fuzz_target_init:
   90|      2|{
   91|      2|    (void)argc;
   92|      2|    (void)argv;
   93|      2|    fuzz_init_r();
   94|       |
   95|       |    /* Reusable text container -- each iteration swaps its CHARSXP. */
   96|      2|    Rf_protect(x_text = Rf_allocVector(STRSXP, 1));
  ------------------
  |  |  126|      2|#define STRSXP	    16	  /* string vectors */
  ------------------
   97|       |
   98|     34|    for (int i = 0; i < N_CALLS; i++) {
  ------------------
  |  |   30|     34|#define N_CALLS 16
  ------------------
  |  Branch (98:21): [True: 32, False: 2]
  ------------------
   99|     32|        SEXP wrapper;
  100|     32|        Rf_protect(wrapper = fuzz_make_wrapper(sources[i]));
  101|     32|        Rf_protect(calls[i] = Rf_lang2(wrapper, x_text));
  102|     32|    }
  103|       |
  104|      2|    fuzz_label_calls(calls, N_CALLS);
  ------------------
  |  |   30|      2|#define N_CALLS 16
  ------------------
  105|       |
  106|       |    /* Warmup: load grDevices and the colour name table. */
  107|      2|    SET_STRING_ELT(x_text, 0, Rf_mkChar("red\n#FF000080\n3\n0.5\ntransparent"));
  108|     34|    for (int i = 0; i < N_CALLS; i++)
  ------------------
  |  |   30|     34|#define N_CALLS 16
  ------------------
  |  Branch (108:21): [True: 32, False: 2]
  ------------------
  109|     32|        fuzz_eval_silent(calls[i], R_GlobalEnv);
  110|       |
  111|      2|    return 0;
  112|      2|}
fuzz_target_run:
  115|  1.85k|{
  116|  1.85k|    if (size < 2 || size > FUZZ_MAX_INPUT || memchr(data + 1, '\0', size - 1))
  ------------------
  |  |   29|  3.71k|#define FUZZ_MAX_INPUT (1024 * 16)
  ------------------
  |  Branch (116:9): [True: 4, False: 1.85k]
  |  Branch (116:21): [True: 10, False: 1.84k]
  |  Branch (116:46): [True: 2, False: 1.84k]
  ------------------
  117|     16|        return 0;
  118|       |
  119|  1.84k|    char buffer[FUZZ_MAX_INPUT];
  120|  1.84k|    memcpy(buffer, data + 1, size - 1);
  121|  1.84k|    buffer[size - 1] = '\0';
  122|  1.84k|    if (!fuzz_set_string(x_text, buffer))
  ------------------
  |  Branch (122:9): [True: 0, False: 1.84k]
  ------------------
  123|      0|        return 0;
  124|       |
  125|  1.84k|    fuzz_eval_silent(calls[data[0] % N_CALLS], R_GlobalEnv);
  ------------------
  |  |   30|  1.84k|#define N_CALLS 16
  ------------------
  126|  1.84k|    return 0;
  127|  1.84k|}

LLVMFuzzerInitialize:
  913|      2|{
  914|       |    /* libFuzzer parses this itself; the alarm wrapper needs the value. */
  915|     11|    for (int i = 1; i < *argc; i++) {
  ------------------
  |  Branch (915:21): [True: 9, False: 2]
  ------------------
  916|      9|        const char *arg = (*argv)[i];
  917|      9|        if (strncmp(arg, "-timeout=", 9) == 0)
  ------------------
  |  Branch (917:13): [True: 2, False: 7]
  ------------------
  918|      2|            fuzz_alarm.timeout = atoi(arg + 9);
  919|      9|    }
  920|       |
  921|      2|    fuzz_init_job_t job = { argc, argv, 0 };
  922|      2|    fuzz_run_on_r_thread(fuzz_do_target_init, &job);
  923|      2|    return job.result;
  924|      2|}
LLVMFuzzerTestOneInput:
  927|  1.85k|{
  928|  1.85k|    fuzz_alarm_wrap();
  929|       |
  930|  1.85k|    fuzz_run_job_t job = { data, size, 0 };
  931|  1.85k|    fuzz_run_on_r_thread(fuzz_do_target_run, &job);
  932|  1.85k|    return job.result;
  933|  1.85k|}
colors.c:fuzz_run_on_r_thread:
  540|  1.85k|{
  541|  1.85k|    if (!fuzz_r_thread.started) {
  ------------------
  |  Branch (541:9): [True: 2, False: 1.85k]
  ------------------
  542|      2|        static int atfork_registered = 0;
  543|      2|        if (!atfork_registered) {
  ------------------
  |  Branch (543:13): [True: 2, False: 0]
  ------------------
  544|      2|            if (pthread_atfork(NULL, NULL, fuzz_r_thread_forget) != 0) {
  ------------------
  |  Branch (544:17): [True: 0, False: 2]
  ------------------
  545|      0|                fprintf(stderr, "fuzz: cannot register the fork handler\n");
  546|      0|                abort();
  547|      0|            }
  548|      2|            atfork_registered = 1;
  549|      2|        }
  550|       |
  551|      2|        pthread_attr_t attr;
  552|      2|        if (pthread_attr_init(&attr) != 0 ||
  ------------------
  |  Branch (552:13): [True: 0, False: 2]
  ------------------
  553|      2|            pthread_attr_setstacksize(&attr, FUZZ_R_STACK_SIZE) != 0 ||
  ------------------
  |  |  172|      2|# define FUZZ_R_STACK_SIZE ((size_t)1 << 30)
  ------------------
  |  Branch (553:13): [True: 0, False: 2]
  ------------------
  554|      2|            pthread_create(&fuzz_r_thread.thread, &attr,
  ------------------
  |  Branch (554:13): [True: 0, False: 2]
  ------------------
  555|      2|                           fuzz_r_thread_main, NULL) != 0) {
  556|      0|            fprintf(stderr, "fuzz: cannot start the R thread\n");
  557|      0|            abort();
  558|      0|        }
  559|      2|        pthread_attr_destroy(&attr);
  560|      2|        fuzz_r_thread.started = 1;
  561|      2|    }
  562|       |
  563|  1.85k|    if (fuzz_on_r_thread()) {
  ------------------
  |  Branch (563:9): [True: 0, False: 1.85k]
  ------------------
  564|      0|        fn(arg);
  565|      0|        return;
  566|      0|    }
  567|       |
  568|  1.85k|    fuzz_job_t job = { fn, arg };
  569|  1.85k|    if (atomic_fetch_add(&fuzz_alarm.input, 1) + 1 == 0)
  ------------------
  |  Branch (569:9): [True: 0, False: 1.85k]
  ------------------
  570|  1.85k|        atomic_fetch_add(&fuzz_alarm.input, 1);  /* wrapped past 0, which is none */
  571|       |
  572|  1.85k|    pthread_mutex_lock(&fuzz_r_thread.mutex);
  573|  1.85k|    fuzz_r_thread.job = &job;
  574|  1.85k|    pthread_cond_broadcast(&fuzz_r_thread.cond);
  575|  3.71k|    while (fuzz_r_thread.job != NULL)
  ------------------
  |  Branch (575:12): [True: 1.85k, False: 1.85k]
  ------------------
  576|  1.85k|        pthread_cond_wait(&fuzz_r_thread.cond, &fuzz_r_thread.mutex);
  577|  1.85k|    pthread_mutex_unlock(&fuzz_r_thread.mutex);
  578|       |
  579|       |    /* Idle again: ticks count, and libFuzzer's clock for the next input
  580|       |     * starts after this. */
  581|  1.85k|    atomic_store(&fuzz_alarm.finishing, 0);
  582|       |    clock_gettime(CLOCK_REALTIME, &fuzz_alarm.armed);
  583|  1.85k|}
colors.c:fuzz_r_thread_main:
  480|      2|{
  481|      2|    (void)unused;
  482|       |    /* The frame address rather than a local's: under ASAN an address-taken
  483|       |     * local may sit on the fake stack, nowhere near this thread's stack.
  484|       |     * R_CStackStart matters only once R is initialized; fuzz_init_r()
  485|       |     * sets it again after Rf_initialize_R has overwritten it. */
  486|      2|    fuzz_r_thread.stack_top = (uintptr_t)__builtin_frame_address(0);
  487|      2|    R_CStackStart = fuzz_r_thread.stack_top;
  488|       |
  489|       |    /* libFuzzer's -timeout alarm is acted on only by the thread running
  490|       |     * its loop (the main thread); delivered here it would be ignored and
  491|       |     * the input would run on.  Block it so the kernel cannot pick this
  492|       |     * thread; fuzz_alarm_handler below gets this thread's stack into the
  493|       |     * timeout report instead. */
  494|      2|    sigset_t alarm;
  495|      2|    sigemptyset(&alarm);
  496|      2|    sigaddset(&alarm, SIGALRM);
  497|      2|    pthread_sigmask(SIG_BLOCK, &alarm, NULL);
  498|       |
  499|      2|    pthread_mutex_lock(&fuzz_r_thread.mutex);
  500|  1.86k|    for (;;) {
  501|  3.72k|        while (fuzz_r_thread.job == NULL)
  ------------------
  |  Branch (501:16): [True: 1.85k, False: 1.86k]
  ------------------
  502|  1.85k|            pthread_cond_wait(&fuzz_r_thread.cond, &fuzz_r_thread.mutex);
  503|  1.86k|        fuzz_job_t *job = fuzz_r_thread.job;
  504|  1.86k|        pthread_mutex_unlock(&fuzz_r_thread.mutex);
  505|       |
  506|  1.86k|        clock_gettime(CLOCK_REALTIME, &fuzz_alarm.started);
  507|  1.86k|        atomic_store(&fuzz_alarm.running, 1);
  508|  1.86k|        job->fn(job->arg);
  509|  1.86k|        atomic_store(&fuzz_alarm.running, 0);
  510|       |
  511|  1.86k|        pthread_mutex_lock(&fuzz_r_thread.mutex);
  512|  1.86k|        fuzz_r_thread.job = NULL;
  513|  1.86k|        pthread_cond_broadcast(&fuzz_r_thread.cond);
  514|  1.86k|    }
  515|       |    return NULL;
  516|      2|}
colors.c:fuzz_on_r_thread:
  519|  1.86k|{
  520|  1.86k|    return fuzz_r_thread.started &&
  ------------------
  |  Branch (520:12): [True: 1.86k, False: 0]
  ------------------
  521|  1.86k|           pthread_equal(pthread_self(), fuzz_r_thread.thread);
  ------------------
  |  Branch (521:12): [True: 2, False: 1.85k]
  ------------------
  522|  1.86k|}
colors.c:fuzz_do_target_init:
  893|      2|{
  894|      2|    fuzz_init_job_t *job = data;
  895|      2|    job->result = fuzz_target_init(job->argc, job->argv);
  896|      2|}
colors.c:fuzz_alarm_wrap:
  454|  1.85k|{
  455|  1.85k|    if (fuzz_alarm.wrapped)
  ------------------
  |  Branch (455:9): [True: 1.85k, False: 1]
  ------------------
  456|  1.85k|        return;
  457|      1|    fuzz_alarm.wrapped = 1;
  458|       |
  459|      1|    struct sigaction current;
  460|      1|    if (sigaction(SIGALRM, NULL, &current) != 0 ||
  ------------------
  |  Branch (460:9): [True: 0, False: 1]
  ------------------
  461|      1|        !(current.sa_flags & SA_SIGINFO) || current.sa_sigaction == NULL)
  ------------------
  |  Branch (461:9): [True: 0, False: 1]
  |  Branch (461:45): [True: 0, False: 1]
  ------------------
  462|      0|        return;  /* no alarm: AFL++'s driver, -timeout=0, tests */
  463|       |
  464|      1|    struct sigaction dump;
  465|      1|    memset(&dump, 0, sizeof dump);
  466|      1|    dump.sa_sigaction = fuzz_dump_handler;
  467|      1|    dump.sa_flags = SA_SIGINFO;
  468|      1|    sigemptyset(&dump.sa_mask);
  469|      1|    if (sigaction(FUZZ_DUMP_SIGNAL, &dump, NULL) != 0)
  ------------------
  |  |  227|      1|# define FUZZ_DUMP_SIGNAL SIGRTMIN   /* untouched by libFuzzer, glibc and R */
  ------------------
  |  Branch (469:9): [True: 0, False: 1]
  ------------------
  470|      0|        return;
  471|       |
  472|      1|    fuzz_alarm.chain = current;
  473|      1|    struct sigaction wrapper = current;
  474|      1|    wrapper.sa_sigaction = fuzz_alarm_handler;
  475|      1|    if (sigaction(SIGALRM, &wrapper, NULL) != 0)
  ------------------
  |  Branch (475:9): [True: 0, False: 1]
  ------------------
  476|      0|        sigaction(FUZZ_DUMP_SIGNAL, &(struct sigaction){ .sa_handler = SIG_DFL }, NULL);
  ------------------
  |  |  227|      0|# define FUZZ_DUMP_SIGNAL SIGRTMIN   /* untouched by libFuzzer, glibc and R */
  ------------------
  477|      1|}
colors.c:fuzz_alarm_handler:
  405|      1|{
  406|      1|    if (atomic_load(&fuzz_alarm.finishing))
  ------------------
  |  Branch (406:9): [True: 0, False: 1]
  ------------------
  407|      0|        return;
  408|       |
  409|      1|    if (atomic_load(&fuzz_alarm.running) &&
  ------------------
  |  Branch (409:9): [True: 1, False: 0]
  ------------------
  410|      1|        fuzz_seconds_since(&fuzz_alarm.armed) >= fuzz_alarm.timeout - 1) {
  ------------------
  |  Branch (410:9): [True: 0, False: 1]
  ------------------
  411|      0|        struct timespec tick = { 0, fuzz_alarm.poll_ns };
  412|       |
  413|       |        /* Hold until the input is out of time by its own clock as well;
  414|       |         * one that finishes first, even in the last sleep, was within
  415|       |         * its time.  The clock is read before the input is looked at, so
  416|       |         * an input seen running was running at a moment past the
  417|       |         * timeout, whatever delay falls between the two. */
  418|      0|        for (;;) {
  419|      0|            long age = fuzz_seconds_since(&fuzz_alarm.started);
  420|      0|            if (!atomic_load(&fuzz_alarm.running)) {
  ------------------
  |  Branch (420:17): [True: 0, False: 0]
  ------------------
  421|      0|                atomic_store(&fuzz_alarm.finishing, 1);
  422|      0|                return;
  423|      0|            }
  424|      0|            if (age >= fuzz_alarm.timeout)
  ------------------
  |  Branch (424:17): [True: 0, False: 0]
  ------------------
  425|      0|                break;
  426|      0|            nanosleep(&tick, NULL);
  427|      0|        }
  428|       |
  429|      0|        unsigned input = atomic_load(&fuzz_alarm.input);
  430|      0|        if (atomic_load(&fuzz_alarm.requested) != input) {
  ------------------
  |  Branch (430:13): [True: 0, False: 0]
  ------------------
  431|      0|            atomic_store(&fuzz_alarm.requested, input);
  432|      0|            fuzz_write_stderr("==fuzz== R thread, where the input is running:\n");
  433|      0|            if (pthread_kill(fuzz_r_thread.thread, FUZZ_DUMP_SIGNAL) != 0)
  ------------------
  |  |  227|      0|# define FUZZ_DUMP_SIGNAL SIGRTMIN   /* untouched by libFuzzer, glibc and R */
  ------------------
  |  Branch (433:17): [True: 0, False: 0]
  ------------------
  434|      0|                atomic_store(&fuzz_alarm.done, input);
  435|      0|        }
  436|       |
  437|       |        /* Symbolizing takes a moment; a thread that never answers (stuck
  438|       |         * in the allocator, say) must not hold up the report, and an
  439|       |         * input finishing now is reported all the same: it was out of
  440|       |         * time already. */
  441|      0|        for (int i = 0; i < 5000; i++) {
  ------------------
  |  Branch (441:25): [True: 0, False: 0]
  ------------------
  442|      0|            if (atomic_load(&fuzz_alarm.done) == input ||
  ------------------
  |  Branch (442:17): [True: 0, False: 0]
  ------------------
  443|      0|                !atomic_load(&fuzz_alarm.running))
  ------------------
  |  Branch (443:17): [True: 0, False: 0]
  ------------------
  444|      0|                break;
  445|      0|            nanosleep(&tick, NULL);
  446|      0|        }
  447|      0|    }
  448|      1|    fuzz_alarm.chain.sa_sigaction(sig, info, context);
  449|      1|}
colors.c:fuzz_seconds_since:
  393|      1|{
  394|      1|    struct timespec now;
  395|      1|    clock_gettime(CLOCK_REALTIME, &now);
  396|       |
  397|      1|    long seconds = now.tv_sec - then->tv_sec;
  398|      1|    if (now.tv_nsec < then->tv_nsec)
  ------------------
  |  Branch (398:9): [True: 0, False: 1]
  ------------------
  399|      0|        seconds--;
  400|      1|    return seconds;
  401|      1|}
colors.c:fuzz_do_target_run:
  905|  1.85k|{
  906|  1.85k|    fuzz_run_job_t *job = data;
  907|  1.85k|    atomic_store(&fuzz_label_current, -1);
  908|  1.85k|    job->result = fuzz_target_run(job->data, job->size);
  909|       |    atomic_store(&fuzz_label_current, -1);
  910|  1.85k|}
colors.c:fuzz_init_r:
  596|      2|{
  597|      2|    if (!fuzz_on_r_thread()) {
  ------------------
  |  Branch (597:9): [True: 0, False: 2]
  ------------------
  598|      0|        fprintf(stderr, "fuzz_init_r: must run on the R thread "
  599|      0|                        "(define fuzz_target_init, not LLVMFuzzerInitialize)\n");
  600|      0|        abort();
  601|      0|    }
  602|       |
  603|      2|    fuzz_set_r_home();
  604|      2|    fuzz_set_vsize_limit();
  605|       |
  606|       |    /* GC consistency failures ("untraced old-to-new reference", a node
  607|       |     * with a bad type) are memory corruption, not input errors.  R's
  608|       |     * default is to report and carry on; this makes gc_error() fatal
  609|       |     * (through R_Suicide, which instrumentation/0004 turns into abort)
  610|       |     * so they surface as crashes at the collection that found them. */
  611|      2|    if (getenv("_R_GC_FAIL_ON_ERROR_") == NULL)
  ------------------
  |  Branch (611:9): [True: 1, False: 1]
  ------------------
  612|      1|        setenv("_R_GC_FAIL_ON_ERROR_", "yes", 1);
  613|       |
  614|       |    /* R's SIGSEGV/SIGILL/etc. handlers enter an interactive recovery
  615|       |     * prompt instead of crashing, which would hang the fuzzer.  Telling
  616|       |     * R not to install them (rather than resetting to SIG_DFL after
  617|       |     * init) keeps the sanitizers' own handlers in place, so wild-pointer
  618|       |     * faults still get full ASAN reports and clean deduplication. */
  619|      2|    R_SignalHandlers = 0;
  620|       |
  621|       |    /* The two halves of Rf_initEmbeddedR, with the C stack check fixed
  622|       |     * up in between.  On Linux Rf_initialize_R takes R_CStackStart from
  623|       |     * __libc_stack_end, the main thread's stack, so from this thread
  624|       |     * every R_CheckStack() while setup_Rmainloop loads base would see
  625|       |     * terabytes of usage and R would abort ("unable to initialize the
  626|       |     * JIT").  macOS never sets it when embedded, which hides this
  627|       |     * locally.  Switch the check off for startup, then measure against
  628|       |     * this thread with R's own 5% of headroom for handling the overflow
  629|       |     * error: R_CheckStack() fires as an ordinary R error at
  630|       |     * 0.95 * FUZZ_R_STACK_SIZE rather than the sanitizer catching a fault.
  631|       |     * setup_Rmainloop itself would turn any limit above 100 MB into
  632|       |     * "unlimited", hence setting it after. */
  633|      2|    char *r_argv[] = {"R", "--vanilla", "--no-echo", "--no-restore"};
  634|      2|    int r_argc = sizeof(r_argv) / sizeof(r_argv[0]);
  635|      2|    Rf_initialize_R(r_argc, r_argv);
  636|      2|    R_CStackStart = fuzz_r_thread.stack_top;
  637|      2|    R_CStackLimit = (uintptr_t)-1;
  638|      2|    R_Interactive = TRUE;   /* as Rf_initEmbeddedR */
  639|      2|    setup_Rmainloop();
  640|      2|    R_CStackLimit = (uintptr_t)(0.95 * FUZZ_R_STACK_SIZE);
  ------------------
  |  |  172|      2|# define FUZZ_R_STACK_SIZE ((size_t)1 << 30)
  ------------------
  641|       |
  642|      2|    fuzz_suppress_warnings();
  643|      2|}
colors.c:fuzz_set_r_home:
   71|      2|{
   72|       |    /* Skip if R_HOME is already set (e.g., for local testing) */
   73|      2|    if (getenv("R_HOME") != NULL)
  ------------------
  |  Branch (73:9): [True: 1, False: 1]
  ------------------
   74|      1|        return;
   75|       |
   76|      1|    char exe[PATH_MAX];
   77|      1|    ssize_t len = readlink("/proc/self/exe", exe, sizeof(exe) - 1);
   78|      1|    if (len <= 0)
  ------------------
  |  Branch (78:9): [True: 0, False: 1]
  ------------------
   79|      0|        return;
   80|      1|    exe[len] = '\0';
   81|       |
   82|       |    /* Find the directory containing the binary */
   83|      1|    char *slash = strrchr(exe, '/');
   84|      1|    if (slash == NULL)
  ------------------
  |  Branch (84:9): [True: 0, False: 1]
  ------------------
   85|      0|        return;
   86|      1|    *slash = '\0';
   87|       |
   88|      1|    char r_home[PATH_MAX];
   89|      1|    snprintf(r_home, sizeof(r_home), "%s/r-install/lib/R", exe);
   90|      1|    setenv("R_HOME", r_home, 1);
   91|      1|}
colors.c:fuzz_set_vsize_limit:
  135|      2|{
  136|      2|    if (getenv("R_MAX_VSIZE") == NULL)
  ------------------
  |  Branch (136:9): [True: 1, False: 1]
  ------------------
  137|      1|        setenv("R_MAX_VSIZE", FUZZ_R_MAX_VSIZE, 1);
  ------------------
  |  |  131|      1|# define FUZZ_R_MAX_VSIZE "1Gb"
  ------------------
  138|      2|}
colors.c:fuzz_suppress_warnings:
   53|      2|{
   54|      2|    int error = 0;
   55|      2|    SEXP warn_call;
   56|      2|    Rf_protect(warn_call = Rf_lang2(Rf_install("options"),
   57|      2|                                    Rf_ScalarInteger(-1)));
   58|      2|    SET_TAG(CDR(warn_call), Rf_install("warn"));
   59|      2|    R_tryEval(warn_call, R_GlobalEnv, &error);
   60|      2|    Rf_unprotect(1);
   61|      2|}
colors.c:fuzz_make_wrapper:
  709|     32|{
  710|     32|    ParseStatus status;
  711|     32|    SEXP text, parsed, wrapper;
  712|     32|    Rf_protect(text = Rf_mkString(source));
  713|     32|    Rf_protect(parsed = R_ParseVector(text, -1, &status, R_NilValue));
  714|     32|    if (status != PARSE_OK || XLENGTH(parsed) != 1)
  ------------------
  |  Branch (714:9): [True: 0, False: 32]
  |  Branch (714:31): [True: 0, False: 32]
  ------------------
  715|      0|        abort();
  716|       |
  717|     32|    wrapper = Rf_eval(VECTOR_ELT(parsed, 0), R_BaseEnv);
  718|     32|    Rf_unprotect(2);
  719|     32|    return wrapper;
  720|     32|}
colors.c:fuzz_label_calls:
  356|      2|{
  357|     34|    for (int i = 0; i < n; i++)
  ------------------
  |  Branch (357:21): [True: 32, False: 2]
  ------------------
  358|     32|        fuzz_label_call(calls[i], i, n);
  359|      2|}
colors.c:fuzz_label_call:
  314|     32|{
  315|     32|    if (call == NULL || call == R_NilValue)
  ------------------
  |  Branch (315:9): [True: 0, False: 32]
  |  Branch (315:25): [True: 0, False: 32]
  ------------------
  316|      0|        return;
  317|       |
  318|       |    /* A call shared by several slots (run under different settings, say)
  319|       |     * keeps one label naming them all. */
  320|    272|    for (int i = 0; i < fuzz_n_labels; i++) {
  ------------------
  |  Branch (320:21): [True: 240, False: 32]
  ------------------
  321|    240|        if (fuzz_labels[i].call != call)
  ------------------
  |  Branch (321:13): [True: 240, False: 0]
  ------------------
  322|    240|            continue;
  323|      0|        char *old = fuzz_labels[i].text;
  324|      0|        char *of = strstr(old, " of ");  /* "==fuzz== slot 7 of 9:" */
  325|      0|        size_t size = strlen(old) + 32;
  326|      0|        char *buf = malloc(size);
  327|      0|        if (of == NULL || buf == NULL) {
  ------------------
  |  Branch (327:13): [True: 0, False: 0]
  |  Branch (327:27): [True: 0, False: 0]
  ------------------
  328|      0|            free(buf);
  329|      0|            return;
  330|      0|        }
  331|      0|        snprintf(buf, size, "%.*s, %d%s", (int)(of - old), old, slot, of);
  332|      0|        fuzz_labels[i].text = buf;
  333|      0|        free(old);
  334|      0|        return;
  335|      0|    }
  336|     32|    if (fuzz_n_labels == FUZZ_MAX_LABELS)
  ------------------
  |  |  266|     32|#define FUZZ_MAX_LABELS 128
  ------------------
  |  Branch (336:9): [True: 0, False: 32]
  ------------------
  337|      0|        return;
  338|       |
  339|     32|    char *buf = malloc(FUZZ_LABEL_MAX);
  ------------------
  |  |  267|     32|#define FUZZ_LABEL_MAX 4096
  ------------------
  340|     32|    if (buf == NULL)
  ------------------
  |  Branch (340:9): [True: 0, False: 32]
  ------------------
  341|      0|        return;
  342|     32|    int n = snprintf(buf, FUZZ_LABEL_MAX, "==fuzz== slot %d of %d:\n", slot, n_slots);
  ------------------
  |  |  267|     32|#define FUZZ_LABEL_MAX 4096
  ------------------
  343|       |
  344|       |    /* A failed deparse leaves the header alone. */
  345|     32|    fuzz_deparse_job_t job = { call, buf, (size_t)n };
  346|     32|    R_ToplevelExec(fuzz_do_deparse, &job);
  347|       |
  348|     32|    fuzz_labels[fuzz_n_labels].call = call;
  349|     32|    fuzz_labels[fuzz_n_labels].text = buf;
  350|     32|    fuzz_n_labels++;
  351|     32|}
colors.c:fuzz_do_deparse:
  298|     32|{
  299|     32|    fuzz_deparse_job_t *job = data;
  300|     32|    SEXP quoted, expr, lines;
  301|     32|    Rf_protect(quoted = Rf_lang2(R_QuoteSymbol, job->call));
  302|     32|    Rf_protect(expr = Rf_lang2(Rf_install("deparse"), quoted));
  303|     32|    Rf_protect(lines = Rf_eval(expr, R_BaseEnv));
  304|    258|    for (R_xlen_t i = 0; i < XLENGTH(lines); i++) {
  ------------------
  |  Branch (304:26): [True: 226, False: 32]
  ------------------
  305|    226|        if (!fuzz_label_append_line(job, CHAR(STRING_ELT(lines, i)))) {
  ------------------
  |  |  203|    226|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (305:13): [True: 0, False: 226]
  ------------------
  306|      0|            memcpy(job->buf + job->len, "    ...\n", sizeof "    ...\n");
  307|      0|            break;
  308|      0|        }
  309|    226|    }
  310|     32|    Rf_unprotect(3);
  311|     32|}
colors.c:fuzz_label_append_line:
  285|    226|{
  286|    226|    size_t n = strlen(line);
  287|    226|    if (job->len + 4 + n + 1 >= FUZZ_LABEL_MAX - sizeof "    ...\n")
  ------------------
  |  |  267|    226|#define FUZZ_LABEL_MAX 4096
  ------------------
  |  Branch (287:9): [True: 0, False: 226]
  ------------------
  288|      0|        return 0;
  289|    226|    memcpy(job->buf + job->len, "    ", 4);
  290|    226|    memcpy(job->buf + job->len + 4, line, n);
  291|    226|    job->buf[job->len + 4 + n] = '\n';
  292|    226|    job->len += 4 + n + 1;
  293|    226|    job->buf[job->len] = '\0';
  294|    226|    return 1;
  295|    226|}
colors.c:fuzz_eval_silent:
  667|  1.87k|{
  668|  1.87k|    int error = 0;
  669|  1.87k|    fuzz_label_enter(call);
  670|  1.87k|    R_tryEvalSilent(call, env, &error);
  671|  1.87k|}
colors.c:fuzz_label_enter:
  363|  1.87k|{
  364|  1.87k|    int found = -1;
  365|  21.0k|    for (int i = 0; i < fuzz_n_labels; i++) {
  ------------------
  |  Branch (365:21): [True: 21.0k, False: 0]
  ------------------
  366|  21.0k|        if (fuzz_labels[i].call == call) {
  ------------------
  |  Branch (366:13): [True: 1.87k, False: 19.1k]
  ------------------
  367|  1.87k|            found = i;
  368|  1.87k|            break;
  369|  1.87k|        }
  370|  21.0k|    }
  371|       |    atomic_store(&fuzz_label_current, found);
  372|  1.87k|}
colors.c:fuzz_set_string:
  694|  1.84k|{
  695|  1.84k|    fuzz_string_data_t sd = { vec, str };
  696|  1.84k|    return R_ToplevelExec(fuzz_do_set_string, &sd);
  697|  1.84k|}
colors.c:fuzz_do_set_string:
  688|  1.84k|{
  689|  1.84k|    fuzz_string_data_t *sd = (fuzz_string_data_t *)data;
  690|  1.84k|    SET_STRING_ELT(sd->vec, 0, Rf_mkChar(sd->str));
  691|  1.84k|}

tre_regcompb:
  135|    206|{
  136|    206|  int ret;
  137|    206|  tre_char_t *wregex;
  138|    206|  size_t wlen, n = strlen(regex);
  139|    206|  unsigned int i;
  140|    206|  const unsigned char *str = (const unsigned char *)regex;
  141|    206|  tre_char_t *wstr;
  142|       |
  143|    206|  wregex = xmalloc(sizeof(tre_char_t) * (n + 1));
  ------------------
  |  |   67|    206|#define xmalloc(size) malloc(size)
  ------------------
  144|    206|  if (wregex == NULL) return REG_ESPACE;
  ------------------
  |  Branch (144:7): [True: 0, False: 206]
  ------------------
  145|    206|  wstr = wregex;
  146|       |
  147|  3.17k|  for (i = 0; i < n; i++) *(wstr++) = *(str++);
  ------------------
  |  Branch (147:15): [True: 2.97k, False: 206]
  ------------------
  148|    206|  wlen = n;
  149|    206|  wregex[wlen] = L'\0';
  150|    206|  ret = tre_compile(preg, wregex, wlen, cflags | REG_USEBYTES);
  ------------------
  |  |  109|    206|#define REG_USEBYTES    (REG_UNGREEDY << 1)
  |  |  ------------------
  |  |  |  |  107|    206|#define REG_UNGREEDY    (REG_RIGHT_ASSOC << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  106|    206|#define REG_RIGHT_ASSOC (REG_LITERAL << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  105|    206|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  101|    206|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  100|    206|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   99|    206|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   98|    206|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  151|    206|  xfree(wregex);
  ------------------
  |  |   69|    206|#define xfree(ptr) free(ptr)
  ------------------
  152|    206|  return ret;
  153|    206|}
tre_regfree:
  172|    206|{
  173|    206|  tre_free(preg);
  174|    206|}

tre_fill_pmatch:
   62|    528|{
   63|    528|  tre_submatch_data_t *submatch_data;
   64|    528|  unsigned int i, j;
   65|    528|  int *parents;
   66|       |
   67|    528|  i = 0;
   68|    528|  if (match_eo >= 0 && !(cflags & REG_NOSUB))
  ------------------
  |  |  101|    528|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  ------------------
  |  |  |  |  100|    528|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   99|    528|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   98|    528|#define REG_EXTENDED	1
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (68:7): [True: 528, False: 0]
  |  Branch (68:24): [True: 180, False: 348]
  ------------------
   69|    180|    {
   70|       |      /* Construct submatch offsets from the tags. */
   71|    180|      DPRINT(("end tag = t%d = %d\n", tnfa->end_tag, match_eo));
  ------------------
  |  |   27|    180|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 180]
  |  |  ------------------
  ------------------
   72|    180|      submatch_data = tnfa->submatch_data;
   73|    378|      while (i < tnfa->num_submatches && i < nmatch)
  ------------------
  |  Branch (73:14): [True: 198, False: 180]
  |  Branch (73:42): [True: 198, False: 0]
  ------------------
   74|    198|	{
   75|    198|	  if (submatch_data[i].so_tag == tnfa->end_tag)
  ------------------
  |  Branch (75:8): [True: 0, False: 198]
  ------------------
   76|      0|	    pmatch[i].rm_so = match_eo;
   77|    198|	  else
   78|    198|	    pmatch[i].rm_so = tags[submatch_data[i].so_tag];
   79|       |
   80|    198|	  if (submatch_data[i].eo_tag == tnfa->end_tag)
  ------------------
  |  Branch (80:8): [True: 192, False: 6]
  ------------------
   81|    192|	    pmatch[i].rm_eo = match_eo;
   82|      6|	  else
   83|      6|	    pmatch[i].rm_eo = tags[submatch_data[i].eo_tag];
   84|       |
   85|       |	  /* If either of the endpoints were not used, this submatch
   86|       |	     was not part of the match. */
   87|    198|	  if (pmatch[i].rm_so == -1 || pmatch[i].rm_eo == -1)
  ------------------
  |  Branch (87:8): [True: 2, False: 196]
  |  Branch (87:33): [True: 0, False: 196]
  ------------------
   88|      2|	    pmatch[i].rm_so = pmatch[i].rm_eo = -1;
   89|       |
   90|    198|	  DPRINT(("pmatch[%d] = {t%d = %d, t%d = %d}\n", i,
  ------------------
  |  |   27|    198|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 198]
  |  |  ------------------
  ------------------
   91|    198|		  submatch_data[i].so_tag, pmatch[i].rm_so,
   92|    198|		  submatch_data[i].eo_tag, pmatch[i].rm_eo));
   93|    198|	  i++;
   94|    198|	}
   95|       |      /* Reset all submatches that are not within all of their parent
   96|       |	 submatches. */
   97|    180|      i = 0;
   98|    378|      while (i < tnfa->num_submatches && i < nmatch)
  ------------------
  |  Branch (98:14): [True: 198, False: 180]
  |  Branch (98:42): [True: 198, False: 0]
  ------------------
   99|    198|	{
  100|    198|	  if (pmatch[i].rm_eo == -1)
  ------------------
  |  Branch (100:8): [True: 2, False: 196]
  ------------------
  101|    198|	    assert(pmatch[i].rm_so == -1);
  ------------------
  |  |   55|      2|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|      2|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  102|    198|	  assert(pmatch[i].rm_so <= pmatch[i].rm_eo);
  ------------------
  |  |   55|    198|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|    198|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [True: 198, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  103|       |
  104|    198|	  parents = submatch_data[i].parents;
  105|    198|	  if (parents != NULL)
  ------------------
  |  Branch (105:8): [True: 18, False: 180]
  ------------------
  106|     36|	    for (j = 0; parents[j] >= 0; j++)
  ------------------
  |  Branch (106:18): [True: 18, False: 18]
  ------------------
  107|     18|	      {
  108|     18|		DPRINT(("pmatch[%d] parent %d\n", i, parents[j]));
  ------------------
  |  |   27|     18|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 18]
  |  |  ------------------
  ------------------
  109|     18|		if (pmatch[i].rm_so < pmatch[parents[j]].rm_so
  ------------------
  |  Branch (109:7): [True: 2, False: 16]
  ------------------
  110|     16|		    || pmatch[i].rm_eo > pmatch[parents[j]].rm_eo)
  ------------------
  |  Branch (110:10): [True: 0, False: 16]
  ------------------
  111|      2|		  pmatch[i].rm_so = pmatch[i].rm_eo = -1;
  112|     18|	      }
  113|    198|	  i++;
  114|    198|	}
  115|    180|    }
  116|       |
  117|    726|  while (i < nmatch)
  ------------------
  |  Branch (117:10): [True: 198, False: 528]
  ------------------
  118|    198|    {
  119|    198|      pmatch[i].rm_so = -1;
  120|    198|      pmatch[i].rm_eo = -1;
  121|    198|      i++;
  122|    198|    }
  123|    528|}
tre_regexecb:
  232|  4.86k|{
  233|  4.86k|  tre_tnfa_t *tnfa = (void *)preg->TRE_REGEX_T_FIELD;
  ------------------
  |  |   15|  4.86k|#define TRE_REGEX_T_FIELD value
  ------------------
  234|       |
  235|  4.86k|  return tre_match(tnfa, str, (unsigned)-1, STR_BYTE, nmatch, pmatch, eflags);
  236|  4.86k|}
regexec.c:tre_match:
  148|  4.86k|{
  149|  4.86k|  reg_errcode_t status;
  150|  4.86k|  int *tags = NULL, eo;
  151|  4.86k|  if (tnfa->num_tags > 0 && nmatch > 0)
  ------------------
  |  Branch (151:7): [True: 278, False: 4.58k]
  |  Branch (151:29): [True: 278, False: 0]
  ------------------
  152|    278|    {
  153|       |#ifdef TRE_USE_ALLOCA
  154|       |      tags = alloca(sizeof(*tags) * tnfa->num_tags);
  155|       |#else /* !TRE_USE_ALLOCA */
  156|    278|      tags = xmalloc(sizeof(*tags) * tnfa->num_tags);
  ------------------
  |  |   67|    278|#define xmalloc(size) malloc(size)
  ------------------
  157|    278|#endif /* !TRE_USE_ALLOCA */
  158|    278|      if (tags == NULL)
  ------------------
  |  Branch (158:11): [True: 0, False: 278]
  ------------------
  159|      0|	return REG_ESPACE;
  160|    278|    }
  161|       |
  162|       |  /* Dispatch to the appropriate matcher. */
  163|  4.86k|  if (tnfa->have_backrefs || eflags & REG_BACKTRACKING_MATCHER)
  ------------------
  |  |  117|  4.86k|#define REG_BACKTRACKING_MATCHER (REG_APPROX_MATCHER << 1)
  |  |  ------------------
  |  |  |  |  116|  4.86k|#define REG_APPROX_MATCHER	 (REG_NOTEOL << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  113|  4.86k|#define REG_NOTEOL (REG_NOTBOL << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|  4.86k|#define REG_NOTBOL 1
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (163:7): [True: 0, False: 4.86k]
  |  Branch (163:30): [True: 0, False: 4.86k]
  ------------------
  164|      0|    {
  165|       |      /* The regex has back references, use the backtracking matcher. */
  166|      0|      if (type == STR_USER)
  ------------------
  |  Branch (166:11): [True: 0, False: 0]
  ------------------
  167|      0|	{
  168|      0|	  const tre_str_source *source = string;
  169|      0|	  if (source->rewind == NULL || source->compare == NULL) {
  ------------------
  |  Branch (169:8): [True: 0, False: 0]
  |  Branch (169:34): [True: 0, False: 0]
  ------------------
  170|       |	    /* The backtracking matcher requires rewind and compare
  171|       |	       capabilities from the input stream. */
  172|      0|#ifndef TRE_USE_ALLOCA
  173|      0|	    if (tags)
  ------------------
  |  Branch (173:10): [True: 0, False: 0]
  ------------------
  174|      0|		xfree(tags);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
  175|      0|#endif /* !TRE_USE_ALLOCA */
  176|      0|	    return REG_BADPAT;
  177|      0|	  }
  178|      0|	}
  179|      0|      status = tre_tnfa_run_backtrack(tnfa, string, (int)len, type,
  180|      0|				      tags, eflags, &eo);
  181|      0|    }
  182|  4.86k|#ifdef TRE_APPROX
  183|  4.86k|  else if (tnfa->have_approx || eflags & REG_APPROX_MATCHER)
  ------------------
  |  |  116|  4.86k|#define REG_APPROX_MATCHER	 (REG_NOTEOL << 1)
  |  |  ------------------
  |  |  |  |  113|  4.86k|#define REG_NOTEOL (REG_NOTBOL << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|  4.86k|#define REG_NOTBOL 1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (183:12): [True: 0, False: 4.86k]
  |  Branch (183:33): [True: 0, False: 4.86k]
  ------------------
  184|      0|    {
  185|       |      /* The regex uses approximate matching, use the approximate matcher. */
  186|      0|      regamatch_t match;
  187|      0|      regaparams_t params;
  188|      0|      tre_regaparams_default(&params);
  189|      0|      params.max_err = 0;
  190|      0|      params.max_cost = 0;
  191|      0|      status = tre_tnfa_run_approx(tnfa, string, (int)len, type, tags,
  192|      0|				   &match, params, eflags, &eo);
  193|      0|    }
  194|  4.86k|#endif /* TRE_APPROX */
  195|  4.86k|  else
  196|  4.86k|    {
  197|       |      /* Exact matching, no back references, use the parallel matcher. */
  198|  4.86k|      status = tre_tnfa_run_parallel(tnfa, string, (int)len, type,
  199|  4.86k|				     tags, eflags, &eo);
  200|  4.86k|    }
  201|       |
  202|  4.86k|  if (status == REG_OK)
  ------------------
  |  Branch (202:7): [True: 528, False: 4.33k]
  ------------------
  203|       |    /* A match was found, so fill the submatch registers. */
  204|    528|    tre_fill_pmatch(nmatch, pmatch, tnfa->cflags, tnfa, tags, eo);
  205|  4.86k|#ifndef TRE_USE_ALLOCA
  206|  4.86k|  if (tags)
  ------------------
  |  Branch (206:7): [True: 278, False: 4.58k]
  ------------------
  207|    278|    xfree(tags);
  ------------------
  |  |   69|    278|#define xfree(ptr) free(ptr)
  ------------------
  208|  4.86k|#endif /* !TRE_USE_ALLOCA */
  209|  4.86k|  return status;
  210|  4.86k|}

tre_ast_new_node:
   20|  2.99k|{
   21|  2.99k|  tre_ast_node_t *node;
   22|       |
   23|  2.99k|  node = tre_mem_calloc(mem, sizeof(*node));
  ------------------
  |  |   45|  2.99k|#define tre_mem_calloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 1, size)
  ------------------
   24|  2.99k|  if (!node)
  ------------------
  |  Branch (24:7): [True: 0, False: 2.99k]
  ------------------
   25|      0|    return NULL;
   26|  2.99k|  node->obj = tre_mem_calloc(mem, size);
  ------------------
  |  |   45|  2.99k|#define tre_mem_calloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 1, size)
  ------------------
   27|  2.99k|  if (!node->obj)
  ------------------
  |  Branch (27:7): [True: 0, False: 2.99k]
  ------------------
   28|      0|    return NULL;
   29|  2.99k|  node->type = type;
   30|  2.99k|  node->nullable = -1;
   31|  2.99k|  node->submatch_id = -1;
   32|       |
   33|  2.99k|  return node;
   34|  2.99k|}
tre_ast_new_literal:
   38|  1.70k|{
   39|  1.70k|  tre_ast_node_t *node;
   40|  1.70k|  tre_literal_t *lit;
   41|       |
   42|  1.70k|  node = tre_ast_new_node(mem, LITERAL, sizeof(tre_literal_t));
   43|  1.70k|  if (!node)
  ------------------
  |  Branch (43:7): [True: 0, False: 1.70k]
  ------------------
   44|      0|    return NULL;
   45|  1.70k|  lit = node->obj;
   46|  1.70k|  lit->code_min = code_min;
   47|  1.70k|  lit->code_max = code_max;
   48|  1.70k|  lit->position = position;
   49|       |
   50|  1.70k|  return node;
   51|  1.70k|}
tre_ast_new_iter:
   56|    219|{
   57|    219|  tre_ast_node_t *node;
   58|    219|  tre_iteration_t *iter;
   59|       |
   60|    219|  node = tre_ast_new_node(mem, ITERATION, sizeof(tre_iteration_t));
   61|    219|  if (!node)
  ------------------
  |  Branch (61:7): [True: 0, False: 219]
  ------------------
   62|      0|    return NULL;
   63|    219|  iter = node->obj;
   64|    219|  iter->arg = arg;
   65|    219|  iter->min = min;
   66|    219|  iter->max = max;
   67|    219|  iter->minimal = minimal;
   68|    219|  node->num_submatches = arg->num_submatches;
   69|       |
   70|    219|  return node;
   71|    219|}
tre_ast_new_union:
   75|    159|{
   76|    159|  tre_ast_node_t *node;
   77|       |
   78|    159|  node = tre_ast_new_node(mem, UNION, sizeof(tre_union_t));
   79|    159|  if (node == NULL)
  ------------------
  |  Branch (79:7): [True: 0, False: 159]
  ------------------
   80|      0|    return NULL;
   81|    159|  ((tre_union_t *)node->obj)->left = left;
   82|    159|  ((tre_union_t *)node->obj)->right = right;
   83|    159|  node->num_submatches = left->num_submatches + right->num_submatches;
   84|       |
   85|    159|  return node;
   86|    159|}
tre_ast_new_catenation:
   91|    907|{
   92|    907|  tre_ast_node_t *node;
   93|       |
   94|    907|  node = tre_ast_new_node(mem, CATENATION, sizeof(tre_catenation_t));
   95|    907|  if (node == NULL)
  ------------------
  |  Branch (95:7): [True: 0, False: 907]
  ------------------
   96|      0|    return NULL;
   97|    907|  ((tre_catenation_t *)node->obj)->left = left;
   98|    907|  ((tre_catenation_t *)node->obj)->right = right;
   99|       |  // UBSAN warning in clang 10: signed integer overflow
  100|    907|  double tmp = (double)left->num_submatches + (double)right->num_submatches;
  101|    907|  if (tmp >= INT_MIN && tmp <= INT_MAX)
  ------------------
  |  Branch (101:7): [True: 907, False: 0]
  |  Branch (101:25): [True: 907, False: 0]
  ------------------
  102|    907|      node->num_submatches = left->num_submatches + right->num_submatches;
  103|      0|  else node->num_submatches = 0;
  104|       |
  105|    907|  return node;
  106|    907|}

tre_compile:
 1893|    206|{
 1894|    206|  tre_stack_t *stack;
 1895|    206|  tre_ast_node_t *tree, *tmp_ast_l, *tmp_ast_r;
 1896|    206|  tre_pos_and_tags_t *p;
 1897|    206|  int *counts = NULL, *offs = NULL;
 1898|    206|  int i, add = 0;
 1899|    206|  tre_tnfa_transition_t *transitions, *initial;
 1900|    206|  tre_tnfa_t *tnfa = NULL;
 1901|    206|  tre_submatch_data_t *submatch_data;
 1902|    206|  tre_tag_direction_t *tag_directions = NULL;
 1903|    206|  reg_errcode_t errcode;
 1904|    206|  tre_mem_t mem;
 1905|       |
 1906|       |  /* Parse context. */
 1907|    206|  tre_parse_ctx_t parse_ctx;
 1908|       |
 1909|       |  /* Allocate a stack used throughout the compilation process for various
 1910|       |     purposes. */
 1911|    206|  stack = tre_stack_new(512, 10240, 128);
 1912|    206|  if (!stack)
  ------------------
  |  Branch (1912:7): [True: 0, False: 206]
  ------------------
 1913|      0|    return REG_ESPACE;
 1914|       |  /* Allocate a fast memory allocator. */
 1915|    206|  mem = tre_mem_new();
  ------------------
  |  |   36|    206|#define tre_mem_new()  tre_mem_new_impl(0, NULL)
  ------------------
 1916|    206|  if (!mem)
  ------------------
  |  Branch (1916:7): [True: 0, False: 206]
  ------------------
 1917|      0|    {
 1918|      0|      tre_stack_destroy(stack);
 1919|      0|      return REG_ESPACE;
 1920|      0|    }
 1921|       |
 1922|       |  /* Parse the regexp. */
 1923|    206|  memset(&parse_ctx, 0, sizeof(parse_ctx));
 1924|    206|  parse_ctx.mem = mem;
 1925|    206|  parse_ctx.stack = stack;
 1926|    206|  parse_ctx.re = regex;
 1927|    206|  parse_ctx.len = n;
 1928|    206|  parse_ctx.cflags = cflags;
 1929|    206|  parse_ctx.max_backref = -1;
 1930|       |  /* workaround for PR#14408: use 8-bit optimizations in 8-bit mode */
 1931|    206|  parse_ctx.cur_max = (cflags & REG_USEBYTES) ? 1 : TRE_MB_CUR_MAX;
  ------------------
  |  |  109|    206|#define REG_USEBYTES    (REG_UNGREEDY << 1)
  |  |  ------------------
  |  |  |  |  107|    206|#define REG_UNGREEDY    (REG_RIGHT_ASSOC << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  106|    206|#define REG_RIGHT_ASSOC (REG_LITERAL << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  105|    206|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  101|    206|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  100|    206|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   99|    206|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   98|    206|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                parse_ctx.cur_max = (cflags & REG_USEBYTES) ? 1 : TRE_MB_CUR_MAX;
  ------------------
  |  |   68|    206|#define TRE_MB_CUR_MAX MB_CUR_MAX
  ------------------
  |  Branch (1931:23): [True: 206, False: 0]
  ------------------
 1932|    206|  DPRINT(("tre_compile: parsing '%.*" STRF "'\n", (int)n, regex));
  ------------------
  |  |   27|    206|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 206]
  |  |  ------------------
  ------------------
 1933|    206|  errcode = tre_parse(&parse_ctx);
 1934|    206|  if (errcode != REG_OK)
  ------------------
  |  Branch (1934:7): [True: 0, False: 206]
  ------------------
 1935|      0|    ERROR_EXIT(errcode);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1936|    206|  preg->re_nsub = parse_ctx.submatch_id - 1;
 1937|    206|  tree = parse_ctx.result;
 1938|       |
 1939|       |  /* Back references and approximate matching cannot currently be used
 1940|       |     in the same regexp. */
 1941|    206|  if (parse_ctx.max_backref >= 0 && parse_ctx.have_approx)
  ------------------
  |  Branch (1941:7): [True: 0, False: 206]
  |  Branch (1941:37): [True: 0, False: 0]
  ------------------
 1942|      0|    ERROR_EXIT(REG_BADPAT);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1943|       |
 1944|       |#ifdef TRE_DEBUG
 1945|       |  tre_ast_print(tree);
 1946|       |#endif /* TRE_DEBUG */
 1947|       |
 1948|       |  /* Referring to nonexistent subexpressions is illegal. */
 1949|    206|  if (parse_ctx.max_backref > (int)preg->re_nsub)
  ------------------
  |  Branch (1949:7): [True: 0, False: 206]
  ------------------
 1950|      0|    ERROR_EXIT(REG_ESUBREG);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1951|       |
 1952|       |  /* Allocate the TNFA struct. */
 1953|    206|  tnfa = xcalloc(1, sizeof(tre_tnfa_t));
  ------------------
  |  |   68|    206|#define xcalloc(nmemb, size) calloc(nmemb, size)
  ------------------
 1954|    206|  if (tnfa == NULL)
  ------------------
  |  Branch (1954:7): [True: 0, False: 206]
  ------------------
 1955|      0|    ERROR_EXIT(REG_ESPACE);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1956|    206|  tnfa->have_backrefs = parse_ctx.max_backref >= 0;
 1957|    206|  tnfa->have_approx = parse_ctx.have_approx;
 1958|    206|  tnfa->num_submatches = parse_ctx.submatch_id;
 1959|       |
 1960|       |  /* Set up tags for submatch addressing.  If REG_NOSUB is set and the
 1961|       |     regexp does not have back references, this can be skipped. */
 1962|    206|  if (tnfa->have_backrefs || !(cflags & REG_NOSUB))
  ------------------
  |  |  101|    206|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  ------------------
  |  |  |  |  100|    206|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   99|    206|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   98|    206|#define REG_EXTENDED	1
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1962:7): [True: 0, False: 206]
  |  Branch (1962:30): [True: 138, False: 68]
  ------------------
 1963|    138|    {
 1964|    138|      DPRINT(("tre_compile: setting up tags\n"));
  ------------------
  |  |   27|    138|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 138]
  |  |  ------------------
  ------------------
 1965|       |
 1966|       |      /* Figure out how many tags we will need. */
 1967|    138|      errcode = tre_add_tags(NULL, stack, tree, tnfa);
 1968|    138|      if (errcode != REG_OK)
  ------------------
  |  Branch (1968:11): [True: 0, False: 138]
  ------------------
 1969|      0|	ERROR_EXIT(errcode);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1970|       |#ifdef TRE_DEBUG
 1971|       |      tre_ast_print(tree);
 1972|       |#endif /* TRE_DEBUG */
 1973|       |
 1974|    138|      if (tnfa->num_tags > 0)
  ------------------
  |  Branch (1974:11): [True: 138, False: 0]
  ------------------
 1975|    138|	{
 1976|    138|	  tag_directions = xmalloc(sizeof(*tag_directions)
  ------------------
  |  |   67|    138|#define xmalloc(size) malloc(size)
  ------------------
 1977|    138|				   * (tnfa->num_tags + 1));
 1978|    138|	  if (tag_directions == NULL)
  ------------------
  |  Branch (1978:8): [True: 0, False: 138]
  ------------------
 1979|      0|	    ERROR_EXIT(REG_ESPACE);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1980|    138|	  tnfa->tag_directions = tag_directions;
 1981|    138|	  memset(tag_directions, -1,
 1982|    138|		 sizeof(*tag_directions) * (tnfa->num_tags + 1));
 1983|    138|	}
 1984|    138|      tnfa->minimal_tags = xcalloc((unsigned)tnfa->num_tags * 2 + 1,
  ------------------
  |  |   68|    138|#define xcalloc(nmemb, size) calloc(nmemb, size)
  ------------------
 1985|    138|				   sizeof(tnfa->minimal_tags));
 1986|    138|      if (tnfa->minimal_tags == NULL)
  ------------------
  |  Branch (1986:11): [True: 0, False: 138]
  ------------------
 1987|      0|	ERROR_EXIT(REG_ESPACE);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1988|       |
 1989|    138|      submatch_data = xcalloc((unsigned)parse_ctx.submatch_id,
  ------------------
  |  |   68|    138|#define xcalloc(nmemb, size) calloc(nmemb, size)
  ------------------
 1990|    138|			      sizeof(*submatch_data));
 1991|    138|      if (submatch_data == NULL)
  ------------------
  |  Branch (1991:11): [True: 0, False: 138]
  ------------------
 1992|      0|	ERROR_EXIT(REG_ESPACE);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1993|    138|      tnfa->submatch_data = submatch_data;
 1994|       |
 1995|    138|      errcode = tre_add_tags(mem, stack, tree, tnfa);
 1996|    138|      if (errcode != REG_OK)
  ------------------
  |  Branch (1996:11): [True: 0, False: 138]
  ------------------
 1997|      0|	ERROR_EXIT(errcode);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1998|       |
 1999|       |#ifdef TRE_DEBUG
 2000|       |      for (i = 0; i < parse_ctx.submatch_id; i++)
 2001|       |	DPRINT(("pmatch[%d] = {t%d, t%d}\n",
 2002|       |		i, submatch_data[i].so_tag, submatch_data[i].eo_tag));
 2003|       |      for (i = 0; i < tnfa->num_tags; i++)
 2004|       |	DPRINT(("t%d is %s\n", i,
 2005|       |		tag_directions[i] == TRE_TAG_MINIMIZE ?
 2006|       |		"minimized" : "maximized"));
 2007|       |#endif /* TRE_DEBUG */
 2008|    138|    }
 2009|       |
 2010|       |  /* Expand iteration nodes. */
 2011|    206|  errcode = tre_expand_ast(mem, stack, tree, &parse_ctx.position,
 2012|    206|			   tag_directions, &tnfa->params_depth);
 2013|    206|  if (errcode != REG_OK)
  ------------------
  |  Branch (2013:7): [True: 0, False: 206]
  ------------------
 2014|      0|    ERROR_EXIT(errcode);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2015|       |
 2016|       |  /* Add a dummy node for the final state.
 2017|       |     XXX - For certain patterns this dummy node can be optimized away,
 2018|       |	   for example "a*" or "ab*".	Figure out a simple way to detect
 2019|       |	   this possibility. */
 2020|    206|  tmp_ast_l = tree;
 2021|    206|  tmp_ast_r = tre_ast_new_literal(mem, 0, 0, parse_ctx.position++);
 2022|    206|  if (tmp_ast_r == NULL)
  ------------------
  |  Branch (2022:7): [True: 0, False: 206]
  ------------------
 2023|      0|    ERROR_EXIT(REG_ESPACE);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2024|       |
 2025|    206|  tree = tre_ast_new_catenation(mem, tmp_ast_l, tmp_ast_r);
 2026|    206|  if (tree == NULL)
  ------------------
  |  Branch (2026:7): [True: 0, False: 206]
  ------------------
 2027|      0|    ERROR_EXIT(REG_ESPACE);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2028|       |
 2029|       |#ifdef TRE_DEBUG
 2030|       |  tre_ast_print(tree);
 2031|       |  DPRINT(("Number of states: %d\n", parse_ctx.position));
 2032|       |#endif /* TRE_DEBUG */
 2033|       |
 2034|    206|  errcode = tre_compute_nfl(mem, stack, tree);
 2035|    206|  if (errcode != REG_OK)
  ------------------
  |  Branch (2035:7): [True: 0, False: 206]
  ------------------
 2036|      0|    ERROR_EXIT(errcode);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2037|       |
 2038|    206|  counts = xmalloc(sizeof(int) * parse_ctx.position);
  ------------------
  |  |   67|    206|#define xmalloc(size) malloc(size)
  ------------------
 2039|    206|  if (counts == NULL)
  ------------------
  |  Branch (2039:7): [True: 0, False: 206]
  ------------------
 2040|      0|    ERROR_EXIT(REG_ESPACE);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2041|       |
 2042|    206|  offs = xmalloc(sizeof(int) * parse_ctx.position);
  ------------------
  |  |   67|    206|#define xmalloc(size) malloc(size)
  ------------------
 2043|    206|  if (offs == NULL)
  ------------------
  |  Branch (2043:7): [True: 0, False: 206]
  ------------------
 2044|      0|    ERROR_EXIT(REG_ESPACE);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2045|       |
 2046|  1.17k|  for (i = 0; i < parse_ctx.position; i++)
  ------------------
  |  Branch (2046:15): [True: 965, False: 206]
  ------------------
 2047|    965|    counts[i] = 0;
 2048|    206|  tre_ast_to_tnfa(tree, NULL, counts, NULL);
 2049|       |
 2050|    206|  add = 0;
 2051|  1.17k|  for (i = 0; i < parse_ctx.position; i++)
  ------------------
  |  Branch (2051:15): [True: 965, False: 206]
  ------------------
 2052|    965|    {
 2053|    965|      offs[i] = add;
 2054|    965|      add += counts[i] + 1;
 2055|    965|      counts[i] = 0;
 2056|    965|    }
 2057|    206|  transitions = xcalloc((unsigned)add + 1, sizeof(*transitions));
  ------------------
  |  |   68|    206|#define xcalloc(nmemb, size) calloc(nmemb, size)
  ------------------
 2058|    206|  if (transitions == NULL)
  ------------------
  |  Branch (2058:7): [True: 0, False: 206]
  ------------------
 2059|      0|    ERROR_EXIT(REG_ESPACE);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2060|    206|  tnfa->transitions = transitions;
 2061|    206|  tnfa->num_transitions = add;
 2062|       |
 2063|    206|  DPRINT(("Converting to TNFA:\n"));
  ------------------
  |  |   27|    206|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 206]
  |  |  ------------------
  ------------------
 2064|    206|  errcode = tre_ast_to_tnfa(tree, transitions, counts, offs);
 2065|    206|  if (errcode != REG_OK)
  ------------------
  |  Branch (2065:7): [True: 0, False: 206]
  ------------------
 2066|      0|    ERROR_EXIT(errcode);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2067|       |
 2068|       |  /* If in eight bit mode, compute a table of characters that can be the
 2069|       |     first character of a match. */
 2070|    206|  tnfa->first_char = -1;
 2071|    206|  if (TRE_MB_CUR_MAX == 1 && !tmp_ast_l->nullable)
  ------------------
  |  |   68|    206|#define TRE_MB_CUR_MAX MB_CUR_MAX
  ------------------
  |  Branch (2071:7): [True: 206, False: 0]
  |  Branch (2071:30): [True: 206, False: 0]
  ------------------
 2072|    206|    {
 2073|    206|      int count = 0;
 2074|    206|      tre_cint_t k;
 2075|    206|      DPRINT(("Characters that can start a match:"));
  ------------------
  |  |   27|    206|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 206]
  |  |  ------------------
  ------------------
 2076|    206|      tnfa->firstpos_chars = xcalloc(256, sizeof(char));
  ------------------
  |  |   68|    206|#define xcalloc(nmemb, size) calloc(nmemb, size)
  ------------------
 2077|    206|      if (tnfa->firstpos_chars == NULL)
  ------------------
  |  Branch (2077:11): [True: 0, False: 206]
  ------------------
 2078|      0|	ERROR_EXIT(REG_ESPACE);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2079|    573|      for (p = tree->firstpos; p->position >= 0; p++)
  ------------------
  |  Branch (2079:32): [True: 367, False: 206]
  ------------------
 2080|    367|	{
 2081|    367|	  tre_tnfa_transition_t *j = transitions + offs[p->position];
 2082|  1.10k|	  while (j->state != NULL)
  ------------------
  |  Branch (2082:11): [True: 733, False: 367]
  ------------------
 2083|    733|	    {
 2084|  37.8k|	      for (k = j->code_min; k <= j->code_max && k < 256; k++)
  ------------------
  |  Branch (2084:30): [True: 37.2k, False: 597]
  |  Branch (2084:50): [True: 37.1k, False: 136]
  ------------------
 2085|  37.1k|		{
 2086|  37.1k|		  DPRINT((" %d", k));
  ------------------
  |  |   27|  37.1k|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 37.1k]
  |  |  ------------------
  ------------------
 2087|  37.1k|		  tnfa->firstpos_chars[k] = 1;
 2088|  37.1k|		  count++;
 2089|  37.1k|		}
 2090|    733|	      j++;
 2091|    733|	    }
 2092|    367|	}
 2093|    206|      DPRINT(("\n"));
  ------------------
  |  |   27|    206|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 206]
  |  |  ------------------
  ------------------
 2094|    206|#define TRE_OPTIMIZE_FIRST_CHAR 1
 2095|    206|#if TRE_OPTIMIZE_FIRST_CHAR
 2096|    206|      if (count == 1)
  ------------------
  |  Branch (2096:11): [True: 63, False: 143]
  ------------------
 2097|     63|	{
 2098|  4.79k|	  for (k = 0; k < 256; k++)
  ------------------
  |  Branch (2098:16): [True: 4.79k, False: 0]
  ------------------
 2099|  4.79k|	    if (tnfa->firstpos_chars[k])
  ------------------
  |  Branch (2099:10): [True: 63, False: 4.73k]
  ------------------
 2100|     63|	      {
 2101|     63|		DPRINT(("first char must be %d\n", k));
  ------------------
  |  |   27|     63|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 63]
  |  |  ------------------
  ------------------
 2102|     63|		tnfa->first_char = k;
 2103|     63|		xfree(tnfa->firstpos_chars);
  ------------------
  |  |   69|     63|#define xfree(ptr) free(ptr)
  ------------------
 2104|     63|		tnfa->firstpos_chars = NULL;
 2105|     63|		break;
 2106|     63|	      }
 2107|     63|	}
 2108|    206|#endif
 2109|       |
 2110|    206|    }
 2111|      0|  else
 2112|      0|    tnfa->firstpos_chars = NULL;
 2113|       |
 2114|       |
 2115|    206|  p = tree->firstpos;
 2116|    206|  i = 0;
 2117|    573|  while (p->position >= 0)
  ------------------
  |  Branch (2117:10): [True: 367, False: 206]
  ------------------
 2118|    367|    {
 2119|    367|      i++;
 2120|       |
 2121|       |#ifdef TRE_DEBUG
 2122|       |      {
 2123|       |	int *tags;
 2124|       |	DPRINT(("initial: %d", p->position));
 2125|       |	tags = p->tags;
 2126|       |	if (tags != NULL)
 2127|       |	  {
 2128|       |	    if (*tags >= 0)
 2129|       |	      DPRINT(("/"));
 2130|       |	    while (*tags >= 0)
 2131|       |	      {
 2132|       |		DPRINT(("%d", *tags));
 2133|       |		tags++;
 2134|       |		if (*tags >= 0)
 2135|       |		  DPRINT((","));
 2136|       |	      }
 2137|       |	  }
 2138|       |	DPRINT((", assert %d", p->assertions));
 2139|       |	if (p->params)
 2140|       |	  {
 2141|       |	    DPRINT((", "));
 2142|       |	    tre_print_params(p->params);
 2143|       |	  }
 2144|       |	DPRINT(("\n"));
 2145|       |      }
 2146|       |#endif /* TRE_DEBUG */
 2147|       |
 2148|    367|      p++;
 2149|    367|    }
 2150|       |
 2151|    206|  initial = xcalloc((unsigned)i + 1, sizeof(tre_tnfa_transition_t));
  ------------------
  |  |   68|    206|#define xcalloc(nmemb, size) calloc(nmemb, size)
  ------------------
 2152|    206|  if (initial == NULL)
  ------------------
  |  Branch (2152:7): [True: 0, False: 206]
  ------------------
 2153|      0|    ERROR_EXIT(REG_ESPACE);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2154|    206|  tnfa->initial = initial;
 2155|       |
 2156|    206|  i = 0;
 2157|    573|  for (p = tree->firstpos; p->position >= 0; p++)
  ------------------
  |  Branch (2157:28): [True: 367, False: 206]
  ------------------
 2158|    367|    {
 2159|    367|      initial[i].state = transitions + offs[p->position];
 2160|    367|      initial[i].state_id = p->position;
 2161|    367|      initial[i].tags = NULL;
 2162|       |      /* Copy the arrays p->tags, and p->params, they are allocated
 2163|       |	 from a tre_mem object. */
 2164|    367|      if (p->tags)
  ------------------
  |  Branch (2164:11): [True: 363, False: 4]
  ------------------
 2165|    363|	{
 2166|    363|	  int j;
 2167|    807|	  for (j = 0; p->tags[j] >= 0; j++);
  ------------------
  |  Branch (2167:16): [True: 444, False: 363]
  ------------------
 2168|    363|	  initial[i].tags = xmalloc(sizeof(*p->tags) * (j + 1));
  ------------------
  |  |   67|    363|#define xmalloc(size) malloc(size)
  ------------------
 2169|    363|	  if (!initial[i].tags)
  ------------------
  |  Branch (2169:8): [True: 0, False: 363]
  ------------------
 2170|      0|	    ERROR_EXIT(REG_ESPACE);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2171|    363|	  memcpy(initial[i].tags, p->tags, sizeof(*p->tags) * (j + 1));
 2172|    363|	}
 2173|    367|      initial[i].params = NULL;
 2174|    367|      if (p->params)
  ------------------
  |  Branch (2174:11): [True: 0, False: 367]
  ------------------
 2175|      0|	{
 2176|      0|	  initial[i].params = xmalloc(sizeof(*p->params) * TRE_PARAM_LAST);
  ------------------
  |  |   67|      0|#define xmalloc(size) malloc(size)
  ------------------
 2177|      0|	  if (!initial[i].params)
  ------------------
  |  Branch (2177:8): [True: 0, False: 0]
  ------------------
 2178|      0|	    ERROR_EXIT(REG_ESPACE);
  ------------------
  |  | 1882|      0|  do				  \
  |  | 1883|      0|    {				  \
  |  | 1884|      0|      errcode = err;		  \
  |  | 1885|      0|      if (/*CONSTCOND*/(void)1,1)	  \
  |  |  ------------------
  |  |  |  Branch (1885:24): [True: 0, Folded]
  |  |  ------------------
  |  | 1886|      0|      	goto error_exit;	  \
  |  | 1887|      0|    }				  \
  |  | 1888|      0| while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (1888:22): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2179|      0|	  memcpy(initial[i].params, p->params,
 2180|      0|		 sizeof(*p->params) * TRE_PARAM_LAST);
 2181|      0|	}
 2182|    367|      initial[i].assertions = p->assertions;
 2183|    367|      i++;
 2184|    367|    }
 2185|    206|  initial[i].state = NULL;
 2186|       |
 2187|    206|  tnfa->num_transitions = add;
 2188|    206|  tnfa->final = transitions + offs[tree->lastpos[0].position];
 2189|    206|  tnfa->num_states = parse_ctx.position;
 2190|    206|  tnfa->cflags = cflags;
 2191|       |
 2192|    206|  DPRINT(("final state %p\n", (void *)tnfa->final));
  ------------------
  |  |   27|    206|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 206]
  |  |  ------------------
  ------------------
 2193|       |
 2194|    206|  tre_mem_destroy(mem);
 2195|    206|  tre_stack_destroy(stack);
 2196|    206|  xfree(counts);
  ------------------
  |  |   69|    206|#define xfree(ptr) free(ptr)
  ------------------
 2197|    206|  xfree(offs);
  ------------------
  |  |   69|    206|#define xfree(ptr) free(ptr)
  ------------------
 2198|       |
 2199|    206|  preg->TRE_REGEX_T_FIELD = (void *)tnfa;
  ------------------
  |  |   15|    206|#define TRE_REGEX_T_FIELD value
  ------------------
 2200|    206|  return REG_OK;
 2201|       |
 2202|      0| error_exit:
 2203|       |  /* Free everything that was allocated and return the error code. */
 2204|      0|  tre_mem_destroy(mem);
 2205|      0|  if (stack != NULL)
  ------------------
  |  Branch (2205:7): [True: 0, False: 0]
  ------------------
 2206|      0|    tre_stack_destroy(stack);
 2207|      0|  if (counts != NULL)
  ------------------
  |  Branch (2207:7): [True: 0, False: 0]
  ------------------
 2208|      0|    xfree(counts);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
 2209|      0|  if (offs != NULL)
  ------------------
  |  Branch (2209:7): [True: 0, False: 0]
  ------------------
 2210|      0|    xfree(offs);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
 2211|      0|  preg->TRE_REGEX_T_FIELD = (void *)tnfa;
  ------------------
  |  |   15|      0|#define TRE_REGEX_T_FIELD value
  ------------------
 2212|      0|  tre_free(preg);
 2213|      0|  return errcode;
 2214|    206|}
tre_free:
 2221|    206|{
 2222|    206|  tre_tnfa_t *tnfa;
 2223|    206|  unsigned int i;
 2224|    206|  tre_tnfa_transition_t *trans;
 2225|       |
 2226|    206|  tnfa = (void *)preg->TRE_REGEX_T_FIELD;
  ------------------
  |  |   15|    206|#define TRE_REGEX_T_FIELD value
  ------------------
 2227|    206|  if (!tnfa)
  ------------------
  |  Branch (2227:7): [True: 0, False: 206]
  ------------------
 2228|      0|    return;
 2229|       |
 2230|  2.56k|  for (i = 0; i < tnfa->num_transitions; i++)
  ------------------
  |  Branch (2230:15): [True: 2.35k, False: 206]
  ------------------
 2231|  2.35k|    if (tnfa->transitions[i].state)
  ------------------
  |  Branch (2231:9): [True: 1.25k, False: 1.10k]
  ------------------
 2232|  1.25k|      {
 2233|  1.25k|	if (tnfa->transitions[i].tags)
  ------------------
  |  Branch (2233:6): [True: 354, False: 904]
  ------------------
 2234|    354|	  xfree(tnfa->transitions[i].tags);
  ------------------
  |  |   69|    354|#define xfree(ptr) free(ptr)
  ------------------
 2235|  1.25k|	if (tnfa->transitions[i].neg_classes)
  ------------------
  |  Branch (2235:6): [True: 0, False: 1.25k]
  ------------------
 2236|      0|	  xfree(tnfa->transitions[i].neg_classes);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
 2237|  1.25k|	if (tnfa->transitions[i].params)
  ------------------
  |  Branch (2237:6): [True: 0, False: 1.25k]
  ------------------
 2238|      0|	  xfree(tnfa->transitions[i].params);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
 2239|  1.25k|      }
 2240|    206|  if (tnfa->transitions)
  ------------------
  |  Branch (2240:7): [True: 206, False: 0]
  ------------------
 2241|    206|    xfree(tnfa->transitions);
  ------------------
  |  |   69|    206|#define xfree(ptr) free(ptr)
  ------------------
 2242|       |
 2243|    206|  if (tnfa->initial)
  ------------------
  |  Branch (2243:7): [True: 206, False: 0]
  ------------------
 2244|    206|    {
 2245|    573|      for (trans = tnfa->initial; trans->state; trans++)
  ------------------
  |  Branch (2245:35): [True: 367, False: 206]
  ------------------
 2246|    367|	{
 2247|    367|	  if (trans->tags)
  ------------------
  |  Branch (2247:8): [True: 363, False: 4]
  ------------------
 2248|    363|	    xfree(trans->tags);
  ------------------
  |  |   69|    363|#define xfree(ptr) free(ptr)
  ------------------
 2249|    367|	  if (trans->params)
  ------------------
  |  Branch (2249:8): [True: 0, False: 367]
  ------------------
 2250|      0|	    xfree(trans->params);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
 2251|    367|	}
 2252|    206|      xfree(tnfa->initial);
  ------------------
  |  |   69|    206|#define xfree(ptr) free(ptr)
  ------------------
 2253|    206|    }
 2254|       |
 2255|    206|  if (tnfa->submatch_data)
  ------------------
  |  Branch (2255:7): [True: 138, False: 68]
  ------------------
 2256|    138|    {
 2257|    412|      for (i = 0; i < tnfa->num_submatches; i++)
  ------------------
  |  Branch (2257:19): [True: 274, False: 138]
  ------------------
 2258|    274|	if (tnfa->submatch_data[i].parents)
  ------------------
  |  Branch (2258:6): [True: 136, False: 138]
  ------------------
 2259|    136|	  xfree(tnfa->submatch_data[i].parents);
  ------------------
  |  |   69|    136|#define xfree(ptr) free(ptr)
  ------------------
 2260|    138|      xfree(tnfa->submatch_data);
  ------------------
  |  |   69|    138|#define xfree(ptr) free(ptr)
  ------------------
 2261|    138|    }
 2262|       |
 2263|    206|  if (tnfa->tag_directions)
  ------------------
  |  Branch (2263:7): [True: 138, False: 68]
  ------------------
 2264|    138|    xfree(tnfa->tag_directions);
  ------------------
  |  |   69|    138|#define xfree(ptr) free(ptr)
  ------------------
 2265|    206|  if (tnfa->firstpos_chars)
  ------------------
  |  Branch (2265:7): [True: 143, False: 63]
  ------------------
 2266|    143|    xfree(tnfa->firstpos_chars);
  ------------------
  |  |   69|    143|#define xfree(ptr) free(ptr)
  ------------------
 2267|    206|  if (tnfa->minimal_tags)
  ------------------
  |  Branch (2267:7): [True: 138, False: 68]
  ------------------
 2268|    138|    xfree(tnfa->minimal_tags);
  ------------------
  |  |   69|    138|#define xfree(ptr) free(ptr)
  ------------------
 2269|    206|  xfree(tnfa);
  ------------------
  |  |   69|    206|#define xfree(ptr) free(ptr)
  ------------------
 2270|    206|}
tre-compile.c:tre_add_tags:
  148|    276|{
  149|    276|  reg_errcode_t status = REG_OK;
  150|    276|  tre_addtags_symbol_t symbol;
  151|    276|  tre_ast_node_t *node = tree; /* Tree node we are currently looking at. */
  152|    276|  int bottom = tre_stack_num_objects(stack);
  153|       |  /* True for first pass (counting number of needed tags) */
  154|    276|  int first_pass = (mem == NULL || tnfa == NULL);
  ------------------
  |  Branch (154:21): [True: 138, False: 138]
  |  Branch (154:36): [True: 0, False: 138]
  ------------------
  155|    276|  int *regset, *orig_regset;
  156|    276|  int num_tags = 0; /* Total number of tags. */
  157|    276|  int num_minimals = 0;	 /* Number of special minimal tags. */
  158|    276|  int tag = 0;	    /* The tag that is to be added next. */
  159|    276|  int next_tag = 1; /* Next tag to use after this one. */
  160|    276|  int *parents;	    /* Stack of submatches the current submatch is
  161|       |		       contained in. */
  162|    276|  int minimal_tag = -1; /* Tag that marks the beginning of a minimal match. */
  163|    276|  tre_tag_states_t *saved_states;
  164|       |
  165|    276|  tre_tag_direction_t direction = TRE_TAG_MINIMIZE;
  166|    276|  if (!first_pass)
  ------------------
  |  Branch (166:7): [True: 138, False: 138]
  ------------------
  167|    138|    {
  168|    138|      tnfa->end_tag = 0;
  169|    138|      tnfa->minimal_tags[0] = -1;
  170|    138|    }
  171|       |
  172|    276|  regset = xmalloc(sizeof(*regset) * ((tnfa->num_submatches + 1) * 2));
  ------------------
  |  |   67|    276|#define xmalloc(size) malloc(size)
  ------------------
  173|    276|  if (regset == NULL)
  ------------------
  |  Branch (173:7): [True: 0, False: 276]
  ------------------
  174|      0|    return REG_ESPACE;
  175|    276|  regset[0] = -1;
  176|    276|  orig_regset = regset;
  177|       |
  178|    276|  parents = xmalloc(sizeof(*parents) * (tnfa->num_submatches + 1));
  ------------------
  |  |   67|    276|#define xmalloc(size) malloc(size)
  ------------------
  179|    276|  if (parents == NULL)
  ------------------
  |  Branch (179:7): [True: 0, False: 276]
  ------------------
  180|      0|    {
  181|      0|      xfree(regset);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
  182|      0|      return REG_ESPACE;
  183|      0|    }
  184|    276|  parents[0] = -1;
  185|       |
  186|    276|  saved_states = xmalloc(sizeof(*saved_states) * (tnfa->num_submatches + 1));
  ------------------
  |  |   67|    276|#define xmalloc(size) malloc(size)
  ------------------
  187|    276|  if (saved_states == NULL)
  ------------------
  |  Branch (187:7): [True: 0, False: 276]
  ------------------
  188|      0|    {
  189|      0|      xfree(regset);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
  190|      0|      xfree(parents);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
  191|      0|      return REG_ESPACE;
  192|      0|    }
  193|    276|  else
  194|    276|    {
  195|    276|      unsigned int i;
  196|  1.10k|      for (i = 0; i <= tnfa->num_submatches; i++)
  ------------------
  |  Branch (196:19): [True: 824, False: 276]
  ------------------
  197|    824|	saved_states[i].tag = -1;
  198|    276|    }
  199|       |
  200|    276|  STACK_PUSH(stack, voidptr, node);
  ------------------
  |  |   53|    276|  do									      \
  |  |   54|    276|    {									      \
  |  |   55|    276|      status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   56|    276|    }									      \
  |  |   57|    276|  while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (57:23): [Folded, False: 276]
  |  |  ------------------
  ------------------
  201|    276|  STACK_PUSH(stack, int, ADDTAGS_RECURSE);
  ------------------
  |  |   53|    276|  do									      \
  |  |   54|    276|    {									      \
  |  |   55|    276|      status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   56|    276|    }									      \
  |  |   57|    276|  while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (57:23): [Folded, False: 276]
  |  |  ------------------
  ------------------
  202|       |
  203|  5.46k|  while (tre_stack_num_objects(stack) > bottom)
  ------------------
  |  Branch (203:10): [True: 5.19k, False: 276]
  ------------------
  204|  5.19k|    {
  205|  5.19k|      if (status != REG_OK)
  ------------------
  |  Branch (205:11): [True: 0, False: 5.19k]
  ------------------
  206|      0|	break;
  207|       |
  208|  5.19k|      symbol = (tre_addtags_symbol_t)tre_stack_pop_int(stack);
  209|  5.19k|      switch (symbol)
  210|  5.19k|	{
  211|       |
  212|    548|	case ADDTAGS_SET_SUBMATCH_END:
  ------------------
  |  Branch (212:2): [True: 548, False: 4.64k]
  ------------------
  213|    548|	  {
  214|    548|	    int id = tre_stack_pop_int(stack);
  215|    548|	    int i;
  216|       |
  217|       |	    /* Add end of this submatch to regset. */
  218|    656|	    for (i = 0; regset[i] >= 0; i++);
  ------------------
  |  Branch (218:18): [True: 108, False: 548]
  ------------------
  219|    548|	    regset[i] = id * 2 + 1;
  220|    548|	    regset[i + 1] = -1;
  221|       |
  222|       |	    /* Pop this submatch from the parents stack. */
  223|  1.36k|	    for (i = 0; parents[i] >= 0; i++);
  ------------------
  |  Branch (223:18): [True: 820, False: 548]
  ------------------
  224|    548|	    parents[i - 1] = -1;
  225|    548|	    break;
  226|      0|	  }
  227|       |
  228|  2.46k|	case ADDTAGS_RECURSE:
  ------------------
  |  Branch (228:2): [True: 2.46k, False: 2.73k]
  ------------------
  229|  2.46k|	  node = tre_stack_pop_voidptr(stack);
  230|       |
  231|  2.46k|	  if (node->submatch_id >= 0)
  ------------------
  |  Branch (231:8): [True: 548, False: 1.91k]
  ------------------
  232|    548|	    {
  233|    548|	      int id = node->submatch_id;
  234|    548|	      int i;
  235|       |
  236|       |
  237|       |	      /* Add start of this submatch to regset. */
  238|    660|	      for (i = 0; regset[i] >= 0; i++);
  ------------------
  |  Branch (238:20): [True: 112, False: 548]
  ------------------
  239|    548|	      regset[i] = id * 2;
  240|    548|	      regset[i + 1] = -1;
  241|       |
  242|    548|	      if (!first_pass)
  ------------------
  |  Branch (242:12): [True: 274, False: 274]
  ------------------
  243|    274|		{
  244|    410|		  for (i = 0; parents[i] >= 0; i++);
  ------------------
  |  Branch (244:17): [True: 136, False: 274]
  ------------------
  245|    274|		  tnfa->submatch_data[id].parents = NULL;
  246|    274|		  if (i > 0)
  ------------------
  |  Branch (246:9): [True: 136, False: 138]
  ------------------
  247|    136|		    {
  248|    136|		      int *p = xmalloc(sizeof(*p) * (i + 1));
  ------------------
  |  |   67|    136|#define xmalloc(size) malloc(size)
  ------------------
  249|    136|		      if (p == NULL)
  ------------------
  |  Branch (249:13): [True: 0, False: 136]
  ------------------
  250|      0|			{
  251|      0|			  status = REG_ESPACE;
  252|      0|			  break;
  253|      0|			}
  254|    136|		      assert(tnfa->submatch_data[id].parents == NULL);
  ------------------
  |  |   32|    136|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|    136|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [True: 136, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  255|    136|		      tnfa->submatch_data[id].parents = p;
  256|    272|		      for (i = 0; parents[i] >= 0; i++)
  ------------------
  |  Branch (256:21): [True: 136, False: 136]
  ------------------
  257|    136|			p[i] = parents[i];
  258|    136|		      p[i] = -1;
  259|    136|		    }
  260|    274|		}
  261|       |
  262|       |	      /* Add end of this submatch to regset after processing this
  263|       |		 node. */
  264|    548|	      STACK_PUSHX(stack, int, node->submatch_id);
  ------------------
  |  |   60|    548|  {									      \
  |  |   61|    548|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    548|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 548]
  |  |  ------------------
  |  |   63|    548|      break;								      \
  |  |   64|    548|  }
  ------------------
  265|    548|	      STACK_PUSHX(stack, int, ADDTAGS_SET_SUBMATCH_END);
  ------------------
  |  |   60|    548|  {									      \
  |  |   61|    548|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    548|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 548]
  |  |  ------------------
  |  |   63|    548|      break;								      \
  |  |   64|    548|  }
  ------------------
  266|    548|	    }
  267|       |
  268|  2.46k|	  switch (node->type)
  ------------------
  |  Branch (268:12): [True: 2.46k, False: 0]
  ------------------
  269|  2.46k|	    {
  270|  1.28k|	    case LITERAL:
  ------------------
  |  Branch (270:6): [True: 1.28k, False: 1.18k]
  ------------------
  271|  1.28k|	      {
  272|  1.28k|		tre_literal_t *lit = node->obj;
  273|       |
  274|  1.28k|		if (!IS_SPECIAL(lit) || IS_BACKREF(lit))
  ------------------
  |  |   32|  2.56k|#define IS_SPECIAL(x)	((x)->code_min < 0)
  ------------------
              		if (!IS_SPECIAL(lit) || IS_BACKREF(lit))
  ------------------
  |  |   36|    124|#define IS_BACKREF(x)	((x)->code_min == BACKREF)
  |  |  ------------------
  |  |  |  |   29|    124|#define BACKREF	  -4   /* Back reference leaf. */
  |  |  ------------------
  |  |  |  Branch (36:23): [True: 0, False: 124]
  |  |  ------------------
  ------------------
  |  Branch (274:7): [True: 1.15k, False: 124]
  ------------------
  275|  1.15k|		  {
  276|  1.15k|		    int i;
  277|  1.15k|		    DPRINT(("Literal %d-%d\n",
  ------------------
  |  |   27|  1.15k|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 1.15k]
  |  |  ------------------
  ------------------
  278|  1.15k|			    (int)lit->code_min, (int)lit->code_max));
  279|  1.15k|		    if (regset[0] >= 0)
  ------------------
  |  Branch (279:11): [True: 300, False: 856]
  ------------------
  280|    300|		      {
  281|       |			/* Regset is not empty, so add a tag before the
  282|       |			   literal or backref. */
  283|    300|			if (!first_pass)
  ------------------
  |  Branch (283:8): [True: 150, False: 150]
  ------------------
  284|    150|			  {
  285|    150|			    status = tre_add_tag_left(mem, node, tag);
  286|    150|			    tnfa->tag_directions[tag] = direction;
  287|    150|			    if (minimal_tag >= 0)
  ------------------
  |  Branch (287:12): [True: 0, False: 150]
  ------------------
  288|      0|			      {
  289|      0|				DPRINT(("Minimal %d, %d\n", minimal_tag, tag));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  290|      0|				for (i = 0; tnfa->minimal_tags[i] >= 0; i++);
  ------------------
  |  Branch (290:17): [True: 0, False: 0]
  ------------------
  291|      0|				tnfa->minimal_tags[i] = tag;
  292|      0|				tnfa->minimal_tags[i + 1] = minimal_tag;
  293|      0|				tnfa->minimal_tags[i + 2] = -1;
  294|      0|				minimal_tag = -1;
  295|      0|				num_minimals++;
  296|      0|			      }
  297|    150|			    tre_purge_regset(regset, tnfa, tag);
  298|    150|			  }
  299|    150|			else
  300|    150|			  {
  301|    150|			    DPRINT(("  num_tags = 1\n"));
  ------------------
  |  |   27|    150|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 150]
  |  |  ------------------
  ------------------
  302|    150|			    node->num_tags = 1;
  303|    150|			  }
  304|       |
  305|    300|			DPRINT(("  num_tags++\n"));
  ------------------
  |  |   27|    300|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 300]
  |  |  ------------------
  ------------------
  306|    300|			regset[0] = -1;
  307|    300|			tag = next_tag;
  308|    300|			num_tags++;
  309|    300|			next_tag++;
  310|    300|		      }
  311|  1.15k|		  }
  312|    124|		else
  313|    124|		  {
  314|    124|		    assert(!IS_TAG(lit));
  ------------------
  |  |   32|    124|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|    124|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [True: 124, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  315|    124|		  }
  316|  1.28k|		break;
  317|      0|	      }
  318|    744|	    case CATENATION:
  ------------------
  |  Branch (318:6): [True: 744, False: 1.71k]
  ------------------
  319|    744|	      {
  320|    744|		tre_catenation_t *cat = node->obj;
  321|    744|		tre_ast_node_t *left = cat->left;
  322|    744|		tre_ast_node_t *right = cat->right;
  323|    744|		int reserved_tag = -1;
  324|    744|		DPRINT(("Catenation, next_tag = %d\n", next_tag));
  ------------------
  |  |   27|    744|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 744]
  |  |  ------------------
  ------------------
  325|       |
  326|       |
  327|       |		/* After processing right child. */
  328|    744|		STACK_PUSHX(stack, voidptr, node);
  ------------------
  |  |   60|    744|  {									      \
  |  |   61|    744|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    744|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 744]
  |  |  ------------------
  |  |   63|    744|      break;								      \
  |  |   64|    744|  }
  ------------------
  329|    744|		STACK_PUSHX(stack, int, ADDTAGS_AFTER_CAT_RIGHT);
  ------------------
  |  |   60|    744|  {									      \
  |  |   61|    744|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    744|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 744]
  |  |  ------------------
  |  |   63|    744|      break;								      \
  |  |   64|    744|  }
  ------------------
  330|       |
  331|       |		/* Process right child. */
  332|    744|		STACK_PUSHX(stack, voidptr, right);
  ------------------
  |  |   60|    744|  {									      \
  |  |   61|    744|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    744|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 744]
  |  |  ------------------
  |  |   63|    744|      break;								      \
  |  |   64|    744|  }
  ------------------
  333|    744|		STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
  ------------------
  |  |   60|    744|  {									      \
  |  |   61|    744|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    744|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 744]
  |  |  ------------------
  |  |   63|    744|      break;								      \
  |  |   64|    744|  }
  ------------------
  334|       |
  335|       |		/* After processing left child. */
  336|    744|		STACK_PUSHX(stack, int, next_tag + left->num_tags);
  ------------------
  |  |   60|    744|  {									      \
  |  |   61|    744|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    744|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 744]
  |  |  ------------------
  |  |   63|    744|      break;								      \
  |  |   64|    744|  }
  ------------------
  337|    744|		DPRINT(("  Pushing %d for after left\n",
  ------------------
  |  |   27|    744|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 744]
  |  |  ------------------
  ------------------
  338|    744|			next_tag + left->num_tags));
  339|    744|		if (left->num_tags > 0 && right->num_tags > 0)
  ------------------
  |  Branch (339:7): [True: 342, False: 402]
  |  Branch (339:29): [True: 134, False: 208]
  ------------------
  340|    134|		  {
  341|       |		    /* Reserve the next tag to the right child. */
  342|    134|		    DPRINT(("  Reserving next_tag %d to right child\n",
  ------------------
  |  |   27|    134|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 134]
  |  |  ------------------
  ------------------
  343|    134|			    next_tag));
  344|    134|		    reserved_tag = next_tag;
  345|    134|		    next_tag++;
  346|    134|		  }
  347|    744|		STACK_PUSHX(stack, int, reserved_tag);
  ------------------
  |  |   60|    744|  {									      \
  |  |   61|    744|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    744|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 744]
  |  |  ------------------
  |  |   63|    744|      break;								      \
  |  |   64|    744|  }
  ------------------
  348|    744|		STACK_PUSHX(stack, int, ADDTAGS_AFTER_CAT_LEFT);
  ------------------
  |  |   60|    744|  {									      \
  |  |   61|    744|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    744|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 744]
  |  |  ------------------
  |  |   63|    744|      break;								      \
  |  |   64|    744|  }
  ------------------
  349|       |
  350|       |		/* Process left child. */
  351|    744|		STACK_PUSHX(stack, voidptr, left);
  ------------------
  |  |   60|    744|  {									      \
  |  |   61|    744|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    744|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 744]
  |  |  ------------------
  |  |   63|    744|      break;								      \
  |  |   64|    744|  }
  ------------------
  352|    744|		STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
  ------------------
  |  |   60|    744|  {									      \
  |  |   61|    744|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    744|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 744]
  |  |  ------------------
  |  |   63|    744|      break;								      \
  |  |   64|    744|  }
  ------------------
  353|       |
  354|    744|		}
  355|      0|	      break;
  356|    176|	    case ITERATION:
  ------------------
  |  Branch (356:6): [True: 176, False: 2.28k]
  ------------------
  357|    176|	      {
  358|    176|		tre_iteration_t *iter = node->obj;
  359|    176|		DPRINT(("Iteration\n"));
  ------------------
  |  |   27|    176|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 176]
  |  |  ------------------
  ------------------
  360|       |
  361|    176|		if (first_pass)
  ------------------
  |  Branch (361:7): [True: 88, False: 88]
  ------------------
  362|     88|		  {
  363|     88|		    STACK_PUSHX(stack, int, regset[0] >= 0 || iter->minimal);
  ------------------
  |  |   60|     88|  {									      \
  |  |   61|     94|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |  ------------------
  |  |  |  Branch (61:44): [True: 82, False: 6]
  |  |  |  Branch (61:44): [True: 0, False: 6]
  |  |  ------------------
  |  |   62|     88|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 88]
  |  |  ------------------
  |  |   63|     88|      break;								      \
  |  |   64|     88|  }
  ------------------
  364|     88|		  }
  365|     88|		else
  366|     88|		  {
  367|     88|		    STACK_PUSHX(stack, int, tag);
  ------------------
  |  |   60|     88|  {									      \
  |  |   61|     88|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|     88|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 88]
  |  |  ------------------
  |  |   63|     88|      break;								      \
  |  |   64|     88|  }
  ------------------
  368|     88|		    STACK_PUSHX(stack, int, iter->minimal);
  ------------------
  |  |   60|     88|  {									      \
  |  |   61|     88|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|     88|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 88]
  |  |  ------------------
  |  |   63|     88|      break;								      \
  |  |   64|     88|  }
  ------------------
  369|     88|		  }
  370|    176|		STACK_PUSHX(stack, voidptr, node);
  ------------------
  |  |   60|    176|  {									      \
  |  |   61|    176|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    176|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 176]
  |  |  ------------------
  |  |   63|    176|      break;								      \
  |  |   64|    176|  }
  ------------------
  371|    176|		STACK_PUSHX(stack, int, ADDTAGS_AFTER_ITERATION);
  ------------------
  |  |   60|    176|  {									      \
  |  |   61|    176|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    176|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 176]
  |  |  ------------------
  |  |   63|    176|      break;								      \
  |  |   64|    176|  }
  ------------------
  372|       |
  373|    176|		STACK_PUSHX(stack, voidptr, iter->arg);
  ------------------
  |  |   60|    176|  {									      \
  |  |   61|    176|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    176|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 176]
  |  |  ------------------
  |  |   63|    176|      break;								      \
  |  |   64|    176|  }
  ------------------
  374|    176|		STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
  ------------------
  |  |   60|    176|  {									      \
  |  |   61|    176|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    176|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 176]
  |  |  ------------------
  |  |   63|    176|      break;								      \
  |  |   64|    176|  }
  ------------------
  375|       |
  376|       |		/* Regset is not empty, so add a tag here. */
  377|    176|		if (regset[0] >= 0 || iter->minimal)
  ------------------
  |  Branch (377:7): [True: 164, False: 12]
  |  Branch (377:25): [True: 0, False: 12]
  ------------------
  378|    164|		  {
  379|    164|		    if (!first_pass)
  ------------------
  |  Branch (379:11): [True: 82, False: 82]
  ------------------
  380|     82|		      {
  381|     82|			int i;
  382|     82|			status = tre_add_tag_left(mem, node, tag);
  383|     82|			if (iter->minimal)
  ------------------
  |  Branch (383:8): [True: 0, False: 82]
  ------------------
  384|      0|			  tnfa->tag_directions[tag] = TRE_TAG_MAXIMIZE;
  385|     82|			else
  386|     82|			  tnfa->tag_directions[tag] = direction;
  387|     82|			if (minimal_tag >= 0)
  ------------------
  |  Branch (387:8): [True: 0, False: 82]
  ------------------
  388|      0|			  {
  389|      0|			    DPRINT(("Minimal %d, %d\n", minimal_tag, tag));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  390|      0|			    for (i = 0; tnfa->minimal_tags[i] >= 0; i++);
  ------------------
  |  Branch (390:20): [True: 0, False: 0]
  ------------------
  391|      0|			    tnfa->minimal_tags[i] = tag;
  392|      0|			    tnfa->minimal_tags[i + 1] = minimal_tag;
  393|      0|			    tnfa->minimal_tags[i + 2] = -1;
  394|      0|			    minimal_tag = -1;
  395|      0|			    num_minimals++;
  396|      0|			  }
  397|     82|			tre_purge_regset(regset, tnfa, tag);
  398|     82|		      }
  399|       |
  400|    164|		    DPRINT(("  num_tags++\n"));
  ------------------
  |  |   27|    164|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 164]
  |  |  ------------------
  ------------------
  401|    164|		    regset[0] = -1;
  402|    164|		    tag = next_tag;
  403|    164|		    num_tags++;
  404|    164|		    next_tag++;
  405|    164|		  }
  406|    176|		direction = TRE_TAG_MINIMIZE;
  407|    176|	      }
  408|      0|	      break;
  409|    260|	    case UNION:
  ------------------
  |  Branch (409:6): [True: 260, False: 2.20k]
  ------------------
  410|    260|	      {
  411|    260|		tre_union_t *uni = node->obj;
  412|    260|		tre_ast_node_t *left = uni->left;
  413|    260|		tre_ast_node_t *right = uni->right;
  414|    260|		int left_tag;
  415|    260|		int right_tag;
  416|       |
  417|    260|		if (regset[0] >= 0)
  ------------------
  |  Branch (417:7): [True: 136, False: 124]
  ------------------
  418|    136|		  {
  419|    136|		    left_tag = next_tag;
  420|    136|		    right_tag = next_tag + 1;
  421|    136|		  }
  422|    124|		else
  423|    124|		  {
  424|    124|		    left_tag = tag;
  425|    124|		    right_tag = next_tag;
  426|    124|		  }
  427|       |
  428|    260|		DPRINT(("Union\n"));
  ------------------
  |  |   27|    260|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 260]
  |  |  ------------------
  ------------------
  429|       |
  430|       |		/* After processing right child. */
  431|    260|		STACK_PUSHX(stack, int, right_tag);
  ------------------
  |  |   60|    260|  {									      \
  |  |   61|    260|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    260|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 260]
  |  |  ------------------
  |  |   63|    260|      break;								      \
  |  |   64|    260|  }
  ------------------
  432|    260|		STACK_PUSHX(stack, int, left_tag);
  ------------------
  |  |   60|    260|  {									      \
  |  |   61|    260|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    260|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 260]
  |  |  ------------------
  |  |   63|    260|      break;								      \
  |  |   64|    260|  }
  ------------------
  433|    260|		STACK_PUSHX(stack, voidptr, regset);
  ------------------
  |  |   60|    260|  {									      \
  |  |   61|    260|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    260|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 260]
  |  |  ------------------
  |  |   63|    260|      break;								      \
  |  |   64|    260|  }
  ------------------
  434|    260|		STACK_PUSHX(stack, int, regset[0] >= 0);
  ------------------
  |  |   60|    260|  {									      \
  |  |   61|    260|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    260|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 260]
  |  |  ------------------
  |  |   63|    260|      break;								      \
  |  |   64|    260|  }
  ------------------
  435|    260|		STACK_PUSHX(stack, voidptr, node);
  ------------------
  |  |   60|    260|  {									      \
  |  |   61|    260|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    260|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 260]
  |  |  ------------------
  |  |   63|    260|      break;								      \
  |  |   64|    260|  }
  ------------------
  436|    260|		STACK_PUSHX(stack, voidptr, right);
  ------------------
  |  |   60|    260|  {									      \
  |  |   61|    260|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    260|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 260]
  |  |  ------------------
  |  |   63|    260|      break;								      \
  |  |   64|    260|  }
  ------------------
  437|    260|		STACK_PUSHX(stack, voidptr, left);
  ------------------
  |  |   60|    260|  {									      \
  |  |   61|    260|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    260|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 260]
  |  |  ------------------
  |  |   63|    260|      break;								      \
  |  |   64|    260|  }
  ------------------
  438|    260|		STACK_PUSHX(stack, int, ADDTAGS_AFTER_UNION_RIGHT);
  ------------------
  |  |   60|    260|  {									      \
  |  |   61|    260|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    260|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 260]
  |  |  ------------------
  |  |   63|    260|      break;								      \
  |  |   64|    260|  }
  ------------------
  439|       |
  440|       |		/* Process right child. */
  441|    260|		STACK_PUSHX(stack, voidptr, right);
  ------------------
  |  |   60|    260|  {									      \
  |  |   61|    260|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    260|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 260]
  |  |  ------------------
  |  |   63|    260|      break;								      \
  |  |   64|    260|  }
  ------------------
  442|    260|		STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
  ------------------
  |  |   60|    260|  {									      \
  |  |   61|    260|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    260|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 260]
  |  |  ------------------
  |  |   63|    260|      break;								      \
  |  |   64|    260|  }
  ------------------
  443|       |
  444|       |		/* After processing left child. */
  445|    260|		STACK_PUSHX(stack, int, ADDTAGS_AFTER_UNION_LEFT);
  ------------------
  |  |   60|    260|  {									      \
  |  |   61|    260|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    260|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 260]
  |  |  ------------------
  |  |   63|    260|      break;								      \
  |  |   64|    260|  }
  ------------------
  446|       |
  447|       |		/* Process left child. */
  448|    260|		STACK_PUSHX(stack, voidptr, left);
  ------------------
  |  |   60|    260|  {									      \
  |  |   61|    260|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    260|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 260]
  |  |  ------------------
  |  |   63|    260|      break;								      \
  |  |   64|    260|  }
  ------------------
  449|    260|		STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
  ------------------
  |  |   60|    260|  {									      \
  |  |   61|    260|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    260|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 260]
  |  |  ------------------
  |  |   63|    260|      break;								      \
  |  |   64|    260|  }
  ------------------
  450|       |
  451|       |		/* Regset is not empty, so add a tag here. */
  452|    260|		if (regset[0] >= 0)
  ------------------
  |  Branch (452:7): [True: 136, False: 124]
  ------------------
  453|    136|		  {
  454|    136|		    if (!first_pass)
  ------------------
  |  Branch (454:11): [True: 68, False: 68]
  ------------------
  455|     68|		      {
  456|     68|			int i;
  457|     68|			status = tre_add_tag_left(mem, node, tag);
  458|     68|			tnfa->tag_directions[tag] = direction;
  459|     68|			if (minimal_tag >= 0)
  ------------------
  |  Branch (459:8): [True: 0, False: 68]
  ------------------
  460|      0|			  {
  461|      0|			    DPRINT(("Minimal %d, %d\n", minimal_tag, tag));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  462|      0|			    for (i = 0; tnfa->minimal_tags[i] >= 0; i++);
  ------------------
  |  Branch (462:20): [True: 0, False: 0]
  ------------------
  463|      0|			    tnfa->minimal_tags[i] = tag;
  464|      0|			    tnfa->minimal_tags[i + 1] = minimal_tag;
  465|      0|			    tnfa->minimal_tags[i + 2] = -1;
  466|      0|			    minimal_tag = -1;
  467|      0|			    num_minimals++;
  468|      0|			  }
  469|     68|			tre_purge_regset(regset, tnfa, tag);
  470|     68|		      }
  471|       |
  472|    136|		    DPRINT(("  num_tags++\n"));
  ------------------
  |  |   27|    136|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 136]
  |  |  ------------------
  ------------------
  473|    136|		    regset[0] = -1;
  474|    136|		    tag = next_tag;
  475|    136|		    num_tags++;
  476|    136|		    next_tag++;
  477|    136|		  }
  478|       |
  479|    260|		if (node->num_submatches > 0)
  ------------------
  |  Branch (479:7): [True: 136, False: 124]
  ------------------
  480|    136|		  {
  481|       |		    /* The next two tags are reserved for markers. */
  482|    136|		    next_tag++;
  483|    136|		    tag = next_tag;
  484|    136|		    next_tag++;
  485|    136|		  }
  486|       |
  487|    260|		break;
  488|    260|	      }
  489|  2.46k|	    }
  490|       |
  491|  2.46k|	  if (node->submatch_id >= 0)
  ------------------
  |  Branch (491:8): [True: 548, False: 1.91k]
  ------------------
  492|    548|	    {
  493|    548|	      int i;
  494|       |	      /* Push this submatch on the parents stack. */
  495|    820|	      for (i = 0; parents[i] >= 0; i++);
  ------------------
  |  Branch (495:20): [True: 272, False: 548]
  ------------------
  496|    548|	      parents[i] = node->submatch_id;
  497|    548|	      parents[i + 1] = -1;
  498|    548|	    }
  499|       |
  500|  2.46k|	  break; /* end case: ADDTAGS_RECURSE */
  501|       |
  502|    176|	case ADDTAGS_AFTER_ITERATION:
  ------------------
  |  Branch (502:2): [True: 176, False: 5.01k]
  ------------------
  503|    176|	  {
  504|    176|	    int minimal = 0;
  505|    176|	    int enter_tag;
  506|    176|	    node = tre_stack_pop_voidptr(stack);
  507|    176|	    if (first_pass)
  ------------------
  |  Branch (507:10): [True: 88, False: 88]
  ------------------
  508|     88|	      {
  509|     88|		node->num_tags = ((tre_iteration_t *)node->obj)->arg->num_tags
  510|     88|		  + tre_stack_pop_int(stack);
  511|     88|		minimal_tag = -1;
  512|     88|	      }
  513|     88|	    else
  514|     88|	      {
  515|     88|		minimal = tre_stack_pop_int(stack);
  516|     88|		enter_tag = tre_stack_pop_int(stack);
  517|     88|		if (minimal)
  ------------------
  |  Branch (517:7): [True: 0, False: 88]
  ------------------
  518|      0|		  minimal_tag = enter_tag;
  519|     88|	      }
  520|       |
  521|    176|	    DPRINT(("After iteration\n"));
  ------------------
  |  |   27|    176|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 176]
  |  |  ------------------
  ------------------
  522|    176|	    if (!first_pass)
  ------------------
  |  Branch (522:10): [True: 88, False: 88]
  ------------------
  523|     88|	      {
  524|     88|		DPRINT(("  Setting direction to %s\n",
  ------------------
  |  |   27|     88|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 88]
  |  |  ------------------
  ------------------
  525|     88|			minimal ? "minimize" : "maximize"));
  526|     88|		if (minimal)
  ------------------
  |  Branch (526:7): [True: 0, False: 88]
  ------------------
  527|      0|		  direction = TRE_TAG_MINIMIZE;
  528|     88|		else
  529|     88|		  direction = TRE_TAG_MAXIMIZE;
  530|     88|	      }
  531|    176|	    break;
  532|  2.46k|	  }
  533|       |
  534|    744|	case ADDTAGS_AFTER_CAT_LEFT:
  ------------------
  |  Branch (534:2): [True: 744, False: 4.44k]
  ------------------
  535|    744|	  {
  536|    744|	    int new_tag = tre_stack_pop_int(stack);
  537|    744|	    next_tag = tre_stack_pop_int(stack);
  538|    744|	    DPRINT(("After cat left, tag = %d, next_tag = %d\n",
  ------------------
  |  |   27|    744|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 744]
  |  |  ------------------
  ------------------
  539|    744|		    tag, next_tag));
  540|    744|	    if (new_tag >= 0)
  ------------------
  |  Branch (540:10): [True: 134, False: 610]
  ------------------
  541|    134|	      {
  542|    134|		DPRINT(("  Setting tag to %d\n", new_tag));
  ------------------
  |  |   27|    134|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 134]
  |  |  ------------------
  ------------------
  543|    134|		tag = new_tag;
  544|    134|	      }
  545|    744|	    break;
  546|  2.46k|	  }
  547|       |
  548|    744|	case ADDTAGS_AFTER_CAT_RIGHT:
  ------------------
  |  Branch (548:2): [True: 744, False: 4.44k]
  ------------------
  549|    744|	  DPRINT(("After cat right\n"));
  ------------------
  |  |   27|    744|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 744]
  |  |  ------------------
  ------------------
  550|    744|	  node = tre_stack_pop_voidptr(stack);
  551|    744|	  if (first_pass)
  ------------------
  |  Branch (551:8): [True: 372, False: 372]
  ------------------
  552|    372|	    node->num_tags = ((tre_catenation_t *)node->obj)->left->num_tags
  553|    372|	      + ((tre_catenation_t *)node->obj)->right->num_tags;
  554|    744|	  break;
  555|       |
  556|    260|	case ADDTAGS_AFTER_UNION_LEFT:
  ------------------
  |  Branch (556:2): [True: 260, False: 4.93k]
  ------------------
  557|    260|	  DPRINT(("After union left\n"));
  ------------------
  |  |   27|    260|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 260]
  |  |  ------------------
  ------------------
  558|       |	  /* Lift the bottom of the `regset' array so that when processing
  559|       |	     the right operand the items currently in the array are
  560|       |	     invisible.	 The original bottom was saved at ADDTAGS_UNION and
  561|       |	     will be restored at ADDTAGS_AFTER_UNION_RIGHT below. */
  562|    260|	  while (*regset >= 0)
  ------------------
  |  Branch (562:11): [True: 0, False: 260]
  ------------------
  563|      0|	    regset++;
  564|    260|	  break;
  565|       |
  566|    260|	case ADDTAGS_AFTER_UNION_RIGHT:
  ------------------
  |  Branch (566:2): [True: 260, False: 4.93k]
  ------------------
  567|    260|	  {
  568|    260|	    int added_tags, tag_left, tag_right;
  569|    260|	    tre_ast_node_t *left = tre_stack_pop_voidptr(stack);
  570|    260|	    tre_ast_node_t *right = tre_stack_pop_voidptr(stack);
  571|    260|	    DPRINT(("After union right\n"));
  ------------------
  |  |   27|    260|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 260]
  |  |  ------------------
  ------------------
  572|    260|	    node = tre_stack_pop_voidptr(stack);
  573|    260|	    added_tags = tre_stack_pop_int(stack);
  574|    260|	    if (first_pass)
  ------------------
  |  Branch (574:10): [True: 130, False: 130]
  ------------------
  575|    130|	      {
  576|    130|		node->num_tags = ((tre_union_t *)node->obj)->left->num_tags
  577|    130|		  + ((tre_union_t *)node->obj)->right->num_tags + added_tags
  578|    130|		  + ((node->num_submatches > 0) ? 2 : 0);
  ------------------
  |  Branch (578:8): [True: 68, False: 62]
  ------------------
  579|    130|	      }
  580|    260|	    regset = tre_stack_pop_voidptr(stack);
  581|    260|	    tag_left = tre_stack_pop_int(stack);
  582|    260|	    tag_right = tre_stack_pop_int(stack);
  583|       |
  584|       |	    /* Add tags after both children, the left child gets a smaller
  585|       |	       tag than the right child.  This guarantees that we prefer
  586|       |	       the left child over the right child. */
  587|       |	    /* XXX - This is not always necessary (if the children have
  588|       |	       tags which must be seen for every match of that child). */
  589|       |	    /* XXX - Check if this is the only place where tre_add_tag_right
  590|       |	       is used.	 If so, use tre_add_tag_left (putting the tag before
  591|       |	       the child as opposed after the child) and throw away
  592|       |	       tre_add_tag_right. */
  593|    260|	    if (node->num_submatches > 0)
  ------------------
  |  Branch (593:10): [True: 136, False: 124]
  ------------------
  594|    136|	      {
  595|    136|		if (!first_pass)
  ------------------
  |  Branch (595:7): [True: 68, False: 68]
  ------------------
  596|     68|		  {
  597|     68|		    status = tre_add_tag_right(mem, left, tag_left);
  598|     68|		    tnfa->tag_directions[tag_left] = TRE_TAG_MAXIMIZE;
  599|     68|		    status = tre_add_tag_right(mem, right, tag_right);
  600|     68|		    tnfa->tag_directions[tag_right] = TRE_TAG_MAXIMIZE;
  601|     68|		  }
  602|    136|		DPRINT(("  num_tags += 2\n"));
  ------------------
  |  |   27|    136|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 136]
  |  |  ------------------
  ------------------
  603|    136|		num_tags += 2;
  604|    136|	      }
  605|    260|	    direction = TRE_TAG_MAXIMIZE;
  606|    260|	    break;
  607|  2.46k|	  }
  608|       |
  609|      0|	default:
  ------------------
  |  Branch (609:2): [True: 0, False: 5.19k]
  ------------------
  610|      0|	  assert(0);
  ------------------
  |  |   32|      0|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|      0|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  611|      0|	  break;
  612|       |
  613|  5.19k|	} /* end switch(symbol) */
  614|  5.19k|    } /* end while(tre_stack_num_objects(stack) > bottom) */
  615|       |
  616|    276|  if (!first_pass)
  ------------------
  |  Branch (616:7): [True: 138, False: 138]
  ------------------
  617|    138|    tre_purge_regset(regset, tnfa, tag);
  618|       |
  619|    276|  if (!first_pass && minimal_tag >= 0)
  ------------------
  |  Branch (619:7): [True: 138, False: 138]
  |  Branch (619:22): [True: 0, False: 138]
  ------------------
  620|      0|    {
  621|      0|      int i;
  622|      0|      DPRINT(("Minimal %d, %d\n", minimal_tag, tag));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  623|      0|      for (i = 0; tnfa->minimal_tags[i] >= 0; i++);
  ------------------
  |  Branch (623:19): [True: 0, False: 0]
  ------------------
  624|      0|      tnfa->minimal_tags[i] = tag;
  625|      0|      tnfa->minimal_tags[i + 1] = minimal_tag;
  626|      0|      tnfa->minimal_tags[i + 2] = -1;
  627|      0|      minimal_tag = -1;
  628|      0|      num_minimals++;
  629|      0|    }
  630|       |
  631|    276|  DPRINT(("tre_add_tags: %s complete.  Number of tags %d.\n",
  ------------------
  |  |   27|    276|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 276]
  |  |  ------------------
  ------------------
  632|    276|	  first_pass? "First pass" : "Second pass", num_tags));
  633|       |
  634|    276|  assert(tree->num_tags == num_tags);
  ------------------
  |  |   32|    276|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|    276|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [True: 276, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  635|    276|  tnfa->end_tag = num_tags;
  636|    276|  tnfa->num_tags = num_tags;
  637|    276|  tnfa->num_minimals = num_minimals;
  638|    276|  xfree(orig_regset);
  ------------------
  |  |   69|    276|#define xfree(ptr) free(ptr)
  ------------------
  639|    276|  xfree(parents);
  ------------------
  |  |   69|    276|#define xfree(ptr) free(ptr)
  ------------------
  640|    276|  xfree(saved_states);
  ------------------
  |  |   69|    276|#define xfree(ptr) free(ptr)
  ------------------
  641|    276|  return status;
  642|    276|}
tre-compile.c:tre_add_tag_left:
   44|    300|{
   45|    300|  tre_catenation_t *c;
   46|       |
   47|    300|  DPRINT(("add_tag_left: tag %d\n", tag_id));
  ------------------
  |  |   27|    300|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 300]
  |  |  ------------------
  ------------------
   48|       |
   49|    300|  c = tre_mem_alloc(mem, sizeof(*c));
  ------------------
  |  |   40|    300|#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
  ------------------
   50|    300|  if (c == NULL)
  ------------------
  |  Branch (50:7): [True: 0, False: 300]
  ------------------
   51|      0|    return REG_ESPACE;
   52|    300|  c->left = tre_ast_new_literal(mem, TAG, tag_id, -1);
  ------------------
  |  |   28|    300|#define TAG	  -3   /* Tag leaf. */
  ------------------
   53|    300|  if (c->left == NULL)
  ------------------
  |  Branch (53:7): [True: 0, False: 300]
  ------------------
   54|      0|    return REG_ESPACE;
   55|    300|  c->right = tre_mem_alloc(mem, sizeof(tre_ast_node_t));
  ------------------
  |  |   40|    300|#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
  ------------------
   56|    300|  if (c->right == NULL)
  ------------------
  |  Branch (56:7): [True: 0, False: 300]
  ------------------
   57|      0|    return REG_ESPACE;
   58|       |
   59|    300|  c->right->obj = node->obj;
   60|    300|  c->right->type = node->type;
   61|    300|  c->right->nullable = -1;
   62|    300|  c->right->submatch_id = -1;
   63|    300|  c->right->firstpos = NULL;
   64|       |  c->right->lastpos = NULL;
   65|    300|  c->right->num_tags = 0;
   66|    300|  node->obj = c;
   67|    300|  node->type = CATENATION;
   68|    300|  return REG_OK;
   69|    300|}
tre-compile.c:tre_purge_regset:
  124|    438|{
  125|    438|  int i;
  126|       |
  127|    986|  for (i = 0; regset[i] >= 0; i++)
  ------------------
  |  Branch (127:15): [True: 548, False: 438]
  ------------------
  128|    548|    {
  129|    548|      int id = regset[i] / 2;
  130|    548|      int start = !(regset[i] % 2);
  131|    548|      DPRINT(("  Using tag %d for %s offset of "
  ------------------
  |  |   27|    548|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 548]
  |  |  ------------------
  ------------------
  132|    548|	      "submatch %d\n", tag,
  133|    548|	      start ? "start" : "end", id));
  134|    548|      if (start)
  ------------------
  |  Branch (134:11): [True: 274, False: 274]
  ------------------
  135|    274|	tnfa->submatch_data[id].so_tag = tag;
  136|    274|      else
  137|    274|	tnfa->submatch_data[id].eo_tag = tag;
  138|    548|    }
  139|    438|  regset[0] = -1;
  140|    438|}
tre-compile.c:tre_add_tag_right:
   76|    136|{
   77|    136|  tre_catenation_t *c;
   78|       |
   79|    136|  DPRINT(("tre_add_tag_right: tag %d\n", tag_id));
  ------------------
  |  |   27|    136|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 136]
  |  |  ------------------
  ------------------
   80|       |
   81|    136|  c = tre_mem_alloc(mem, sizeof(*c));
  ------------------
  |  |   40|    136|#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
  ------------------
   82|    136|  if (c == NULL)
  ------------------
  |  Branch (82:7): [True: 0, False: 136]
  ------------------
   83|      0|    return REG_ESPACE;
   84|    136|  c->right = tre_ast_new_literal(mem, TAG, tag_id, -1);
  ------------------
  |  |   28|    136|#define TAG	  -3   /* Tag leaf. */
  ------------------
   85|    136|  if (c->right == NULL)
  ------------------
  |  Branch (85:7): [True: 0, False: 136]
  ------------------
   86|      0|    return REG_ESPACE;
   87|    136|  c->left = tre_mem_alloc(mem, sizeof(tre_ast_node_t));
  ------------------
  |  |   40|    136|#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
  ------------------
   88|    136|  if (c->left == NULL)
  ------------------
  |  Branch (88:7): [True: 0, False: 136]
  ------------------
   89|      0|    return REG_ESPACE;
   90|       |
   91|    136|  c->left->obj = node->obj;
   92|    136|  c->left->type = node->type;
   93|    136|  c->left->nullable = -1;
   94|    136|  c->left->submatch_id = -1;
   95|    136|  c->left->firstpos = NULL;
   96|       |  c->left->lastpos = NULL;
   97|    136|  c->left->num_tags = 0;
   98|    136|  node->obj = c;
   99|    136|  node->type = CATENATION;
  100|    136|  return REG_OK;
  101|    136|}
tre-compile.c:tre_expand_ast:
  816|    206|{
  817|    206|  reg_errcode_t status = REG_OK;
  818|    206|  int bottom = tre_stack_num_objects(stack);
  819|    206|  int pos_add = 0;
  820|    206|  int pos_add_total = 0;
  821|    206|  int max_pos = 0;
  822|       |  /* Current approximate matching parameters. */
  823|    206|  int params[TRE_PARAM_LAST];
  824|       |  /* Approximate parameter nesting level. */
  825|    206|  int params_depth = 0;
  826|    206|  int iter_depth = 0;
  827|    206|  int i;
  828|       |
  829|  2.06k|  for (i = 0; i < TRE_PARAM_LAST; i++)
  ------------------
  |  Branch (829:15): [True: 1.85k, False: 206]
  ------------------
  830|  1.85k|    params[i] = TRE_PARAM_DEFAULT;
  ------------------
  |  |  257|  1.85k|#define TRE_PARAM_DEFAULT -2
  ------------------
  831|       |
  832|    206|  STACK_PUSHR(stack, voidptr, ast);
  ------------------
  |  |   67|    206|  {									      \
  |  |   68|    206|    reg_errcode_t _status;						      \
  |  |   69|    206|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    206|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 206]
  |  |  ------------------
  |  |   71|    206|      return _status;							      \
  |  |   72|    206|  }
  ------------------
  833|    206|  STACK_PUSHR(stack, int, EXPAND_RECURSE);
  ------------------
  |  |   67|    206|  {									      \
  |  |   68|    206|    reg_errcode_t _status;						      \
  |  |   69|    206|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    206|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 206]
  |  |  ------------------
  |  |   71|    206|      return _status;							      \
  |  |   72|    206|  }
  ------------------
  834|  3.44k|  while (status == REG_OK && tre_stack_num_objects(stack) > bottom)
  ------------------
  |  Branch (834:10): [True: 3.44k, False: 0]
  |  Branch (834:30): [True: 3.23k, False: 206]
  ------------------
  835|  3.23k|    {
  836|  3.23k|      tre_ast_node_t *node;
  837|  3.23k|      tre_expand_ast_symbol_t symbol;
  838|       |
  839|  3.23k|      if (status != REG_OK)
  ------------------
  |  Branch (839:11): [True: 0, False: 3.23k]
  ------------------
  840|      0|	break;
  841|       |
  842|  3.23k|      DPRINT(("pos_add %d\n", pos_add));
  ------------------
  |  |   27|  3.23k|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 3.23k]
  |  |  ------------------
  ------------------
  843|       |
  844|  3.23k|      symbol = (tre_expand_ast_symbol_t)tre_stack_pop_int(stack);
  845|  3.23k|      node = tre_stack_pop_voidptr(stack);
  846|  3.23k|      switch (symbol)
  847|  3.23k|	{
  848|  3.01k|	case EXPAND_RECURSE:
  ------------------
  |  Branch (848:2): [True: 3.01k, False: 219]
  ------------------
  849|  3.01k|	  switch (node->type)
  850|  3.01k|	    {
  851|  1.50k|	    case LITERAL:
  ------------------
  |  Branch (851:6): [True: 1.50k, False: 1.51k]
  ------------------
  852|  1.50k|	      {
  853|  1.50k|		tre_literal_t *lit= node->obj;
  854|  1.50k|		if (!IS_SPECIAL(lit) || IS_BACKREF(lit))
  ------------------
  |  |   32|  3.00k|#define IS_SPECIAL(x)	((x)->code_min < 0)
  ------------------
              		if (!IS_SPECIAL(lit) || IS_BACKREF(lit))
  ------------------
  |  |   36|    613|#define IS_BACKREF(x)	((x)->code_min == BACKREF)
  |  |  ------------------
  |  |  |  |   29|    613|#define BACKREF	  -4   /* Back reference leaf. */
  |  |  ------------------
  |  |  |  Branch (36:23): [True: 0, False: 613]
  |  |  ------------------
  ------------------
  |  Branch (854:7): [True: 889, False: 613]
  ------------------
  855|    889|		  {
  856|    889|		    lit->position += pos_add;
  857|    889|		    if (lit->position > max_pos)
  ------------------
  |  Branch (857:11): [True: 553, False: 336]
  ------------------
  858|    553|		      max_pos = lit->position;
  859|    889|		  }
  860|  1.50k|		break;
  861|      0|	      }
  862|    159|	    case UNION:
  ------------------
  |  Branch (862:6): [True: 159, False: 2.85k]
  ------------------
  863|    159|	      {
  864|    159|		tre_union_t *uni = node->obj;
  865|    159|		STACK_PUSHX(stack, voidptr, uni->right);
  ------------------
  |  |   60|    159|  {									      \
  |  |   61|    159|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    159|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 159]
  |  |  ------------------
  |  |   63|    159|      break;								      \
  |  |   64|    159|  }
  ------------------
  866|    159|		STACK_PUSHX(stack, int, EXPAND_RECURSE);
  ------------------
  |  |   60|    159|  {									      \
  |  |   61|    159|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    159|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 159]
  |  |  ------------------
  |  |   63|    159|      break;								      \
  |  |   64|    159|  }
  ------------------
  867|    159|		STACK_PUSHX(stack, voidptr, uni->left);
  ------------------
  |  |   60|    159|  {									      \
  |  |   61|    159|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    159|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 159]
  |  |  ------------------
  |  |   63|    159|      break;								      \
  |  |   64|    159|  }
  ------------------
  868|    159|		STACK_PUSHX(stack, int, EXPAND_RECURSE);
  ------------------
  |  |   60|    159|  {									      \
  |  |   61|    159|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    159|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 159]
  |  |  ------------------
  |  |   63|    159|      break;								      \
  |  |   64|    159|  }
  ------------------
  869|    159|		break;
  870|    159|	      }
  871|  1.13k|	    case CATENATION:
  ------------------
  |  Branch (871:6): [True: 1.13k, False: 1.88k]
  ------------------
  872|  1.13k|	      {
  873|  1.13k|		tre_catenation_t *cat = node->obj;
  874|  1.13k|		STACK_PUSHX(stack, voidptr, cat->right);
  ------------------
  |  |   60|  1.13k|  {									      \
  |  |   61|  1.13k|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|  1.13k|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 1.13k]
  |  |  ------------------
  |  |   63|  1.13k|      break;								      \
  |  |   64|  1.13k|  }
  ------------------
  875|  1.13k|		STACK_PUSHX(stack, int, EXPAND_RECURSE);
  ------------------
  |  |   60|  1.13k|  {									      \
  |  |   61|  1.13k|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|  1.13k|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 1.13k]
  |  |  ------------------
  |  |   63|  1.13k|      break;								      \
  |  |   64|  1.13k|  }
  ------------------
  876|  1.13k|		STACK_PUSHX(stack, voidptr, cat->left);
  ------------------
  |  |   60|  1.13k|  {									      \
  |  |   61|  1.13k|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|  1.13k|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 1.13k]
  |  |  ------------------
  |  |   63|  1.13k|      break;								      \
  |  |   64|  1.13k|  }
  ------------------
  877|  1.13k|		STACK_PUSHX(stack, int, EXPAND_RECURSE);
  ------------------
  |  |   60|  1.13k|  {									      \
  |  |   61|  1.13k|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|  1.13k|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 1.13k]
  |  |  ------------------
  |  |   63|  1.13k|      break;								      \
  |  |   64|  1.13k|  }
  ------------------
  878|  1.13k|		break;
  879|  1.13k|	      }
  880|    219|	    case ITERATION:
  ------------------
  |  Branch (880:6): [True: 219, False: 2.79k]
  ------------------
  881|    219|	      {
  882|    219|		tre_iteration_t *iter = node->obj;
  883|    219|		STACK_PUSHX(stack, int, pos_add);
  ------------------
  |  |   60|    219|  {									      \
  |  |   61|    219|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    219|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 219]
  |  |  ------------------
  |  |   63|    219|      break;								      \
  |  |   64|    219|  }
  ------------------
  884|    219|		STACK_PUSHX(stack, voidptr, node);
  ------------------
  |  |   60|    219|  {									      \
  |  |   61|    219|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    219|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 219]
  |  |  ------------------
  |  |   63|    219|      break;								      \
  |  |   64|    219|  }
  ------------------
  885|    219|		STACK_PUSHX(stack, int, EXPAND_AFTER_ITER);
  ------------------
  |  |   60|    219|  {									      \
  |  |   61|    219|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    219|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 219]
  |  |  ------------------
  |  |   63|    219|      break;								      \
  |  |   64|    219|  }
  ------------------
  886|    219|		STACK_PUSHX(stack, voidptr, iter->arg);
  ------------------
  |  |   60|    219|  {									      \
  |  |   61|    219|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    219|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 219]
  |  |  ------------------
  |  |   63|    219|      break;								      \
  |  |   64|    219|  }
  ------------------
  887|    219|		STACK_PUSHX(stack, int, EXPAND_RECURSE);
  ------------------
  |  |   60|    219|  {									      \
  |  |   61|    219|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    219|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 219]
  |  |  ------------------
  |  |   63|    219|      break;								      \
  |  |   64|    219|  }
  ------------------
  888|       |		/* If we are going to expand this node at EXPAND_AFTER_ITER
  889|       |		   then don't increase the `pos' fields of the nodes now, it
  890|       |		   will get done when expanding. */
  891|    219|		if (iter->min > 1 || iter->max > 1)
  ------------------
  |  Branch (891:7): [True: 0, False: 219]
  |  Branch (891:24): [True: 0, False: 219]
  ------------------
  892|      0|		  pos_add = 0;
  893|    219|		iter_depth++;
  894|    219|		DPRINT(("iter\n"));
  ------------------
  |  |   27|    219|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 219]
  |  |  ------------------
  ------------------
  895|    219|		break;
  896|    219|	      }
  897|      0|	    default:
  ------------------
  |  Branch (897:6): [True: 0, False: 3.01k]
  ------------------
  898|      0|	      assert(0);
  ------------------
  |  |   32|      0|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|      0|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  899|      0|	      break;
  900|  3.01k|	    }
  901|  3.01k|	  break;
  902|  3.01k|	case EXPAND_AFTER_ITER:
  ------------------
  |  Branch (902:2): [True: 219, False: 3.01k]
  ------------------
  903|    219|	  {
  904|    219|	    tre_iteration_t *iter = node->obj;
  905|    219|	    int pos_add_last;
  906|    219|	    pos_add = tre_stack_pop_int(stack);
  907|    219|	    pos_add_last = pos_add;
  908|    219|	    if (iter->min > 1 || iter->max > 1)
  ------------------
  |  Branch (908:10): [True: 0, False: 219]
  |  Branch (908:27): [True: 0, False: 219]
  ------------------
  909|      0|	      {
  910|      0|		tre_ast_node_t *seq1 = NULL, *seq2 = NULL;
  911|      0|		int j;
  912|      0|		int pos_add_save = pos_add;
  913|       |
  914|       |		/* Create a catenated sequence of copies of the node. */
  915|      0|		for (j = 0; j < iter->min; j++)
  ------------------
  |  Branch (915:15): [True: 0, False: 0]
  ------------------
  916|      0|		  {
  917|      0|		    tre_ast_node_t *copy;
  918|       |		    /* Remove tags from all but the last copy. */
  919|      0|		    int flags = ((j + 1 < iter->min)
  ------------------
  |  Branch (919:20): [True: 0, False: 0]
  ------------------
  920|      0|				 ? COPY_REMOVE_TAGS
  ------------------
  |  |  656|      0|#define COPY_REMOVE_TAGS	 1
  ------------------
  921|      0|				 : COPY_MAXIMIZE_FIRST_TAG);
  ------------------
  |  |  657|      0|#define COPY_MAXIMIZE_FIRST_TAG	 2
  ------------------
  922|      0|		    DPRINT(("  pos_add %d\n", pos_add));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  923|      0|		    pos_add_save = pos_add;
  924|      0|		    status = tre_copy_ast(mem, stack, iter->arg, flags,
  925|      0|					  &pos_add, tag_directions, &copy,
  926|      0|					  &max_pos);
  927|      0|		    if (status != REG_OK)
  ------------------
  |  Branch (927:11): [True: 0, False: 0]
  ------------------
  928|      0|		      return status;
  929|      0|		    if (max_pos > TRE_EXPAND_MAX_POSITIONS)
  ------------------
  |  |  808|      0|#define TRE_EXPAND_MAX_POSITIONS 100000
  ------------------
  |  Branch (929:11): [True: 0, False: 0]
  ------------------
  930|      0|		      return REG_ESPACE;
  931|      0|		    if (seq1 != NULL)
  ------------------
  |  Branch (931:11): [True: 0, False: 0]
  ------------------
  932|      0|		      seq1 = tre_ast_new_catenation(mem, seq1, copy);
  933|      0|		    else
  934|      0|		      seq1 = copy;
  935|      0|		    if (seq1 == NULL)
  ------------------
  |  Branch (935:11): [True: 0, False: 0]
  ------------------
  936|      0|		      return REG_ESPACE;
  937|      0|		  }
  938|       |
  939|      0|		if (iter->max == -1)
  ------------------
  |  Branch (939:7): [True: 0, False: 0]
  ------------------
  940|      0|		  {
  941|       |		    /* No upper limit. */
  942|      0|		    pos_add_save = pos_add;
  943|      0|		    status = tre_copy_ast(mem, stack, iter->arg, 0,
  944|      0|					  &pos_add, NULL, &seq2, &max_pos);
  945|      0|		    if (status != REG_OK)
  ------------------
  |  Branch (945:11): [True: 0, False: 0]
  ------------------
  946|      0|		      return status;
  947|      0|		    seq2 = tre_ast_new_iter(mem, seq2, 0, -1, 0);
  948|      0|		    if (seq2 == NULL)
  ------------------
  |  Branch (948:11): [True: 0, False: 0]
  ------------------
  949|      0|		      return REG_ESPACE;
  950|      0|		  }
  951|      0|		else
  952|      0|		  {
  953|      0|		    for (j = iter->min; j < iter->max; j++)
  ------------------
  |  Branch (953:27): [True: 0, False: 0]
  ------------------
  954|      0|		      {
  955|      0|			tre_ast_node_t *tmp, *copy;
  956|      0|			pos_add_save = pos_add;
  957|      0|			status = tre_copy_ast(mem, stack, iter->arg, 0,
  958|      0|					      &pos_add, NULL, &copy, &max_pos);
  959|      0|			if (status != REG_OK)
  ------------------
  |  Branch (959:8): [True: 0, False: 0]
  ------------------
  960|      0|			  return status;
  961|      0|			if (max_pos > TRE_EXPAND_MAX_POSITIONS)
  ------------------
  |  |  808|      0|#define TRE_EXPAND_MAX_POSITIONS 100000
  ------------------
  |  Branch (961:8): [True: 0, False: 0]
  ------------------
  962|      0|			  return REG_ESPACE;
  963|      0|			if (seq2 != NULL)
  ------------------
  |  Branch (963:8): [True: 0, False: 0]
  ------------------
  964|      0|			  seq2 = tre_ast_new_catenation(mem, copy, seq2);
  965|      0|			else
  966|      0|			  seq2 = copy;
  967|      0|			if (seq2 == NULL)
  ------------------
  |  Branch (967:8): [True: 0, False: 0]
  ------------------
  968|      0|			  return REG_ESPACE;
  969|      0|			tmp = tre_ast_new_literal(mem, EMPTY, -1, -1);
  ------------------
  |  |   26|      0|#define EMPTY	  -1   /* Empty leaf (denotes empty string). */
  ------------------
  970|      0|			if (tmp == NULL)
  ------------------
  |  Branch (970:8): [True: 0, False: 0]
  ------------------
  971|      0|			  return REG_ESPACE;
  972|      0|			seq2 = tre_ast_new_union(mem, tmp, seq2);
  973|      0|			if (seq2 == NULL)
  ------------------
  |  Branch (973:8): [True: 0, False: 0]
  ------------------
  974|      0|			  return REG_ESPACE;
  975|      0|		      }
  976|      0|		  }
  977|       |
  978|      0|		pos_add = pos_add_save;
  979|      0|		if (seq1 == NULL)
  ------------------
  |  Branch (979:7): [True: 0, False: 0]
  ------------------
  980|      0|		  seq1 = seq2;
  981|      0|		else if (seq2 != NULL)
  ------------------
  |  Branch (981:12): [True: 0, False: 0]
  ------------------
  982|      0|		  seq1 = tre_ast_new_catenation(mem, seq1, seq2);
  983|      0|		if (seq1 == NULL)
  ------------------
  |  Branch (983:7): [True: 0, False: 0]
  ------------------
  984|      0|		  return REG_ESPACE;
  985|      0|		node->obj = seq1->obj;
  986|      0|		node->type = seq1->type;
  987|      0|	      }
  988|       |
  989|    219|	    iter_depth--;
  990|    219|	    pos_add_total += pos_add - pos_add_last;
  991|    219|	    if (iter_depth == 0)
  ------------------
  |  Branch (991:10): [True: 191, False: 28]
  ------------------
  992|    191|	      pos_add = pos_add_total;
  993|       |
  994|       |	    /* If approximate parameters are specified, surround the result
  995|       |	       with two parameter setting nodes.  The one on the left sets
  996|       |	       the specified parameters, and the one on the right restores
  997|       |	       the old parameters. */
  998|    219|	    if (iter->params)
  ------------------
  |  Branch (998:10): [True: 0, False: 219]
  ------------------
  999|      0|	      {
 1000|      0|		tre_ast_node_t *tmp_l, *tmp_r, *tmp_node, *node_copy;
 1001|      0|		int *old_params;
 1002|       |
 1003|      0|		tmp_l = tre_ast_new_literal(mem, PARAMETER, 0, -1);
  ------------------
  |  |   30|      0|#define PARAMETER -5   /* Parameter. */
  ------------------
 1004|      0|		if (!tmp_l)
  ------------------
  |  Branch (1004:7): [True: 0, False: 0]
  ------------------
 1005|      0|		  return REG_ESPACE;
 1006|      0|		((tre_literal_t *)tmp_l->obj)->u.params = iter->params;
 1007|      0|		iter->params[TRE_PARAM_DEPTH] = params_depth + 1;
 1008|      0|		tmp_r = tre_ast_new_literal(mem, PARAMETER, 0, -1);
  ------------------
  |  |   30|      0|#define PARAMETER -5   /* Parameter. */
  ------------------
 1009|      0|		if (!tmp_r)
  ------------------
  |  Branch (1009:7): [True: 0, False: 0]
  ------------------
 1010|      0|		  return REG_ESPACE;
 1011|      0|		old_params = tre_mem_alloc(mem, sizeof(*old_params)
  ------------------
  |  |   40|      0|#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
  ------------------
 1012|      0|					   * TRE_PARAM_LAST);
 1013|      0|		if (!old_params)
  ------------------
  |  Branch (1013:7): [True: 0, False: 0]
  ------------------
 1014|      0|		  return REG_ESPACE;
 1015|      0|		for (i = 0; i < TRE_PARAM_LAST; i++)
  ------------------
  |  Branch (1015:15): [True: 0, False: 0]
  ------------------
 1016|      0|		  old_params[i] = params[i];
 1017|      0|		((tre_literal_t *)tmp_r->obj)->u.params = old_params;
 1018|      0|		old_params[TRE_PARAM_DEPTH] = params_depth;
 1019|       |		/* XXX - this is the only place where ast_new_node is
 1020|       |		   needed -- should be moved inside AST module. */
 1021|      0|		node_copy = tre_ast_new_node(mem, node->type,
 1022|      0|					     sizeof(tre_iteration_t));
 1023|      0|		if (!node_copy)
  ------------------
  |  Branch (1023:7): [True: 0, False: 0]
  ------------------
 1024|      0|		  return REG_ESPACE;
 1025|      0|		node_copy->obj = node->obj;
 1026|      0|		tmp_node = tre_ast_new_catenation(mem, tmp_l, node_copy);
 1027|      0|		if (!tmp_node)
  ------------------
  |  Branch (1027:7): [True: 0, False: 0]
  ------------------
 1028|      0|		  return REG_ESPACE;
 1029|      0|		tmp_node = tre_ast_new_catenation(mem, tmp_node, tmp_r);
 1030|      0|		if (!tmp_node)
  ------------------
  |  Branch (1030:7): [True: 0, False: 0]
  ------------------
 1031|      0|		  return REG_ESPACE;
 1032|       |		/* Replace the contents of `node' with `tmp_node'. */
 1033|      0|		memcpy(node, tmp_node, sizeof(*node));
 1034|      0|		node->obj = tmp_node->obj;
 1035|      0|		node->type = tmp_node->type;
 1036|      0|		params_depth++;
 1037|      0|		if (params_depth > *max_depth)
  ------------------
  |  Branch (1037:7): [True: 0, False: 0]
  ------------------
 1038|      0|		  *max_depth = params_depth;
 1039|      0|	      }
 1040|    219|	    break;
 1041|    219|	  }
 1042|    219|	default:
  ------------------
  |  Branch (1042:2): [True: 0, False: 3.23k]
  ------------------
 1043|      0|	  assert(0);
  ------------------
  |  |   32|      0|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|      0|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1044|      0|	  break;
 1045|  3.23k|	}
 1046|  3.23k|    }
 1047|       |
 1048|    206|  *position += pos_add_total;
 1049|       |
 1050|       |  /* `max_pos' should never be larger than `*position' if the above
 1051|       |     code works, but just an extra safeguard let's make sure
 1052|       |     `*position' is set large enough so enough memory will be
 1053|       |     allocated for the transition table. */
 1054|    206|  if (max_pos > *position)
  ------------------
  |  Branch (1054:7): [True: 0, False: 206]
  ------------------
 1055|      0|    *position = max_pos;
 1056|       |
 1057|       |#ifdef TRE_DEBUG
 1058|       |  DPRINT(("Expanded AST:\n"));
 1059|       |  tre_ast_print(ast);
 1060|       |  DPRINT(("*position %d, max_pos %d\n", *position, max_pos));
 1061|       |#endif
 1062|       |
 1063|    206|  return status;
 1064|    206|}
tre-compile.c:tre_compute_nfl:
 1336|    206|{
 1337|    206|  int bottom = tre_stack_num_objects(stack);
 1338|       |
 1339|    206|  STACK_PUSHR(stack, voidptr, tree);
  ------------------
  |  |   67|    206|  {									      \
  |  |   68|    206|    reg_errcode_t _status;						      \
  |  |   69|    206|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    206|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 206]
  |  |  ------------------
  |  |   71|    206|      return _status;							      \
  |  |   72|    206|  }
  ------------------
 1340|    206|  STACK_PUSHR(stack, int, NFL_RECURSE);
  ------------------
  |  |   67|    206|  {									      \
  |  |   68|    206|    reg_errcode_t _status;						      \
  |  |   69|    206|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    206|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 206]
  |  |  ------------------
  |  |   71|    206|      return _status;							      \
  |  |   72|    206|  }
  ------------------
 1341|       |
 1342|  5.35k|  while (tre_stack_num_objects(stack) > bottom)
  ------------------
  |  Branch (1342:10): [True: 5.15k, False: 206]
  ------------------
 1343|  5.15k|    {
 1344|  5.15k|      tre_nfl_stack_symbol_t symbol;
 1345|  5.15k|      tre_ast_node_t *node;
 1346|       |
 1347|  5.15k|      symbol = (tre_nfl_stack_symbol_t)tre_stack_pop_int(stack);
 1348|  5.15k|      node = tre_stack_pop_voidptr(stack);
 1349|  5.15k|      switch (symbol)
 1350|  5.15k|	{
 1351|  3.42k|	case NFL_RECURSE:
  ------------------
  |  Branch (1351:2): [True: 3.42k, False: 1.72k]
  ------------------
 1352|  3.42k|	  switch (node->type)
  ------------------
  |  Branch (1352:12): [True: 3.42k, False: 0]
  ------------------
 1353|  3.42k|	    {
 1354|  1.70k|	    case LITERAL:
  ------------------
  |  Branch (1354:6): [True: 1.70k, False: 1.72k]
  ------------------
 1355|  1.70k|	      {
 1356|  1.70k|		tre_literal_t *lit = (tre_literal_t *)node->obj;
 1357|  1.70k|		if (IS_BACKREF(lit))
  ------------------
  |  |   36|  1.70k|#define IS_BACKREF(x)	((x)->code_min == BACKREF)
  |  |  ------------------
  |  |  |  |   29|  1.70k|#define BACKREF	  -4   /* Back reference leaf. */
  |  |  ------------------
  |  |  |  Branch (36:23): [True: 0, False: 1.70k]
  |  |  ------------------
  ------------------
 1358|      0|		  {
 1359|       |		    /* Back references: nullable = false, firstpos = {i},
 1360|       |		       lastpos = {i}. */
 1361|      0|		    node->nullable = 0;
 1362|      0|		    node->firstpos = tre_set_one(mem, lit->position, 0,
 1363|      0|					     TRE_CHAR_MAX, 0, NULL, -1);
  ------------------
  |  |   64|      0|# define TRE_CHAR_MAX WCHAR_MAX
  ------------------
 1364|      0|		    if (!node->firstpos)
  ------------------
  |  Branch (1364:11): [True: 0, False: 0]
  ------------------
 1365|      0|		      return REG_ESPACE;
 1366|      0|		    node->lastpos = tre_set_one(mem, lit->position, 0,
 1367|      0|						TRE_CHAR_MAX, 0, NULL,
  ------------------
  |  |   64|      0|# define TRE_CHAR_MAX WCHAR_MAX
  ------------------
 1368|      0|						(int)lit->code_max);
 1369|      0|		    if (!node->lastpos)
  ------------------
  |  Branch (1369:11): [True: 0, False: 0]
  ------------------
 1370|      0|		      return REG_ESPACE;
 1371|      0|		  }
 1372|  1.70k|		else if (lit->code_min < 0)
  ------------------
  |  Branch (1372:12): [True: 613, False: 1.09k]
  ------------------
 1373|    613|		  {
 1374|       |		    /* Tags, empty strings, params, and zero width assertions:
 1375|       |		       nullable = true, firstpos = {}, and lastpos = {}. */
 1376|    613|		    node->nullable = 1;
 1377|    613|		    node->firstpos = tre_set_empty(mem);
 1378|    613|		    if (!node->firstpos)
  ------------------
  |  Branch (1378:11): [True: 0, False: 613]
  ------------------
 1379|      0|		      return REG_ESPACE;
 1380|    613|		    node->lastpos = tre_set_empty(mem);
 1381|    613|		    if (!node->lastpos)
  ------------------
  |  Branch (1381:11): [True: 0, False: 613]
  ------------------
 1382|      0|		      return REG_ESPACE;
 1383|    613|		  }
 1384|  1.09k|		else
 1385|  1.09k|		  {
 1386|       |		    /* Literal at position i: nullable = false, firstpos = {i},
 1387|       |		       lastpos = {i}. */
 1388|  1.09k|		    node->nullable = 0;
 1389|  1.09k|		    node->firstpos =
 1390|  1.09k|		      tre_set_one(mem, lit->position, (int)lit->code_min,
 1391|  1.09k|				  (int)lit->code_max, 0, NULL, -1);
 1392|  1.09k|		    if (!node->firstpos)
  ------------------
  |  Branch (1392:11): [True: 0, False: 1.09k]
  ------------------
 1393|      0|		      return REG_ESPACE;
 1394|  1.09k|		    node->lastpos = tre_set_one(mem, lit->position,
 1395|  1.09k|						(int)lit->code_min,
 1396|  1.09k|						(int)lit->code_max,
 1397|  1.09k|						lit->u.class, lit->neg_classes,
 1398|  1.09k|						-1);
 1399|  1.09k|		    if (!node->lastpos)
  ------------------
  |  Branch (1399:11): [True: 0, False: 1.09k]
  ------------------
 1400|      0|		      return REG_ESPACE;
 1401|  1.09k|		  }
 1402|  1.70k|		break;
 1403|  1.70k|	      }
 1404|       |
 1405|  1.70k|	    case UNION:
  ------------------
  |  Branch (1405:6): [True: 159, False: 3.27k]
  ------------------
 1406|       |	      /* Compute the attributes for the two subtrees, and after that
 1407|       |		 for this node. */
 1408|    159|	      STACK_PUSHR(stack, voidptr, node);
  ------------------
  |  |   67|    159|  {									      \
  |  |   68|    159|    reg_errcode_t _status;						      \
  |  |   69|    159|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    159|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 159]
  |  |  ------------------
  |  |   71|    159|      return _status;							      \
  |  |   72|    159|  }
  ------------------
 1409|    159|	      STACK_PUSHR(stack, int, NFL_POST_UNION);
  ------------------
  |  |   67|    159|  {									      \
  |  |   68|    159|    reg_errcode_t _status;						      \
  |  |   69|    159|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    159|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 159]
  |  |  ------------------
  |  |   71|    159|      return _status;							      \
  |  |   72|    159|  }
  ------------------
 1410|    159|	      STACK_PUSHR(stack, voidptr, ((tre_union_t *)node->obj)->right);
  ------------------
  |  |   67|    159|  {									      \
  |  |   68|    159|    reg_errcode_t _status;						      \
  |  |   69|    159|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    159|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 159]
  |  |  ------------------
  |  |   71|    159|      return _status;							      \
  |  |   72|    159|  }
  ------------------
 1411|    159|	      STACK_PUSHR(stack, int, NFL_RECURSE);
  ------------------
  |  |   67|    159|  {									      \
  |  |   68|    159|    reg_errcode_t _status;						      \
  |  |   69|    159|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    159|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 159]
  |  |  ------------------
  |  |   71|    159|      return _status;							      \
  |  |   72|    159|  }
  ------------------
 1412|    159|	      STACK_PUSHR(stack, voidptr, ((tre_union_t *)node->obj)->left);
  ------------------
  |  |   67|    159|  {									      \
  |  |   68|    159|    reg_errcode_t _status;						      \
  |  |   69|    159|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    159|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 159]
  |  |  ------------------
  |  |   71|    159|      return _status;							      \
  |  |   72|    159|  }
  ------------------
 1413|    159|	      STACK_PUSHR(stack, int, NFL_RECURSE);
  ------------------
  |  |   67|    159|  {									      \
  |  |   68|    159|    reg_errcode_t _status;						      \
  |  |   69|    159|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    159|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 159]
  |  |  ------------------
  |  |   71|    159|      return _status;							      \
  |  |   72|    159|  }
  ------------------
 1414|    159|	      break;
 1415|       |
 1416|  1.34k|	    case CATENATION:
  ------------------
  |  Branch (1416:6): [True: 1.34k, False: 2.08k]
  ------------------
 1417|       |	      /* Compute the attributes for the two subtrees, and after that
 1418|       |		 for this node. */
 1419|  1.34k|	      STACK_PUSHR(stack, voidptr, node);
  ------------------
  |  |   67|  1.34k|  {									      \
  |  |   68|  1.34k|    reg_errcode_t _status;						      \
  |  |   69|  1.34k|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|  1.34k|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 1.34k]
  |  |  ------------------
  |  |   71|  1.34k|      return _status;							      \
  |  |   72|  1.34k|  }
  ------------------
 1420|  1.34k|	      STACK_PUSHR(stack, int, NFL_POST_CATENATION);
  ------------------
  |  |   67|  1.34k|  {									      \
  |  |   68|  1.34k|    reg_errcode_t _status;						      \
  |  |   69|  1.34k|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|  1.34k|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 1.34k]
  |  |  ------------------
  |  |   71|  1.34k|      return _status;							      \
  |  |   72|  1.34k|  }
  ------------------
 1421|  1.34k|	      STACK_PUSHR(stack, voidptr, ((tre_catenation_t *)node->obj)->right);
  ------------------
  |  |   67|  1.34k|  {									      \
  |  |   68|  1.34k|    reg_errcode_t _status;						      \
  |  |   69|  1.34k|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|  1.34k|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 1.34k]
  |  |  ------------------
  |  |   71|  1.34k|      return _status;							      \
  |  |   72|  1.34k|  }
  ------------------
 1422|  1.34k|	      STACK_PUSHR(stack, int, NFL_RECURSE);
  ------------------
  |  |   67|  1.34k|  {									      \
  |  |   68|  1.34k|    reg_errcode_t _status;						      \
  |  |   69|  1.34k|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|  1.34k|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 1.34k]
  |  |  ------------------
  |  |   71|  1.34k|      return _status;							      \
  |  |   72|  1.34k|  }
  ------------------
 1423|  1.34k|	      STACK_PUSHR(stack, voidptr, ((tre_catenation_t *)node->obj)->left);
  ------------------
  |  |   67|  1.34k|  {									      \
  |  |   68|  1.34k|    reg_errcode_t _status;						      \
  |  |   69|  1.34k|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|  1.34k|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 1.34k]
  |  |  ------------------
  |  |   71|  1.34k|      return _status;							      \
  |  |   72|  1.34k|  }
  ------------------
 1424|  1.34k|	      STACK_PUSHR(stack, int, NFL_RECURSE);
  ------------------
  |  |   67|  1.34k|  {									      \
  |  |   68|  1.34k|    reg_errcode_t _status;						      \
  |  |   69|  1.34k|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|  1.34k|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 1.34k]
  |  |  ------------------
  |  |   71|  1.34k|      return _status;							      \
  |  |   72|  1.34k|  }
  ------------------
 1425|  1.34k|	      break;
 1426|       |
 1427|    219|	    case ITERATION:
  ------------------
  |  Branch (1427:6): [True: 219, False: 3.21k]
  ------------------
 1428|       |	      /* Compute the attributes for the subtree, and after that for
 1429|       |		 this node. */
 1430|    219|	      STACK_PUSHR(stack, voidptr, node);
  ------------------
  |  |   67|    219|  {									      \
  |  |   68|    219|    reg_errcode_t _status;						      \
  |  |   69|    219|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    219|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 219]
  |  |  ------------------
  |  |   71|    219|      return _status;							      \
  |  |   72|    219|  }
  ------------------
 1431|    219|	      STACK_PUSHR(stack, int, NFL_POST_ITERATION);
  ------------------
  |  |   67|    219|  {									      \
  |  |   68|    219|    reg_errcode_t _status;						      \
  |  |   69|    219|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    219|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 219]
  |  |  ------------------
  |  |   71|    219|      return _status;							      \
  |  |   72|    219|  }
  ------------------
 1432|    219|	      STACK_PUSHR(stack, voidptr, ((tre_iteration_t *)node->obj)->arg);
  ------------------
  |  |   67|    219|  {									      \
  |  |   68|    219|    reg_errcode_t _status;						      \
  |  |   69|    219|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    219|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 219]
  |  |  ------------------
  |  |   71|    219|      return _status;							      \
  |  |   72|    219|  }
  ------------------
 1433|    219|	      STACK_PUSHR(stack, int, NFL_RECURSE);
  ------------------
  |  |   67|    219|  {									      \
  |  |   68|    219|    reg_errcode_t _status;						      \
  |  |   69|    219|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    219|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 219]
  |  |  ------------------
  |  |   71|    219|      return _status;							      \
  |  |   72|    219|  }
  ------------------
 1434|    219|	      break;
 1435|  3.42k|	    }
 1436|  3.42k|	  break; /* end case: NFL_RECURSE */
 1437|       |
 1438|  3.42k|	case NFL_POST_UNION:
  ------------------
  |  Branch (1438:2): [True: 159, False: 4.99k]
  ------------------
 1439|    159|	  {
 1440|    159|	    tre_union_t *uni = (tre_union_t *)node->obj;
 1441|    159|	    node->nullable = uni->left->nullable || uni->right->nullable;
  ------------------
  |  Branch (1441:23): [True: 28, False: 131]
  |  Branch (1441:46): [True: 0, False: 131]
  ------------------
 1442|    159|	    node->firstpos = tre_set_union(mem, uni->left->firstpos,
 1443|    159|					   uni->right->firstpos, NULL, 0, NULL);
 1444|    159|	    if (!node->firstpos)
  ------------------
  |  Branch (1444:10): [True: 0, False: 159]
  ------------------
 1445|      0|	      return REG_ESPACE;
 1446|    159|	    node->lastpos = tre_set_union(mem, uni->left->lastpos,
 1447|    159|					  uni->right->lastpos, NULL, 0, NULL);
 1448|    159|	    if (!node->lastpos)
  ------------------
  |  Branch (1448:10): [True: 0, False: 159]
  ------------------
 1449|      0|	      return REG_ESPACE;
 1450|    159|	    break;
 1451|    159|	  }
 1452|       |
 1453|    219|	case NFL_POST_ITERATION:
  ------------------
  |  Branch (1453:2): [True: 219, False: 4.93k]
  ------------------
 1454|    219|	  {
 1455|    219|	    tre_iteration_t *iter = (tre_iteration_t *)node->obj;
 1456|       |
 1457|    219|	    if (iter->min == 0 || iter->arg->nullable)
  ------------------
  |  Branch (1457:10): [True: 90, False: 129]
  |  Branch (1457:28): [True: 0, False: 129]
  ------------------
 1458|     90|	      node->nullable = 1;
 1459|    129|	    else
 1460|    129|	      node->nullable = 0;
 1461|    219|	    node->firstpos = iter->arg->firstpos;
 1462|    219|	    node->lastpos = iter->arg->lastpos;
 1463|    219|	    break;
 1464|    159|	  }
 1465|       |
 1466|  1.34k|	case NFL_POST_CATENATION:
  ------------------
  |  Branch (1466:2): [True: 1.34k, False: 3.80k]
  ------------------
 1467|  1.34k|	  {
 1468|  1.34k|	    int num_tags, *tags, assertions, params_seen;
 1469|  1.34k|	    int *params;
 1470|  1.34k|	    reg_errcode_t status;
 1471|  1.34k|	    tre_catenation_t *cat = node->obj;
 1472|  1.34k|	    node->nullable = cat->left->nullable && cat->right->nullable;
  ------------------
  |  Branch (1472:23): [True: 508, False: 835]
  |  Branch (1472:46): [True: 168, False: 340]
  ------------------
 1473|       |
 1474|       |	    /* Compute firstpos. */
 1475|  1.34k|	    if (cat->left->nullable)
  ------------------
  |  Branch (1475:10): [True: 508, False: 835]
  ------------------
 1476|    508|	      {
 1477|       |		/* The left side matches the empty string.  Make a first pass
 1478|       |		   with tre_match_empty() to get the number of tags and
 1479|       |		   parameters. */
 1480|    508|		status = tre_match_empty(stack, cat->left,
 1481|    508|					 NULL, NULL, NULL, &num_tags,
 1482|    508|					 &params_seen);
 1483|    508|		if (status != REG_OK)
  ------------------
  |  Branch (1483:7): [True: 0, False: 508]
  ------------------
 1484|      0|		  return status;
 1485|       |		/* Allocate arrays for the tags and parameters. */
 1486|    508|		tags = xmalloc(sizeof(*tags) * (num_tags + 1));
  ------------------
  |  |   67|    508|#define xmalloc(size) malloc(size)
  ------------------
 1487|    508|		if (!tags)
  ------------------
  |  Branch (1487:7): [True: 0, False: 508]
  ------------------
 1488|      0|		  return REG_ESPACE;
 1489|    508|		tags[0] = -1;
 1490|    508|		assertions = 0;
 1491|    508|		params = NULL;
 1492|    508|		if (params_seen)
  ------------------
  |  Branch (1492:7): [True: 0, False: 508]
  ------------------
 1493|      0|		  {
 1494|      0|		    params = tre_mem_alloc(mem, sizeof(*params)
  ------------------
  |  |   40|      0|#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
  ------------------
 1495|      0|					   * TRE_PARAM_LAST);
 1496|      0|		    if (!params)
  ------------------
  |  Branch (1496:11): [True: 0, False: 0]
  ------------------
 1497|      0|		      {
 1498|      0|			xfree(tags);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
 1499|      0|			return REG_ESPACE;
 1500|      0|		      }
 1501|      0|		  }
 1502|       |		/* Second pass with tre_mach_empty() to get the list of
 1503|       |		   tags and parameters. */
 1504|    508|		status = tre_match_empty(stack, cat->left, tags,
 1505|    508|					 &assertions, params, NULL, NULL);
 1506|    508|		if (status != REG_OK)
  ------------------
  |  Branch (1506:7): [True: 0, False: 508]
  ------------------
 1507|      0|		  {
 1508|      0|		    xfree(tags);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
 1509|      0|		    return status;
 1510|      0|		  }
 1511|    508|		node->firstpos =
 1512|    508|		  tre_set_union(mem, cat->right->firstpos, cat->left->firstpos,
 1513|    508|				tags, assertions, params);
 1514|    508|		xfree(tags);
  ------------------
  |  |   69|    508|#define xfree(ptr) free(ptr)
  ------------------
 1515|    508|		if (!node->firstpos)
  ------------------
  |  Branch (1515:7): [True: 0, False: 508]
  ------------------
 1516|      0|		  return REG_ESPACE;
 1517|    508|	      }
 1518|    835|	    else
 1519|    835|	      {
 1520|    835|		node->firstpos = cat->left->firstpos;
 1521|    835|	      }
 1522|       |
 1523|       |	    /* Compute lastpos. */
 1524|  1.34k|	    if (cat->right->nullable)
  ------------------
  |  Branch (1524:10): [True: 363, False: 980]
  ------------------
 1525|    363|	      {
 1526|       |		/* The right side matches the empty string.  Make a first pass
 1527|       |		   with tre_match_empty() to get the number of tags and
 1528|       |		   parameters. */
 1529|    363|		status = tre_match_empty(stack, cat->right,
 1530|    363|					 NULL, NULL, NULL, &num_tags,
 1531|    363|					 &params_seen);
 1532|    363|		if (status != REG_OK)
  ------------------
  |  Branch (1532:7): [True: 0, False: 363]
  ------------------
 1533|      0|		  return status;
 1534|       |		/* Allocate arrays for the tags and parameters. */
 1535|    363|		tags = xmalloc(sizeof(int) * (num_tags + 1));
  ------------------
  |  |   67|    363|#define xmalloc(size) malloc(size)
  ------------------
 1536|    363|		if (!tags)
  ------------------
  |  Branch (1536:7): [True: 0, False: 363]
  ------------------
 1537|      0|		  return REG_ESPACE;
 1538|    363|		tags[0] = -1;
 1539|    363|		assertions = 0;
 1540|    363|		params = NULL;
 1541|    363|		if (params_seen)
  ------------------
  |  Branch (1541:7): [True: 0, False: 363]
  ------------------
 1542|      0|		  {
 1543|      0|		    params = tre_mem_alloc(mem, sizeof(*params)
  ------------------
  |  |   40|      0|#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
  ------------------
 1544|      0|					   * TRE_PARAM_LAST);
 1545|      0|		    if (!params)
  ------------------
  |  Branch (1545:11): [True: 0, False: 0]
  ------------------
 1546|      0|		      {
 1547|      0|			xfree(tags);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
 1548|      0|			return REG_ESPACE;
 1549|      0|		      }
 1550|      0|		  }
 1551|       |		/* Second pass with tre_mach_empty() to get the list of
 1552|       |		   tags and parameters. */
 1553|    363|		status = tre_match_empty(stack, cat->right, tags,
 1554|    363|					 &assertions, params, NULL, NULL);
 1555|    363|		if (status != REG_OK)
  ------------------
  |  Branch (1555:7): [True: 0, False: 363]
  ------------------
 1556|      0|		  {
 1557|      0|		    xfree(tags);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
 1558|      0|		    return status;
 1559|      0|		  }
 1560|    363|		node->lastpos =
 1561|    363|		  tre_set_union(mem, cat->left->lastpos, cat->right->lastpos,
 1562|    363|				tags, assertions, params);
 1563|    363|		xfree(tags);
  ------------------
  |  |   69|    363|#define xfree(ptr) free(ptr)
  ------------------
 1564|    363|		if (!node->lastpos)
  ------------------
  |  Branch (1564:7): [True: 0, False: 363]
  ------------------
 1565|      0|		  return REG_ESPACE;
 1566|    363|	      }
 1567|    980|	    else
 1568|    980|	      {
 1569|    980|		node->lastpos = cat->right->lastpos;
 1570|    980|	      }
 1571|  1.34k|	    break;
 1572|  1.34k|	  }
 1573|       |
 1574|  1.34k|	default:
  ------------------
  |  Branch (1574:2): [True: 0, False: 5.15k]
  ------------------
 1575|      0|	  assert(0);
  ------------------
  |  |   32|      0|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|      0|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1576|      0|	  break;
 1577|  5.15k|	}
 1578|  5.15k|    }
 1579|       |
 1580|    206|  return REG_OK;
 1581|    206|}
tre-compile.c:tre_set_one:
 1085|  2.19k|{
 1086|  2.19k|  tre_pos_and_tags_t *new_set;
 1087|       |
 1088|  2.19k|  new_set = tre_mem_calloc(mem, sizeof(*new_set) * 2);
  ------------------
  |  |   45|  2.19k|#define tre_mem_calloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 1, size)
  ------------------
 1089|  2.19k|  if (new_set == NULL)
  ------------------
  |  Branch (1089:7): [True: 0, False: 2.19k]
  ------------------
 1090|      0|    return NULL;
 1091|       |
 1092|  2.19k|  new_set[0].position = position;
 1093|  2.19k|  new_set[0].code_min = code_min;
 1094|  2.19k|  new_set[0].code_max = code_max;
 1095|  2.19k|  new_set[0].class = class;
 1096|  2.19k|  new_set[0].neg_classes = neg_classes;
 1097|  2.19k|  new_set[0].backref = backref;
 1098|  2.19k|  new_set[1].position = -1;
 1099|  2.19k|  new_set[1].code_min = -1;
 1100|  2.19k|  new_set[1].code_max = -1;
 1101|       |
 1102|  2.19k|  return new_set;
 1103|  2.19k|}
tre-compile.c:tre_set_empty:
 1068|  1.22k|{
 1069|  1.22k|  tre_pos_and_tags_t *new_set;
 1070|       |
 1071|  1.22k|  new_set = tre_mem_calloc(mem, sizeof(*new_set));
  ------------------
  |  |   45|  1.22k|#define tre_mem_calloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 1, size)
  ------------------
 1072|  1.22k|  if (new_set == NULL)
  ------------------
  |  Branch (1072:7): [True: 0, False: 1.22k]
  ------------------
 1073|      0|    return NULL;
 1074|       |
 1075|  1.22k|  new_set[0].position = -1;
 1076|  1.22k|  new_set[0].code_min = -1;
 1077|  1.22k|  new_set[0].code_max = -1;
 1078|       |
 1079|  1.22k|  return new_set;
 1080|  1.22k|}
tre-compile.c:tre_set_union:
 1108|  1.18k|{
 1109|  1.18k|  int s1, s2, i, j;
 1110|  1.18k|  tre_pos_and_tags_t *new_set;
 1111|  1.18k|  int *new_tags;
 1112|  1.18k|  int num_tags;
 1113|       |
 1114|  1.84k|  for (num_tags = 0; tags != NULL && tags[num_tags] >= 0; num_tags++);
  ------------------
  |  Branch (1114:22): [True: 1.53k, False: 318]
  |  Branch (1114:38): [True: 660, False: 871]
  ------------------
 1115|  2.32k|  for (s1 = 0; set1[s1].position >= 0; s1++);
  ------------------
  |  Branch (1115:16): [True: 1.13k, False: 1.18k]
  ------------------
 1116|  1.96k|  for (s2 = 0; set2[s2].position >= 0; s2++);
  ------------------
  |  Branch (1116:16): [True: 780, False: 1.18k]
  ------------------
 1117|  1.18k|  new_set = tre_mem_calloc(mem, sizeof(*new_set) * (s1 + s2 + 1));
  ------------------
  |  |   45|  1.18k|#define tre_mem_calloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 1, size)
  ------------------
 1118|  1.18k|  if (!new_set )
  ------------------
  |  Branch (1118:7): [True: 0, False: 1.18k]
  ------------------
 1119|      0|    return NULL;
 1120|       |
 1121|  2.32k|  for (s1 = 0; set1[s1].position >= 0; s1++)
  ------------------
  |  Branch (1121:16): [True: 1.13k, False: 1.18k]
  ------------------
 1122|  1.13k|    {
 1123|  1.13k|      new_set[s1].position = set1[s1].position;
 1124|  1.13k|      new_set[s1].code_min = set1[s1].code_min;
 1125|  1.13k|      new_set[s1].code_max = set1[s1].code_max;
 1126|  1.13k|      new_set[s1].assertions = set1[s1].assertions | assertions;
 1127|  1.13k|      new_set[s1].class = set1[s1].class;
 1128|  1.13k|      new_set[s1].neg_classes = set1[s1].neg_classes;
 1129|  1.13k|      new_set[s1].backref = set1[s1].backref;
 1130|  1.13k|      if (set1[s1].tags == NULL && tags == NULL)
  ------------------
  |  Branch (1130:11): [True: 916, False: 220]
  |  Branch (1130:36): [True: 226, False: 690]
  ------------------
 1131|    226|	new_set[s1].tags = NULL;
 1132|    910|      else
 1133|    910|	{
 1134|  1.15k|	  for (i = 0; set1[s1].tags != NULL && set1[s1].tags[i] >= 0; i++);
  ------------------
  |  Branch (1134:16): [True: 464, False: 690]
  |  Branch (1134:41): [True: 244, False: 220]
  ------------------
 1135|    910|	  new_tags = tre_mem_alloc(mem, (sizeof(*new_tags)
  ------------------
  |  |   40|    910|#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
  ------------------
 1136|    910|					 * (i + num_tags + 1)));
 1137|    910|	  if (new_tags == NULL)
  ------------------
  |  Branch (1137:8): [True: 0, False: 910]
  ------------------
 1138|      0|	    return NULL;
 1139|  1.15k|	  for (j = 0; j < i; j++)
  ------------------
  |  Branch (1139:16): [True: 244, False: 910]
  ------------------
 1140|    244|	    new_tags[j] = set1[s1].tags[j];
 1141|  1.67k|	  for (i = 0; i < num_tags; i++)
  ------------------
  |  Branch (1141:16): [True: 762, False: 910]
  ------------------
 1142|    762|	    new_tags[j + i] = tags[i];
 1143|    910|	  new_tags[j + i] = -1;
 1144|    910|	  new_set[s1].tags = new_tags;
 1145|    910|	}
 1146|  1.13k|      if (set1[s1].params)
  ------------------
  |  Branch (1146:11): [True: 0, False: 1.13k]
  ------------------
 1147|      0|	new_set[s1].params = set1[s1].params;
 1148|  1.13k|      if (params)
  ------------------
  |  Branch (1148:11): [True: 0, False: 1.13k]
  ------------------
 1149|      0|	{
 1150|      0|	  if (!new_set[s1].params)
  ------------------
  |  Branch (1150:8): [True: 0, False: 0]
  ------------------
 1151|      0|	    new_set[s1].params = params;
 1152|      0|	  else
 1153|      0|	    {
 1154|      0|	      new_set[s1].params = tre_mem_alloc(mem, sizeof(*params) *
  ------------------
  |  |   40|      0|#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
  ------------------
 1155|      0|						 TRE_PARAM_LAST);
 1156|      0|	      if (!new_set[s1].params)
  ------------------
  |  Branch (1156:12): [True: 0, False: 0]
  ------------------
 1157|      0|		return NULL;
 1158|      0|	      for (i = 0; i < TRE_PARAM_LAST; i++)
  ------------------
  |  Branch (1158:20): [True: 0, False: 0]
  ------------------
 1159|      0|		if (params[i] != TRE_PARAM_UNSET)
  ------------------
  |  |  254|      0|#define TRE_PARAM_UNSET -1
  ------------------
  |  Branch (1159:7): [True: 0, False: 0]
  ------------------
 1160|      0|		  new_set[s1].params[i] = params[i];
 1161|      0|	    }
 1162|      0|	}
 1163|  1.13k|    }
 1164|       |
 1165|  1.96k|  for (s2 = 0; set2[s2].position >= 0; s2++)
  ------------------
  |  Branch (1165:16): [True: 780, False: 1.18k]
  ------------------
 1166|    780|    {
 1167|    780|      new_set[s1 + s2].position = set2[s2].position;
 1168|    780|      new_set[s1 + s2].code_min = set2[s2].code_min;
 1169|    780|      new_set[s1 + s2].code_max = set2[s2].code_max;
 1170|       |      /* XXX - why not | assertions here as well? */
 1171|    780|      new_set[s1 + s2].assertions = set2[s2].assertions;
 1172|    780|      new_set[s1 + s2].class = set2[s2].class;
 1173|    780|      new_set[s1 + s2].neg_classes = set2[s2].neg_classes;
 1174|    780|      new_set[s1 + s2].backref = set2[s2].backref;
 1175|    780|      if (set2[s2].tags == NULL)
  ------------------
  |  Branch (1175:11): [True: 456, False: 324]
  ------------------
 1176|    456|	new_set[s1 + s2].tags = NULL;
 1177|    324|      else
 1178|    324|	{
 1179|    704|	  for (i = 0; set2[s2].tags[i] >= 0; i++);
  ------------------
  |  Branch (1179:16): [True: 380, False: 324]
  ------------------
 1180|    324|	  new_tags = tre_mem_alloc(mem, sizeof(*new_tags) * (i + 1));
  ------------------
  |  |   40|    324|#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
  ------------------
 1181|    324|	  if (new_tags == NULL)
  ------------------
  |  Branch (1181:8): [True: 0, False: 324]
  ------------------
 1182|      0|	    return NULL;
 1183|    704|	  for (j = 0; j < i; j++)
  ------------------
  |  Branch (1183:16): [True: 380, False: 324]
  ------------------
 1184|    380|	    new_tags[j] = set2[s2].tags[j];
 1185|    324|	  new_tags[j] = -1;
 1186|    324|	  new_set[s1 + s2].tags = new_tags;
 1187|    324|	}
 1188|    780|      if (set2[s2].params)
  ------------------
  |  Branch (1188:11): [True: 0, False: 780]
  ------------------
 1189|      0|	new_set[s1 + s2].params = set2[s2].params;
 1190|    780|      if (params)
  ------------------
  |  Branch (1190:11): [True: 0, False: 780]
  ------------------
 1191|      0|	{
 1192|      0|	  if (!new_set[s1 + s2].params)
  ------------------
  |  Branch (1192:8): [True: 0, False: 0]
  ------------------
 1193|      0|	    new_set[s1 + s2].params = params;
 1194|      0|	  else
 1195|      0|	    {
 1196|      0|	      new_set[s1 + s2].params = tre_mem_alloc(mem, sizeof(*params) *
  ------------------
  |  |   40|      0|#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
  ------------------
 1197|      0|						      TRE_PARAM_LAST);
 1198|      0|	      if (!new_set[s1 + s2].params)
  ------------------
  |  Branch (1198:12): [True: 0, False: 0]
  ------------------
 1199|      0|		return NULL;
 1200|      0|	      for (i = 0; i < TRE_PARAM_LAST; i++)
  ------------------
  |  Branch (1200:20): [True: 0, False: 0]
  ------------------
 1201|      0|		if (params[i] != TRE_PARAM_UNSET)
  ------------------
  |  |  254|      0|#define TRE_PARAM_UNSET -1
  ------------------
  |  Branch (1201:7): [True: 0, False: 0]
  ------------------
 1202|      0|		  new_set[s1 + s2].params[i] = params[i];
 1203|      0|	    }
 1204|      0|	}
 1205|    780|    }
 1206|  1.18k|  new_set[s1 + s2].position = -1;
 1207|  1.18k|  return new_set;
 1208|  1.18k|}
tre-compile.c:tre_match_empty:
 1218|  1.74k|{
 1219|  1.74k|  tre_literal_t *lit;
 1220|  1.74k|  tre_union_t *uni;
 1221|  1.74k|  tre_catenation_t *cat;
 1222|  1.74k|  tre_iteration_t *iter;
 1223|  1.74k|  int i;
 1224|  1.74k|  int bottom = tre_stack_num_objects(stack);
 1225|  1.74k|  reg_errcode_t status = REG_OK;
 1226|  1.74k|  if (num_tags_seen)
  ------------------
  |  Branch (1226:7): [True: 871, False: 871]
  ------------------
 1227|    871|    *num_tags_seen = 0;
 1228|  1.74k|  if (params_seen)
  ------------------
  |  Branch (1228:7): [True: 871, False: 871]
  ------------------
 1229|    871|    *params_seen = 0;
 1230|       |
 1231|  1.74k|  status = tre_stack_push_voidptr(stack, node);
 1232|       |
 1233|       |  /* Walk through the tree recursively. */
 1234|  4.77k|  while (status == REG_OK && tre_stack_num_objects(stack) > bottom)
  ------------------
  |  Branch (1234:10): [True: 4.77k, False: 0]
  |  Branch (1234:30): [True: 3.03k, False: 1.74k]
  ------------------
 1235|  3.03k|    {
 1236|  3.03k|      node = tre_stack_pop_voidptr(stack);
 1237|       |
 1238|  3.03k|      switch (node->type)
 1239|  3.03k|	{
 1240|  1.89k|	case LITERAL:
  ------------------
  |  Branch (1240:2): [True: 1.89k, False: 1.13k]
  ------------------
 1241|  1.89k|	  lit = (tre_literal_t *)node->obj;
 1242|  1.89k|	  switch (lit->code_min)
 1243|  1.89k|	    {
 1244|  1.32k|	    case TAG:
  ------------------
  |  |   28|  1.32k|#define TAG	  -3   /* Tag leaf. */
  ------------------
  |  Branch (1244:6): [True: 1.32k, False: 578]
  ------------------
 1245|  1.32k|	      if (lit->code_max >= 0)
  ------------------
  |  Branch (1245:12): [True: 1.32k, False: 0]
  ------------------
 1246|  1.32k|		{
 1247|  1.32k|		  if (tags != NULL)
  ------------------
  |  Branch (1247:9): [True: 660, False: 660]
  ------------------
 1248|    660|		    {
 1249|       |		      /* Add the tag to `tags'. */
 1250|    772|		      for (i = 0; tags[i] >= 0; i++)
  ------------------
  |  Branch (1250:21): [True: 112, False: 660]
  ------------------
 1251|    112|			if (tags[i] == lit->code_max)
  ------------------
  |  Branch (1251:8): [True: 0, False: 112]
  ------------------
 1252|      0|			  break;
 1253|    660|		      if (tags[i] < 0)
  ------------------
  |  Branch (1253:13): [True: 660, False: 0]
  ------------------
 1254|    660|			{
 1255|    660|			  tags[i] = (int)lit->code_max;
 1256|    660|			  tags[i + 1] = -1;
 1257|    660|			}
 1258|    660|		    }
 1259|  1.32k|		  if (num_tags_seen)
  ------------------
  |  Branch (1259:9): [True: 660, False: 660]
  ------------------
 1260|    660|		    (*num_tags_seen)++;
 1261|  1.32k|		}
 1262|  1.32k|	      break;
 1263|    520|	    case ASSERTION:
  ------------------
  |  |   27|    520|#define ASSERTION -2   /* Assertion leaf. */
  ------------------
  |  Branch (1263:6): [True: 520, False: 1.37k]
  ------------------
 1264|    520|	      assert(lit->code_max >= 1
  ------------------
  |  |   32|    520|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|    520|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:23): [True: 520, False: 0]
  |  |  |  |  |  Branch (230:23): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1265|    520|		     || lit->code_max <= ASSERT_LAST);
 1266|    520|	      if (assertions != NULL)
  ------------------
  |  Branch (1266:12): [True: 260, False: 260]
  ------------------
 1267|    260|		*assertions |= lit->code_max;
 1268|    520|	      break;
 1269|      0|	    case PARAMETER:
  ------------------
  |  |   30|      0|#define PARAMETER -5   /* Parameter. */
  ------------------
  |  Branch (1269:6): [True: 0, False: 1.89k]
  ------------------
 1270|      0|	      if (params != NULL)
  ------------------
  |  Branch (1270:12): [True: 0, False: 0]
  ------------------
 1271|      0|		for (i = 0; i < TRE_PARAM_LAST; i++)
  ------------------
  |  Branch (1271:15): [True: 0, False: 0]
  ------------------
 1272|      0|		  params[i] = lit->u.params[i];
 1273|      0|	      if (params_seen != NULL)
  ------------------
  |  Branch (1273:12): [True: 0, False: 0]
  ------------------
 1274|      0|		*params_seen = 1;
 1275|      0|	      break;
 1276|     58|	    case EMPTY:
  ------------------
  |  |   26|     58|#define EMPTY	  -1   /* Empty leaf (denotes empty string). */
  ------------------
  |  Branch (1276:6): [True: 58, False: 1.84k]
  ------------------
 1277|     58|	      break;
 1278|      0|	    default:
  ------------------
  |  Branch (1278:6): [True: 0, False: 1.89k]
  ------------------
 1279|      0|	      assert(0);
  ------------------
  |  |   32|      0|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|      0|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1280|      0|	      break;
 1281|  1.89k|	    }
 1282|  1.89k|	  break;
 1283|       |
 1284|  1.89k|	case UNION:
  ------------------
  |  Branch (1284:2): [True: 168, False: 2.86k]
  ------------------
 1285|       |	  /* Subexpressions starting earlier take priority over ones
 1286|       |	     starting later, so we prefer the left subexpression over the
 1287|       |	     right subexpression. */
 1288|    168|	  uni = (tre_union_t *)node->obj;
 1289|    168|	  if (uni->left->nullable)
  ------------------
  |  Branch (1289:8): [True: 168, False: 0]
  ------------------
 1290|    168|	    STACK_PUSHX(stack, voidptr, uni->left)
  ------------------
  |  |   60|    168|  {									      \
  |  |   61|    168|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    168|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 168]
  |  |  ------------------
  |  |   63|    168|      break;								      \
  |  |   64|    168|  }
  ------------------
 1291|      0|	  else if (uni->right->nullable)
  ------------------
  |  Branch (1291:13): [True: 0, False: 0]
  ------------------
 1292|      0|	    STACK_PUSHX(stack, voidptr, uni->right)
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1293|      0|	  else
 1294|      0|	    assert(0);
  ------------------
  |  |   32|      0|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|      0|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1295|    168|	  break;
 1296|       |
 1297|    560|	case CATENATION:
  ------------------
  |  Branch (1297:2): [True: 560, False: 2.47k]
  ------------------
 1298|       |	  /* The path must go through both children. */
 1299|    560|	  cat = (tre_catenation_t *)node->obj;
 1300|    560|	  assert(cat->left->nullable);
  ------------------
  |  |   32|    560|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|    560|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [True: 560, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1301|    560|	  assert(cat->right->nullable);
  ------------------
  |  |   32|    560|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|    560|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [True: 560, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1302|    560|	  STACK_PUSHX(stack, voidptr, cat->left);
  ------------------
  |  |   60|    560|  {									      \
  |  |   61|    560|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    560|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 560]
  |  |  ------------------
  |  |   63|    560|      break;								      \
  |  |   64|    560|  }
  ------------------
 1303|    560|	  STACK_PUSHX(stack, voidptr, cat->right);
  ------------------
  |  |   60|    560|  {									      \
  |  |   61|    560|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    560|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 560]
  |  |  ------------------
  |  |   63|    560|      break;								      \
  |  |   64|    560|  }
  ------------------
 1304|    560|	  break;
 1305|       |
 1306|    404|	case ITERATION:
  ------------------
  |  Branch (1306:2): [True: 404, False: 2.62k]
  ------------------
 1307|       |	  /* A match with an empty string is preferred over no match at
 1308|       |	     all, so we go through the argument if possible. */
 1309|    404|	  iter = (tre_iteration_t *)node->obj;
 1310|    404|	  if (iter->arg->nullable)
  ------------------
  |  Branch (1310:8): [True: 0, False: 404]
  ------------------
 1311|    404|	    STACK_PUSHX(stack, voidptr, iter->arg);
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1312|    404|	  break;
 1313|       |
 1314|      0|	default:
  ------------------
  |  Branch (1314:2): [True: 0, False: 3.03k]
  ------------------
 1315|      0|	  assert(0);
  ------------------
  |  |   32|      0|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|      0|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1316|      0|	  break;
 1317|  3.03k|	}
 1318|  3.03k|    }
 1319|       |
 1320|  1.74k|  return status;
 1321|  1.74k|}
tre-compile.c:tre_ast_to_tnfa:
 1870|    412|{
 1871|    412|  reg_errcode_t errcode;
 1872|    412|  tre_stack_t *stack;
 1873|       |  /* I made up max_size, there is no reason for that particular value */
 1874|    412|  stack = tre_stack_new(1024, 256*1024, 4096);
 1875|    412|  errcode = tre_ast_to_tnfa_iter(stack, node, transitions, counts, offs);
 1876|    412|  tre_stack_destroy(stack);
 1877|    412|  return errcode;
 1878|    412|}
tre-compile.c:tre_ast_to_tnfa_iter:
 1809|    412|{
 1810|    412|  tre_union_t *uni;
 1811|    412|  tre_catenation_t *cat;
 1812|    412|  tre_iteration_t *iter;
 1813|    412|  reg_errcode_t errcode = REG_OK;
 1814|       |
 1815|    412|  STACK_PUSHR(stack, voidptr, node);
  ------------------
  |  |   67|    412|  {									      \
  |  |   68|    412|    reg_errcode_t _status;						      \
  |  |   69|    412|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    412|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 412]
  |  |  ------------------
  |  |   71|    412|      return _status;							      \
  |  |   72|    412|  }
  ------------------
 1816|       |
 1817|  7.27k|  while (tre_stack_num_objects(stack)) {
  ------------------
  |  Branch (1817:10): [True: 6.85k, False: 412]
  ------------------
 1818|  6.85k|    node = (tre_ast_node_t*) tre_stack_pop_voidptr(stack);
 1819|       |
 1820|  6.85k|    switch (node->type)
  ------------------
  |  Branch (1820:13): [True: 6.85k, False: 0]
  ------------------
 1821|  6.85k|      {
 1822|  3.41k|      case LITERAL:
  ------------------
  |  Branch (1822:7): [True: 3.41k, False: 3.44k]
  ------------------
 1823|  3.41k|	break;
 1824|       |
 1825|    318|      case UNION:
  ------------------
  |  Branch (1825:7): [True: 318, False: 6.54k]
  ------------------
 1826|    318|	uni = (tre_union_t *)node->obj;
 1827|    318|	STACK_PUSHR(stack, voidptr, uni->right);
  ------------------
  |  |   67|    318|  {									      \
  |  |   68|    318|    reg_errcode_t _status;						      \
  |  |   69|    318|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    318|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 318]
  |  |  ------------------
  |  |   71|    318|      return _status;							      \
  |  |   72|    318|  }
  ------------------
 1828|    318|	STACK_PUSHR(stack, voidptr, uni->left);
  ------------------
  |  |   67|    318|  {									      \
  |  |   68|    318|    reg_errcode_t _status;						      \
  |  |   69|    318|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    318|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 318]
  |  |  ------------------
  |  |   71|    318|      return _status;							      \
  |  |   72|    318|  }
  ------------------
 1829|    318|	break;
 1830|       |
 1831|  2.68k|      case CATENATION:
  ------------------
  |  Branch (1831:7): [True: 2.68k, False: 4.17k]
  ------------------
 1832|  2.68k|	cat = (tre_catenation_t *)node->obj;
 1833|       |	/* Add a transition from each position in cat->left->lastpos
 1834|       |	   to each position in cat->right->firstpos. */
 1835|  2.68k|	errcode = tre_make_trans(cat->left->lastpos, cat->right->firstpos,
 1836|  2.68k|				 transitions, counts, offs);
 1837|  2.68k|	if (errcode != REG_OK)
  ------------------
  |  Branch (1837:6): [True: 0, False: 2.68k]
  ------------------
 1838|      0|	  return errcode;
 1839|       |	
 1840|  2.68k|	STACK_PUSHR(stack, voidptr, cat->right);
  ------------------
  |  |   67|  2.68k|  {									      \
  |  |   68|  2.68k|    reg_errcode_t _status;						      \
  |  |   69|  2.68k|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|  2.68k|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 2.68k]
  |  |  ------------------
  |  |   71|  2.68k|      return _status;							      \
  |  |   72|  2.68k|  }
  ------------------
 1841|  2.68k|	STACK_PUSHR(stack, voidptr, cat->left);
  ------------------
  |  |   67|  2.68k|  {									      \
  |  |   68|  2.68k|    reg_errcode_t _status;						      \
  |  |   69|  2.68k|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|  2.68k|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 2.68k]
  |  |  ------------------
  |  |   71|  2.68k|      return _status;							      \
  |  |   72|  2.68k|  }
  ------------------
 1842|  2.68k|	break;
 1843|       |
 1844|    438|      case ITERATION:
  ------------------
  |  Branch (1844:7): [True: 438, False: 6.42k]
  ------------------
 1845|    438|	iter = (tre_iteration_t *)node->obj;
 1846|       |	// assert(iter->max == -1 || iter->max == 1);
 1847|    438|	if(!(iter->max == -1 || iter->max == 1)) return REG_BADBR;
  ------------------
  |  Branch (1847:7): [True: 438, False: 0]
  |  Branch (1847:26): [True: 0, False: 0]
  ------------------
 1848|       |
 1849|    438|	if (iter->max == -1)
  ------------------
  |  Branch (1849:6): [True: 438, False: 0]
  ------------------
 1850|    438|	  {
 1851|       |	    // assert(iter->min == 0 || iter->min == 1);
 1852|    438|	    if(!(iter->min == 0 || iter->min == 1)) return REG_BADBR;
  ------------------
  |  Branch (1852:11): [True: 180, False: 258]
  |  Branch (1852:29): [True: 258, False: 0]
  ------------------
 1853|       |	    /* Add a transition from each last position in the iterated
 1854|       |	       expression to each first position. */
 1855|    438|	    errcode = tre_make_trans(iter->arg->lastpos, iter->arg->firstpos,
 1856|    438|				     transitions, counts, offs);
 1857|    438|	    if (errcode != REG_OK)
  ------------------
  |  Branch (1857:10): [True: 0, False: 438]
  ------------------
 1858|      0|	      return errcode;	  
 1859|    438|	  }
 1860|    438|	STACK_PUSHR(stack, voidptr, iter->arg);
  ------------------
  |  |   67|    438|  {									      \
  |  |   68|    438|    reg_errcode_t _status;						      \
  |  |   69|    438|    _status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   70|    438|    if (_status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 438]
  |  |  ------------------
  |  |   71|    438|      return _status;							      \
  |  |   72|    438|  }
  ------------------
 1861|    438|	break;
 1862|  6.85k|      }
 1863|  6.85k|  }
 1864|    412|  return REG_OK;
 1865|    412|}
tre-compile.c:tre_make_trans:
 1589|  3.12k|{
 1590|  3.12k|  tre_pos_and_tags_t *orig_p2 = p2;
 1591|  3.12k|  tre_tnfa_transition_t *trans;
 1592|  3.12k|  int i, j, k, l, dup, prev_p2_pos;
 1593|       |
 1594|  3.12k|  if (transitions != NULL)
  ------------------
  |  Branch (1594:7): [True: 1.56k, False: 1.56k]
  ------------------
 1595|  3.01k|    while (p1->position >= 0)
  ------------------
  |  Branch (1595:12): [True: 1.45k, False: 1.56k]
  ------------------
 1596|  1.45k|      {
 1597|  1.45k|	p2 = orig_p2;
 1598|  1.45k|	prev_p2_pos = -1;
 1599|  2.85k|	while (p2->position >= 0)
  ------------------
  |  Branch (1599:9): [True: 1.39k, False: 1.45k]
  ------------------
 1600|  1.39k|	  {
 1601|       |	    /* Optimization: if this position was already handled, skip it. */
 1602|  1.39k|	    if (p2->position == prev_p2_pos)
  ------------------
  |  Branch (1602:10): [True: 136, False: 1.25k]
  ------------------
 1603|    136|	      {
 1604|    136|		p2++;
 1605|    136|		continue;
 1606|    136|	      }
 1607|  1.25k|	    prev_p2_pos = p2->position;
 1608|       |	    /* Set `trans' to point to the next unused transition from
 1609|       |	       position `p1->position'. */
 1610|  1.25k|	    trans = transitions + offs[p1->position];
 1611|  2.03k|	    while (trans->state != NULL)
  ------------------
  |  Branch (1611:13): [True: 777, False: 1.25k]
  ------------------
 1612|    777|	      {
 1613|       |#if 0
 1614|       |		/* If we find a previous transition from `p1->position' to
 1615|       |		   `p2->position', it is overwritten.  This can happen only
 1616|       |		   if there are nested loops in the regexp, like in "((a)*)*".
 1617|       |		   In POSIX.2 repetition using the outer loop is always
 1618|       |		   preferred over using the inner loop.	 Therefore the
 1619|       |		   transition for the inner loop is useless and can be thrown
 1620|       |		   away. */
 1621|       |		/* XXX - The same position is used for all nodes in a bracket
 1622|       |		   expression, so this optimization cannot be used (it will
 1623|       |		   break bracket expressions) unless I figure out a way to
 1624|       |		   detect it here. */
 1625|       |		if (trans->state_id == p2->position)
 1626|       |		  {
 1627|       |		    DPRINT(("*"));
 1628|       |		    break;
 1629|       |		  }
 1630|       |#endif
 1631|    777|		trans++;
 1632|    777|	      }
 1633|       |
 1634|  1.25k|	    if (trans->state == NULL)
  ------------------
  |  Branch (1634:10): [True: 1.25k, False: 0]
  ------------------
 1635|  1.25k|	      (trans + 1)->state = NULL;
 1636|       |	    /* Use the character ranges, assertions, etc. from `p1' for
 1637|       |	       the transition from `p1' to `p2'. */
 1638|  1.25k|	    trans->code_min = (tre_cint_t) p1->code_min;
 1639|  1.25k|	    trans->code_max = (tre_cint_t) p1->code_max;
 1640|  1.25k|	    trans->state = transitions + offs[p2->position];
 1641|  1.25k|	    trans->state_id = p2->position;
 1642|  1.25k|	    trans->assertions = p1->assertions | p2->assertions
 1643|  1.25k|	      | (p1->class ? ASSERT_CHAR_CLASS : 0)
  ------------------
  |  |  212|      0|#define ASSERT_CHAR_CLASS	  4   /* Character class in `class'. */
  ------------------
  |  Branch (1643:11): [True: 0, False: 1.25k]
  ------------------
 1644|  1.25k|	      | (p1->neg_classes != NULL ? ASSERT_CHAR_CLASS_NEG : 0);
  ------------------
  |  |  213|      0|#define ASSERT_CHAR_CLASS_NEG	  8   /* Character classes in `neg_classes'. */
  ------------------
  |  Branch (1644:11): [True: 0, False: 1.25k]
  ------------------
 1645|  1.25k|	    if (p1->backref >= 0)
  ------------------
  |  Branch (1645:10): [True: 0, False: 1.25k]
  ------------------
 1646|      0|	      {
 1647|      0|		assert((trans->assertions & ASSERT_CHAR_CLASS) == 0);
  ------------------
  |  |   32|      0|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|      0|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1648|      0|		assert(p2->backref < 0);
  ------------------
  |  |   32|      0|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|      0|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1649|      0|		trans->u.backref = p1->backref;
 1650|      0|		trans->assertions |= ASSERT_BACKREF;
  ------------------
  |  |  218|      0|#define ASSERT_BACKREF		256   /* A back reference in `backref'. */
  ------------------
 1651|      0|	      }
 1652|  1.25k|	    else
 1653|  1.25k|	      trans->u.class = p1->class;
 1654|  1.25k|	    if (p1->neg_classes != NULL)
  ------------------
  |  Branch (1654:10): [True: 0, False: 1.25k]
  ------------------
 1655|      0|	      {
 1656|      0|		for (i = 0; p1->neg_classes[i] != (tre_ctype_t)0; i++);
  ------------------
  |  Branch (1656:15): [True: 0, False: 0]
  ------------------
 1657|      0|		trans->neg_classes =
 1658|      0|		  xmalloc(sizeof(*trans->neg_classes) * (i + 1));
  ------------------
  |  |   67|      0|#define xmalloc(size) malloc(size)
  ------------------
 1659|      0|		if (trans->neg_classes == NULL)
  ------------------
  |  Branch (1659:7): [True: 0, False: 0]
  ------------------
 1660|      0|		  return REG_ESPACE;
 1661|      0|		for (i = 0; p1->neg_classes[i] != (tre_ctype_t)0; i++)
  ------------------
  |  Branch (1661:15): [True: 0, False: 0]
  ------------------
 1662|      0|		  trans->neg_classes[i] = p1->neg_classes[i];
 1663|      0|		trans->neg_classes[i] = (tre_ctype_t)0;
 1664|      0|	      }
 1665|  1.25k|	    else
 1666|  1.25k|	      trans->neg_classes = NULL;
 1667|       |
 1668|       |	    /* Find out how many tags this transition has. */
 1669|  1.25k|	    i = 0;
 1670|  1.25k|	    if (p1->tags != NULL)
  ------------------
  |  Branch (1670:10): [True: 283, False: 975]
  ------------------
 1671|    557|	      while(p1->tags[i] >= 0)
  ------------------
  |  Branch (1671:14): [True: 274, False: 283]
  ------------------
 1672|    274|		i++;
 1673|  1.25k|	    j = 0;
 1674|  1.25k|	    if (p2->tags != NULL)
  ------------------
  |  Branch (1674:10): [True: 274, False: 984]
  ------------------
 1675|    604|	      while(p2->tags[j] >= 0)
  ------------------
  |  Branch (1675:14): [True: 330, False: 274]
  ------------------
 1676|    330|		j++;
 1677|       |
 1678|       |	    /* If we are overwriting a transition, free the old tag array. */
 1679|  1.25k|	    if (trans->tags != NULL)
  ------------------
  |  Branch (1679:10): [True: 0, False: 1.25k]
  ------------------
 1680|      0|	      xfree(trans->tags);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
 1681|  1.25k|	    trans->tags = NULL;
 1682|       |
 1683|       |	    /* If there were any tags, allocate an array and fill it. */
 1684|  1.25k|	    if (i + j > 0)
  ------------------
  |  Branch (1684:10): [True: 354, False: 904]
  ------------------
 1685|    354|	      {
 1686|    354|		trans->tags = xmalloc(sizeof(*trans->tags) * (i + j + 1));
  ------------------
  |  |   67|    354|#define xmalloc(size) malloc(size)
  ------------------
 1687|    354|		if (!trans->tags)
  ------------------
  |  Branch (1687:7): [True: 0, False: 354]
  ------------------
 1688|      0|		  return REG_ESPACE;
 1689|    354|		i = 0;
 1690|    354|		if (p1->tags != NULL)
  ------------------
  |  Branch (1690:7): [True: 218, False: 136]
  ------------------
 1691|    492|		  while(p1->tags[i] >= 0)
  ------------------
  |  Branch (1691:11): [True: 274, False: 218]
  ------------------
 1692|    274|		    {
 1693|    274|		      trans->tags[i] = p1->tags[i];
 1694|    274|		      i++;
 1695|    274|		    }
 1696|    354|		l = i;
 1697|    354|		j = 0;
 1698|    354|		if (p2->tags != NULL)
  ------------------
  |  Branch (1698:7): [True: 274, False: 80]
  ------------------
 1699|    604|		  while (p2->tags[j] >= 0)
  ------------------
  |  Branch (1699:12): [True: 330, False: 274]
  ------------------
 1700|    330|		    {
 1701|       |		      /* Don't add duplicates. */
 1702|    330|		      dup = 0;
 1703|    580|		      for (k = 0; k < i; k++)
  ------------------
  |  Branch (1703:21): [True: 250, False: 330]
  ------------------
 1704|    250|			if (trans->tags[k] == p2->tags[j])
  ------------------
  |  Branch (1704:8): [True: 0, False: 250]
  ------------------
 1705|      0|			  {
 1706|      0|			    dup = 1;
 1707|      0|			    break;
 1708|      0|			  }
 1709|    330|		      if (!dup)
  ------------------
  |  Branch (1709:13): [True: 330, False: 0]
  ------------------
 1710|    330|			trans->tags[l++] = p2->tags[j];
 1711|    330|		      j++;
 1712|    330|		    }
 1713|    354|		trans->tags[l] = -1;
 1714|    354|	      }
 1715|       |
 1716|       |	    /* Set the parameter array.	 If both `p2' and `p1' have same
 1717|       |	       parameters, the values in `p2' override those in `p1'. */
 1718|  1.25k|	    if (p1->params || p2->params)
  ------------------
  |  Branch (1718:10): [True: 0, False: 1.25k]
  |  Branch (1718:24): [True: 0, False: 1.25k]
  ------------------
 1719|      0|	      {
 1720|      0|		if (!trans->params)
  ------------------
  |  Branch (1720:7): [True: 0, False: 0]
  ------------------
 1721|      0|		  trans->params = xmalloc(sizeof(*trans->params)
  ------------------
  |  |   67|      0|#define xmalloc(size) malloc(size)
  ------------------
 1722|      0|					  * TRE_PARAM_LAST);
 1723|      0|		if (!trans->params)
  ------------------
  |  Branch (1723:7): [True: 0, False: 0]
  ------------------
 1724|      0|		  return REG_ESPACE;
 1725|      0|		for (i = 0; i < TRE_PARAM_LAST; i++)
  ------------------
  |  Branch (1725:15): [True: 0, False: 0]
  ------------------
 1726|      0|		  {
 1727|      0|		    trans->params[i] = TRE_PARAM_UNSET;
  ------------------
  |  |  254|      0|#define TRE_PARAM_UNSET -1
  ------------------
 1728|      0|		    if (p1->params && p1->params[i] != TRE_PARAM_UNSET)
  ------------------
  |  |  254|      0|#define TRE_PARAM_UNSET -1
  ------------------
  |  Branch (1728:11): [True: 0, False: 0]
  |  Branch (1728:25): [True: 0, False: 0]
  ------------------
 1729|      0|		      trans->params[i] = p1->params[i];
 1730|      0|		    if (p2->params && p2->params[i] != TRE_PARAM_UNSET)
  ------------------
  |  |  254|      0|#define TRE_PARAM_UNSET -1
  ------------------
  |  Branch (1730:11): [True: 0, False: 0]
  |  Branch (1730:25): [True: 0, False: 0]
  ------------------
 1731|      0|		      trans->params[i] = p2->params[i];
 1732|      0|		  }
 1733|      0|	      }
 1734|  1.25k|	    else
 1735|  1.25k|	      {
 1736|  1.25k|		if (trans->params)
  ------------------
  |  Branch (1736:7): [True: 0, False: 1.25k]
  ------------------
 1737|      0|		  xfree(trans->params);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
 1738|  1.25k|		trans->params = NULL;
 1739|  1.25k|	      }
 1740|       |
 1741|       |
 1742|       |#ifdef TRE_DEBUG
 1743|       |	    {
 1744|       |	      int *tags;
 1745|       |
 1746|       |	      DPRINT(("	 %2d -> %2d on %3d", p1->position, p2->position,
 1747|       |		      p1->code_min));
 1748|       |	      if (p1->code_max != p1->code_min)
 1749|       |		DPRINT(("-%3d", p1->code_max));
 1750|       |	      tags = trans->tags;
 1751|       |	      if (tags)
 1752|       |		{
 1753|       |		  DPRINT((", tags ["));
 1754|       |		  while (*tags >= 0)
 1755|       |		    {
 1756|       |		      DPRINT(("%d", *tags));
 1757|       |		      tags++;
 1758|       |		      if (*tags >= 0)
 1759|       |			DPRINT((","));
 1760|       |		    }
 1761|       |		  DPRINT(("]"));
 1762|       |		}
 1763|       |	      if (trans->assertions)
 1764|       |		DPRINT((", assert %d", trans->assertions));
 1765|       |	      if (trans->assertions & ASSERT_BACKREF)
 1766|       |		DPRINT((", backref %d", trans->u.backref));
 1767|       |	      else if (trans->u.class)
 1768|       |		DPRINT((", class %ld", (long)trans->u.class));
 1769|       |	      if (trans->neg_classes)
 1770|       |		DPRINT((", neg_classes %p", trans->neg_classes));
 1771|       |	      if (trans->params)
 1772|       |		{
 1773|       |		  DPRINT((", "));
 1774|       |		  tre_print_params(trans->params);
 1775|       |		}
 1776|       |	      DPRINT(("\n"));
 1777|       |	    }
 1778|       |#endif /* TRE_DEBUG */
 1779|  1.25k|	    p2++;
 1780|  1.25k|	  }
 1781|  1.45k|	p1++;
 1782|  1.45k|      }
 1783|  1.56k|  else
 1784|       |    /* Compute a maximum limit for the number of transitions leaving
 1785|       |       from each state. */
 1786|  3.01k|    while (p1->position >= 0)
  ------------------
  |  Branch (1786:12): [True: 1.45k, False: 1.56k]
  ------------------
 1787|  1.45k|      {
 1788|  1.45k|	p2 = orig_p2;
 1789|  2.85k|	while (p2->position >= 0)
  ------------------
  |  Branch (1789:9): [True: 1.39k, False: 1.45k]
  ------------------
 1790|  1.39k|	  {
 1791|  1.39k|	    counts[p1->position]++;
 1792|  1.39k|	    p2++;
 1793|  1.39k|	  }
 1794|  1.45k|	p1++;
 1795|  1.45k|      }
 1796|  3.12k|  return REG_OK;
 1797|  3.12k|}

tre_tnfa_run_parallel:
  111|  4.86k|{
  112|       |  /* State variables required by GET_NEXT_WCHAR. */
  113|  4.86k|  tre_char_t prev_c = 0, next_c = 0;
  114|  4.86k|  const char *str_byte = string;
  115|  4.86k|  int pos = -1;
  116|  4.86k|  unsigned int pos_add_next = 1;
  117|  4.86k|#ifdef TRE_WCHAR
  118|  4.86k|  const wchar_t *str_wide = string;
  119|  4.86k|#ifdef TRE_MBSTATE
  120|  4.86k|  mbstate_t mbstate;
  121|  4.86k|#endif /* TRE_MBSTATE */
  122|  4.86k|#endif /* TRE_WCHAR */
  123|  4.86k|  int reg_notbol = eflags & REG_NOTBOL;
  ------------------
  |  |  112|  4.86k|#define REG_NOTBOL 1
  ------------------
  124|  4.86k|  int reg_noteol = eflags & REG_NOTEOL;
  ------------------
  |  |  113|  4.86k|#define REG_NOTEOL (REG_NOTBOL << 1)
  |  |  ------------------
  |  |  |  |  112|  4.86k|#define REG_NOTBOL 1
  |  |  ------------------
  ------------------
  125|  4.86k|  int reg_newline = tnfa->cflags & REG_NEWLINE;
  ------------------
  |  |  100|  4.86k|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  ------------------
  |  |  |  |   99|  4.86k|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   98|  4.86k|#define REG_EXTENDED	1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  126|  4.86k|  int str_user_end = 0;
  127|       |
  128|  4.86k|  char *buf;
  129|  4.86k|  tre_tnfa_transition_t *trans_i;
  130|  4.86k|  tre_tnfa_reach_t *reach, *reach_next, *reach_i, *reach_next_i;
  131|  4.86k|  tre_reach_pos_t *reach_pos;
  132|  4.86k|  int *tag_i;
  133|  4.86k|  int num_tags, i;
  134|       |
  135|  4.86k|  int match_eo = -1;	   /* end offset of match (-1 if no match found yet) */
  136|  4.86k|  int new_match = 0;
  137|  4.86k|  int *tmp_tags = NULL;
  138|  4.86k|  int *tmp_iptr;
  139|       |
  140|  4.86k|#ifdef TRE_MBSTATE
  141|  4.86k|  memset(&mbstate, '\0', sizeof(mbstate));
  142|  4.86k|#endif /* TRE_MBSTATE */
  143|       |
  144|  4.86k|  DPRINT(("tre_tnfa_run_parallel, input type %d\n", type));
  ------------------
  |  |   27|  4.86k|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 4.86k]
  |  |  ------------------
  ------------------
  145|       |
  146|  4.86k|  if (!match_tags)
  ------------------
  |  Branch (146:7): [True: 4.58k, False: 278]
  ------------------
  147|  4.58k|    num_tags = 0;
  148|    278|  else
  149|    278|    num_tags = tnfa->num_tags;
  150|       |
  151|       |  /* Allocate memory for temporary data required for matching.	This needs to
  152|       |     be done for every matching operation to be thread safe.  This allocates
  153|       |     everything in a single large block from the stack frame using alloca()
  154|       |     or with malloc() if alloca is unavailable. */
  155|  4.86k|  {
  156|  4.86k|    int tbytes, rbytes, pbytes, xbytes, total_bytes;
  157|  4.86k|    char *tmp_buf;
  158|       |    /* Compute the length of the block we need. */
  159|  4.86k|    tbytes = sizeof(*tmp_tags) * num_tags;
  160|  4.86k|    rbytes = sizeof(*reach_next) * (tnfa->num_states + 1);
  161|  4.86k|    pbytes = sizeof(*reach_pos) * tnfa->num_states;
  162|  4.86k|    xbytes = sizeof(int) * num_tags;
  163|  4.86k|    total_bytes =
  164|  4.86k|      (sizeof(long) - 1) * 4 /* for alignment paddings */
  165|  4.86k|      + (rbytes + xbytes * tnfa->num_states) * 2 + tbytes + pbytes;
  166|       |
  167|       |    /* Allocate the memory. */
  168|       |#ifdef TRE_USE_ALLOCA
  169|       |    buf = alloca(total_bytes);
  170|       |#else /* !TRE_USE_ALLOCA */
  171|  4.86k|    buf = xmalloc((unsigned)total_bytes);
  ------------------
  |  |   67|  4.86k|#define xmalloc(size) malloc(size)
  ------------------
  172|  4.86k|#endif /* !TRE_USE_ALLOCA */
  173|  4.86k|    if (buf == NULL)
  ------------------
  |  Branch (173:9): [True: 0, False: 4.86k]
  ------------------
  174|      0|      return REG_ESPACE;
  175|  4.86k|    memset(buf, 0, (size_t)total_bytes);
  176|       |
  177|       |    /* Get the various pointers within tmp_buf (properly aligned). */
  178|  4.86k|    tmp_tags = (void *)buf;
  179|  4.86k|    tmp_buf = buf + tbytes;
  180|  4.86k|    tmp_buf += ALIGN(tmp_buf, anytype);
  ------------------
  |  |  154|  4.86k|  ((((size_t)ptr) % sizeof(type)) \
  |  |  ------------------
  |  |  |  Branch (154:4): [True: 238, False: 4.62k]
  |  |  ------------------
  |  |  155|  4.86k|   ? (sizeof(type) - (((size_t)ptr) % sizeof(type))) \
  |  |  156|  4.86k|   : 0)
  ------------------
  181|  4.86k|    reach_next = (void *)tmp_buf;
  182|  4.86k|    tmp_buf += rbytes;
  183|  4.86k|    tmp_buf += ALIGN(tmp_buf, anytype);
  ------------------
  |  |  154|  4.86k|  ((((size_t)ptr) % sizeof(type)) \
  |  |  ------------------
  |  |  |  Branch (154:4): [True: 0, False: 4.86k]
  |  |  ------------------
  |  |  155|  4.86k|   ? (sizeof(type) - (((size_t)ptr) % sizeof(type))) \
  |  |  156|  4.86k|   : 0)
  ------------------
  184|  4.86k|    reach = (void *)tmp_buf;
  185|  4.86k|    tmp_buf += rbytes;
  186|  4.86k|    tmp_buf += ALIGN(tmp_buf, anytype);
  ------------------
  |  |  154|  4.86k|  ((((size_t)ptr) % sizeof(type)) \
  |  |  ------------------
  |  |  |  Branch (154:4): [True: 0, False: 4.86k]
  |  |  ------------------
  |  |  155|  4.86k|   ? (sizeof(type) - (((size_t)ptr) % sizeof(type))) \
  |  |  156|  4.86k|   : 0)
  ------------------
  187|  4.86k|    reach_pos = (void *)tmp_buf;
  188|  4.86k|    tmp_buf += pbytes;
  189|  4.86k|    tmp_buf += ALIGN(tmp_buf, anytype);
  ------------------
  |  |  154|  4.86k|  ((((size_t)ptr) % sizeof(type)) \
  |  |  ------------------
  |  |  |  Branch (154:4): [True: 0, False: 4.86k]
  |  |  ------------------
  |  |  155|  4.86k|   ? (sizeof(type) - (((size_t)ptr) % sizeof(type))) \
  |  |  156|  4.86k|   : 0)
  ------------------
  190|  37.6k|    for (i = 0; i < tnfa->num_states; i++)
  ------------------
  |  Branch (190:17): [True: 32.8k, False: 4.86k]
  ------------------
  191|  32.8k|      {
  192|  32.8k|	reach[i].tags = (void *)tmp_buf;
  193|  32.8k|	tmp_buf += xbytes;
  194|  32.8k|	reach_next[i].tags = (void *)tmp_buf;
  195|  32.8k|	tmp_buf += xbytes;
  196|  32.8k|      }
  197|  4.86k|  }
  198|       |
  199|  37.6k|  for (i = 0; i < tnfa->num_states; i++)
  ------------------
  |  Branch (199:15): [True: 32.8k, False: 4.86k]
  ------------------
  200|  32.8k|    reach_pos[i].pos = -1;
  201|       |
  202|       |  /* If only one character can start a match, find it first. */
  203|  4.86k|  if (tnfa->first_char >= 0 && type == STR_BYTE && str_byte)
  ------------------
  |  Branch (203:7): [True: 4.57k, False: 285]
  |  Branch (203:32): [True: 4.57k, False: 0]
  |  Branch (203:52): [True: 4.57k, False: 0]
  ------------------
  204|  4.57k|    {
  205|  4.57k|      const char *orig_str = str_byte;
  206|  4.57k|      int first = tnfa->first_char;
  207|       |
  208|  4.57k|      if (len >= 0)
  ------------------
  |  Branch (208:11): [True: 0, False: 4.57k]
  ------------------
  209|      0|	str_byte = memchr(orig_str, first, (size_t)len);
  210|  4.57k|      else
  211|  4.57k|	str_byte = strchr(orig_str, first);
  212|  4.57k|      if (str_byte == NULL)
  ------------------
  |  Branch (212:11): [True: 1.66k, False: 2.90k]
  ------------------
  213|  1.66k|	{
  214|  1.66k|#ifndef TRE_USE_ALLOCA
  215|  1.66k|	  if (buf)
  ------------------
  |  Branch (215:8): [True: 1.66k, False: 0]
  ------------------
  216|  1.66k|	    xfree(buf);
  ------------------
  |  |   69|  1.66k|#define xfree(ptr) free(ptr)
  ------------------
  217|  1.66k|#endif /* !TRE_USE_ALLOCA */
  218|  1.66k|	  return REG_NOMATCH;
  219|  1.66k|	}
  220|  2.90k|      DPRINT(("skipped %lu chars\n", (unsigned long)(str_byte - orig_str)));
  ------------------
  |  |   27|  2.90k|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 2.90k]
  |  |  ------------------
  ------------------
  221|  2.90k|      if (str_byte >= orig_str + 1)
  ------------------
  |  Branch (221:11): [True: 28, False: 2.88k]
  ------------------
  222|     28|	prev_c = (unsigned char)*(str_byte - 1);
  223|  2.90k|      next_c = (unsigned char)*str_byte;
  224|  2.90k|      pos = (int)(str_byte - orig_str);
  225|  2.90k|      if (len < 0 || pos < len)
  ------------------
  |  Branch (225:11): [True: 2.90k, False: 0]
  |  Branch (225:22): [True: 0, False: 0]
  ------------------
  226|  2.90k|	str_byte++;
  227|  2.90k|    }
  228|    285|  else
  229|    285|    {
  230|    285|      GET_NEXT_WCHAR();
  ------------------
  |  |   18|    285|  do {									      \
  |  |   19|    285|    prev_c = next_c;							      \
  |  |   20|    285|    if (type == STR_BYTE)						      \
  |  |  ------------------
  |  |  |  Branch (20:9): [True: 285, False: 0]
  |  |  ------------------
  |  |   21|    285|      {									      \
  |  |   22|    285|	pos++;								      \
  |  |   23|    285|	if (len >= 0 && pos >= len)					      \
  |  |  ------------------
  |  |  |  Branch (23:6): [True: 0, False: 285]
  |  |  |  Branch (23:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   24|    285|	  next_c = '\0';						      \
  |  |   25|    285|	else								      \
  |  |   26|    285|	  next_c = (unsigned char)(*str_byte++);			      \
  |  |   27|    285|      }									      \
  |  |   28|    285|    else if (type == STR_WIDE)						      \
  |  |  ------------------
  |  |  |  Branch (28:14): [True: 0, False: 0]
  |  |  ------------------
  |  |   29|      0|      {									      \
  |  |   30|      0|	pos++;								      \
  |  |   31|      0|	if (len >= 0 && pos >= len)					      \
  |  |  ------------------
  |  |  |  Branch (31:6): [True: 0, False: 0]
  |  |  |  Branch (31:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   32|      0|	  next_c = L'\0';						      \
  |  |   33|      0|	else								      \
  |  |   34|      0|	  next_c = *str_wide++;						      \
  |  |   35|      0|      }									      \
  |  |   36|      0|    else if (type == STR_MBS)						      \
  |  |  ------------------
  |  |  |  Branch (36:14): [True: 0, False: 0]
  |  |  ------------------
  |  |   37|      0|      {									      \
  |  |   38|      0|        pos += pos_add_next;					      	      \
  |  |   39|      0|	if (str_byte == NULL)						      \
  |  |  ------------------
  |  |  |  Branch (39:6): [True: 0, False: 0]
  |  |  ------------------
  |  |   40|      0|	  next_c = L'\0';						      \
  |  |   41|      0|	else								      \
  |  |   42|      0|	  {								      \
  |  |   43|      0|	    size_t w;							      \
  |  |   44|      0|	    int max;							      \
  |  |   45|      0|	    if (len >= 0)						      \
  |  |  ------------------
  |  |  |  Branch (45:10): [True: 0, False: 0]
  |  |  ------------------
  |  |   46|      0|	      max = len - pos;						      \
  |  |   47|      0|	    else							      \
  |  |   48|      0|	      max = 32;							      \
  |  |   49|      0|	    if (max <= 0)						      \
  |  |  ------------------
  |  |  |  Branch (49:10): [True: 0, False: 0]
  |  |  ------------------
  |  |   50|      0|	      {								      \
  |  |   51|      0|		next_c = L'\0';						      \
  |  |   52|      0|		pos_add_next = 1;					      \
  |  |   53|      0|	      }								      \
  |  |   54|      0|	    else							      \
  |  |   55|      0|	      {								      \
  |  |   56|      0|		w = tre_mbrtowc(&next_c, str_byte, (size_t)max, &mbstate);    \
  |  |  ------------------
  |  |  |  |   33|      0|#define tre_mbrtowc(pwc, s, n, ps) (mbrtowc((pwc), (s), (n), (ps)))
  |  |  ------------------
  |  |   57|      0|		if (w == (size_t)-1 || w == (size_t)-2)			      \
  |  |  ------------------
  |  |  |  Branch (57:7): [True: 0, False: 0]
  |  |  |  Branch (57:26): [True: 0, False: 0]
  |  |  ------------------
  |  |   58|      0|		  return REG_NOMATCH;					      \
  |  |   59|      0|		if (w == 0 && len >= 0)					      \
  |  |  ------------------
  |  |  |  Branch (59:7): [True: 0, False: 0]
  |  |  |  Branch (59:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   60|      0|		  {							      \
  |  |   61|      0|		    pos_add_next = 1;					      \
  |  |   62|      0|		    next_c = 0;						      \
  |  |   63|      0|		    str_byte++;						      \
  |  |   64|      0|		  }							      \
  |  |   65|      0|		else							      \
  |  |   66|      0|		  {							      \
  |  |   67|      0|		    pos_add_next = (unsigned int)w;					      \
  |  |   68|      0|		    str_byte += w;					      \
  |  |   69|      0|		  }							      \
  |  |   70|      0|	      }								      \
  |  |   71|      0|	  }								      \
  |  |   72|      0|      }									      \
  |  |   73|      0|    else if (type == STR_USER)						      \
  |  |  ------------------
  |  |  |  Branch (73:14): [True: 0, False: 0]
  |  |  ------------------
  |  |   74|      0|      {									      \
  |  |   75|      0|        pos += pos_add_next;					      	      \
  |  |   76|      0|	str_user_end = str_source->get_next_char(&next_c, &pos_add_next,      \
  |  |  ------------------
  |  |  |  |    9|      0|#define str_source ((const tre_str_source*)string)
  |  |  ------------------
  |  |   77|      0|                                                 str_source->context);	      \
  |  |  ------------------
  |  |  |  |    9|      0|#define str_source ((const tre_str_source*)string)
  |  |  ------------------
  |  |   78|      0|      }									      \
  |  |   79|    285|  } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (79:24): [Folded, False: 285]
  |  |  ------------------
  ------------------
  231|    285|      pos = 0;
  232|    285|    }
  233|       |
  234|       |#if 0
  235|       |  /* Skip over characters that cannot possibly be the first character
  236|       |     of a match. */
  237|       |  if (tnfa->firstpos_chars != NULL)
  238|       |    {
  239|       |      char *chars = tnfa->firstpos_chars;
  240|       |
  241|       |      if (len < 0)
  242|       |	{
  243|       |	  const char *orig_str = str_byte;
  244|       |	  /* XXX - use strpbrk() and wcspbrk() because they might be
  245|       |	     optimized for the target architecture.  Try also strcspn()
  246|       |	     and wcscspn() and compare the speeds. */
  247|       |	  while (next_c != L'\0' && !chars[next_c])
  248|       |	    {
  249|       |	      next_c = *str_byte++;
  250|       |	    }
  251|       |	  prev_c = *(str_byte - 2);
  252|       |	  pos += str_byte - orig_str;
  253|       |	  DPRINT(("skipped %d chars\n", str_byte - orig_str));
  254|       |	}
  255|       |      else
  256|       |	{
  257|       |	  while (pos <= len && !chars[next_c])
  258|       |	    {
  259|       |	      prev_c = next_c;
  260|       |	      next_c = (unsigned char)(*str_byte++);
  261|       |	      pos++;
  262|       |	    }
  263|       |	}
  264|       |    }
  265|       |#endif
  266|       |
  267|  3.19k|  DPRINT(("length: %d\n", len));
  ------------------
  |  |   27|  3.19k|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 3.19k]
  |  |  ------------------
  ------------------
  268|  3.19k|  DPRINT(("pos:chr/code | states and tags\n"));
  ------------------
  |  |   27|  3.19k|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 3.19k]
  |  |  ------------------
  ------------------
  269|  3.19k|  DPRINT(("-------------+------------------------------------------------\n"));
  ------------------
  |  |   27|  3.19k|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 3.19k]
  |  |  ------------------
  ------------------
  270|       |
  271|  3.19k|  reach_next_i = reach_next;
  272|  49.2k|  while (/*CONSTCOND*/(void)1,1)
  ------------------
  |  Branch (272:23): [True: 49.2k, Folded]
  ------------------
  273|  49.2k|    {
  274|       |      /* If no match found yet, add the initial states to `reach_next'. */
  275|  49.2k|      if (match_eo < 0)
  ------------------
  |  Branch (275:11): [True: 48.3k, False: 964]
  ------------------
  276|  48.3k|	{
  277|  48.3k|	  DPRINT((" init >"));
  ------------------
  |  |   27|  48.3k|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 48.3k]
  |  |  ------------------
  ------------------
  278|  48.3k|	  trans_i = tnfa->initial;
  279|  99.7k|	  while (trans_i->state != NULL)
  ------------------
  |  Branch (279:11): [True: 51.4k, False: 48.3k]
  ------------------
  280|  51.4k|	    {
  281|  51.4k|	      if (reach_pos[trans_i->state_id].pos < pos)
  ------------------
  |  Branch (281:12): [True: 48.3k, False: 3.12k]
  ------------------
  282|  48.3k|		{
  283|  48.3k|		  if (trans_i->assertions
  ------------------
  |  Branch (283:9): [True: 46.9k, False: 1.34k]
  ------------------
  284|  46.9k|		      && CHECK_ASSERTIONS(trans_i->assertions))
  ------------------
  |  |  144|  46.9k|  (((assertions & ASSERT_AT_BOL)					      \
  |  |  ------------------
  |  |  |  |  210|  46.9k|#define ASSERT_AT_BOL		  1   /* Beginning of line. */
  |  |  ------------------
  |  |  |  Branch (144:5): [True: 46.9k, False: 0]
  |  |  ------------------
  |  |  145|  46.9k|    && (pos > 0 || reg_notbol)						      \
  |  |  ------------------
  |  |  |  Branch (145:9): [True: 43.9k, False: 3.00k]
  |  |  |  Branch (145:20): [True: 0, False: 3.00k]
  |  |  ------------------
  |  |  146|  46.9k|    && (prev_c != L'\n' || !reg_newline))				      \
  |  |  ------------------
  |  |  |  Branch (146:9): [True: 43.9k, False: 0]
  |  |  |  Branch (146:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  147|  46.9k|   || ((assertions & ASSERT_AT_EOL)					      \
  |  |  ------------------
  |  |  |  |  211|  3.00k|#define ASSERT_AT_EOL		  2   /* End of line. */
  |  |  ------------------
  |  |  |  Branch (147:8): [True: 0, False: 3.00k]
  |  |  ------------------
  |  |  148|  3.00k|       && (next_c != L'\0' || reg_noteol)				      \
  |  |  ------------------
  |  |  |  Branch (148:12): [True: 0, False: 0]
  |  |  |  Branch (148:31): [True: 0, False: 0]
  |  |  ------------------
  |  |  149|  3.00k|       && (next_c != L'\n' || !reg_newline))				      \
  |  |  ------------------
  |  |  |  Branch (149:12): [True: 0, False: 0]
  |  |  |  Branch (149:31): [True: 0, False: 0]
  |  |  ------------------
  |  |  150|  46.9k|   || ((assertions & ASSERT_AT_BOW)					      \
  |  |  ------------------
  |  |  |  |  214|  3.00k|#define ASSERT_AT_BOW		 16   /* Beginning of word. */
  |  |  ------------------
  |  |  |  Branch (150:8): [True: 0, False: 3.00k]
  |  |  ------------------
  |  |  151|  3.00k|       && (IS_WORD_CHAR(prev_c) || !IS_WORD_CHAR(next_c)))	              \
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                      && (IS_WORD_CHAR(prev_c) || !IS_WORD_CHAR(next_c)))	              \
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  152|  46.9k|   || ((assertions & ASSERT_AT_EOW)					      \
  |  |  ------------------
  |  |  |  |  215|  3.00k|#define ASSERT_AT_EOW		 32   /* End of word. */
  |  |  ------------------
  |  |  |  Branch (152:8): [True: 0, False: 3.00k]
  |  |  ------------------
  |  |  153|  3.00k|       && (!IS_WORD_CHAR(prev_c) || IS_WORD_CHAR(next_c)))		      \
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                      && (!IS_WORD_CHAR(prev_c) || IS_WORD_CHAR(next_c)))		      \
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  154|  46.9k|   || ((assertions & ASSERT_AT_WB)					      \
  |  |  ------------------
  |  |  |  |  216|  3.00k|#define ASSERT_AT_WB		 64   /* Word boundary. */
  |  |  ------------------
  |  |  |  Branch (154:8): [True: 0, False: 3.00k]
  |  |  ------------------
  |  |  155|  3.00k|       && (pos != 0 && next_c != L'\0'					      \
  |  |  ------------------
  |  |  |  Branch (155:12): [True: 0, False: 0]
  |  |  |  Branch (155:24): [True: 0, False: 0]
  |  |  ------------------
  |  |  156|      0|	   && IS_WORD_CHAR(prev_c) == IS_WORD_CHAR(next_c)))		      \
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	   && IS_WORD_CHAR(prev_c) == IS_WORD_CHAR(next_c)))		      \
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (156:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  157|  46.9k|   || ((assertions & ASSERT_AT_WB_NEG)					      \
  |  |  ------------------
  |  |  |  |  217|  3.00k|#define ASSERT_AT_WB_NEG	128   /* Not a word boundary. */
  |  |  ------------------
  |  |  |  Branch (157:8): [True: 0, False: 3.00k]
  |  |  ------------------
  |  |  158|  3.00k|       && (pos == 0 || next_c == L'\0'					      \
  |  |  ------------------
  |  |  |  Branch (158:12): [True: 0, False: 0]
  |  |  |  Branch (158:24): [True: 0, False: 0]
  |  |  ------------------
  |  |  159|      0|	   || IS_WORD_CHAR(prev_c) != IS_WORD_CHAR(next_c))))
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	   || IS_WORD_CHAR(prev_c) != IS_WORD_CHAR(next_c))))
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (159:8): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  285|  43.9k|		    {
  286|  43.9k|		      DPRINT(("assertion failed\n"));
  ------------------
  |  |   27|  43.9k|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 43.9k]
  |  |  ------------------
  ------------------
  287|  43.9k|		      trans_i++;
  288|  43.9k|		      continue;
  289|  43.9k|		    }
  290|       |
  291|  4.34k|		  DPRINT((" %p", (void *)trans_i->state));
  ------------------
  |  |   27|  4.34k|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 4.34k]
  |  |  ------------------
  ------------------
  292|  4.34k|		  reach_next_i->state = trans_i->state;
  293|  11.1k|		  for (i = 0; i < num_tags; i++)
  ------------------
  |  Branch (293:17): [True: 6.80k, False: 4.34k]
  ------------------
  294|  6.80k|		    reach_next_i->tags[i] = -1;
  295|  4.34k|		  tag_i = trans_i->tags;
  296|  4.34k|		  if (tag_i)
  ------------------
  |  Branch (296:9): [True: 4.34k, False: 0]
  ------------------
  297|  5.92k|		    while (*tag_i >= 0)
  ------------------
  |  Branch (297:14): [True: 1.57k, False: 4.34k]
  ------------------
  298|  1.57k|		      {
  299|  1.57k|			if (*tag_i < num_tags)
  ------------------
  |  Branch (299:8): [True: 1.57k, False: 0]
  ------------------
  300|  1.57k|			  reach_next_i->tags[*tag_i] = pos;
  301|  1.57k|			tag_i++;
  302|  1.57k|		      }
  303|  4.34k|		  if (reach_next_i->state == tnfa->final)
  ------------------
  |  Branch (303:9): [True: 0, False: 4.34k]
  ------------------
  304|      0|		    {
  305|      0|		      DPRINT(("	 found empty match\n"));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  306|      0|		      match_eo = pos;
  307|      0|		      new_match = 1;
  308|      0|		      for (i = 0; i < num_tags; i++)
  ------------------
  |  Branch (308:21): [True: 0, False: 0]
  ------------------
  309|      0|			match_tags[i] = reach_next_i->tags[i];
  310|      0|		    }
  311|  4.34k|		  reach_pos[trans_i->state_id].pos = pos;
  312|  4.34k|		  reach_pos[trans_i->state_id].tags = &reach_next_i->tags;
  313|  4.34k|		  reach_next_i++;
  314|  4.34k|		}
  315|  7.46k|	      trans_i++;
  316|  7.46k|	    }
  317|  48.3k|	  DPRINT(("\n"));
  ------------------
  |  |   27|  48.3k|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 48.3k]
  |  |  ------------------
  ------------------
  318|  48.3k|	  reach_next_i->state = NULL;
  319|  48.3k|	}
  320|    964|      else
  321|    964|	{
  322|    964|	  if (num_tags == 0 || reach_next_i == reach_next)
  ------------------
  |  Branch (322:8): [True: 348, False: 616]
  |  Branch (322:25): [True: 158, False: 458]
  ------------------
  323|       |	    /* We have found a match. */
  324|    506|	    break;
  325|    964|	}
  326|       |
  327|       |      /* Check for end of string. */
  328|  48.7k|      if (len < 0)
  ------------------
  |  Branch (328:11): [True: 48.7k, False: 0]
  ------------------
  329|  48.7k|	{
  330|  48.7k|	  if (type == STR_USER)
  ------------------
  |  Branch (330:8): [True: 0, False: 48.7k]
  ------------------
  331|      0|	    {
  332|      0|	      if (str_user_end)
  ------------------
  |  Branch (332:12): [True: 0, False: 0]
  ------------------
  333|      0|		break;
  334|      0|	    }
  335|  48.7k|	  else if (next_c == L'\0')
  ------------------
  |  Branch (335:13): [True: 2.68k, False: 46.0k]
  ------------------
  336|  2.68k|	    break;
  337|  48.7k|	}
  338|      0|      else
  339|      0|	{
  340|      0|	  if (pos >= len)
  ------------------
  |  Branch (340:8): [True: 0, False: 0]
  ------------------
  341|      0|	    break;
  342|      0|	}
  343|       |
  344|  46.0k|      GET_NEXT_WCHAR();
  ------------------
  |  |   18|  46.0k|  do {									      \
  |  |   19|  46.0k|    prev_c = next_c;							      \
  |  |   20|  46.0k|    if (type == STR_BYTE)						      \
  |  |  ------------------
  |  |  |  Branch (20:9): [True: 46.0k, False: 0]
  |  |  ------------------
  |  |   21|  46.0k|      {									      \
  |  |   22|  46.0k|	pos++;								      \
  |  |   23|  46.0k|	if (len >= 0 && pos >= len)					      \
  |  |  ------------------
  |  |  |  Branch (23:6): [True: 0, False: 46.0k]
  |  |  |  Branch (23:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   24|  46.0k|	  next_c = '\0';						      \
  |  |   25|  46.0k|	else								      \
  |  |   26|  46.0k|	  next_c = (unsigned char)(*str_byte++);			      \
  |  |   27|  46.0k|      }									      \
  |  |   28|  46.0k|    else if (type == STR_WIDE)						      \
  |  |  ------------------
  |  |  |  Branch (28:14): [True: 0, False: 0]
  |  |  ------------------
  |  |   29|      0|      {									      \
  |  |   30|      0|	pos++;								      \
  |  |   31|      0|	if (len >= 0 && pos >= len)					      \
  |  |  ------------------
  |  |  |  Branch (31:6): [True: 0, False: 0]
  |  |  |  Branch (31:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   32|      0|	  next_c = L'\0';						      \
  |  |   33|      0|	else								      \
  |  |   34|      0|	  next_c = *str_wide++;						      \
  |  |   35|      0|      }									      \
  |  |   36|      0|    else if (type == STR_MBS)						      \
  |  |  ------------------
  |  |  |  Branch (36:14): [True: 0, False: 0]
  |  |  ------------------
  |  |   37|      0|      {									      \
  |  |   38|      0|        pos += pos_add_next;					      	      \
  |  |   39|      0|	if (str_byte == NULL)						      \
  |  |  ------------------
  |  |  |  Branch (39:6): [True: 0, False: 0]
  |  |  ------------------
  |  |   40|      0|	  next_c = L'\0';						      \
  |  |   41|      0|	else								      \
  |  |   42|      0|	  {								      \
  |  |   43|      0|	    size_t w;							      \
  |  |   44|      0|	    int max;							      \
  |  |   45|      0|	    if (len >= 0)						      \
  |  |  ------------------
  |  |  |  Branch (45:10): [True: 0, False: 0]
  |  |  ------------------
  |  |   46|      0|	      max = len - pos;						      \
  |  |   47|      0|	    else							      \
  |  |   48|      0|	      max = 32;							      \
  |  |   49|      0|	    if (max <= 0)						      \
  |  |  ------------------
  |  |  |  Branch (49:10): [True: 0, False: 0]
  |  |  ------------------
  |  |   50|      0|	      {								      \
  |  |   51|      0|		next_c = L'\0';						      \
  |  |   52|      0|		pos_add_next = 1;					      \
  |  |   53|      0|	      }								      \
  |  |   54|      0|	    else							      \
  |  |   55|      0|	      {								      \
  |  |   56|      0|		w = tre_mbrtowc(&next_c, str_byte, (size_t)max, &mbstate);    \
  |  |  ------------------
  |  |  |  |   33|      0|#define tre_mbrtowc(pwc, s, n, ps) (mbrtowc((pwc), (s), (n), (ps)))
  |  |  ------------------
  |  |   57|      0|		if (w == (size_t)-1 || w == (size_t)-2)			      \
  |  |  ------------------
  |  |  |  Branch (57:7): [True: 0, False: 0]
  |  |  |  Branch (57:26): [True: 0, False: 0]
  |  |  ------------------
  |  |   58|      0|		  return REG_NOMATCH;					      \
  |  |   59|      0|		if (w == 0 && len >= 0)					      \
  |  |  ------------------
  |  |  |  Branch (59:7): [True: 0, False: 0]
  |  |  |  Branch (59:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   60|      0|		  {							      \
  |  |   61|      0|		    pos_add_next = 1;					      \
  |  |   62|      0|		    next_c = 0;						      \
  |  |   63|      0|		    str_byte++;						      \
  |  |   64|      0|		  }							      \
  |  |   65|      0|		else							      \
  |  |   66|      0|		  {							      \
  |  |   67|      0|		    pos_add_next = (unsigned int)w;					      \
  |  |   68|      0|		    str_byte += w;					      \
  |  |   69|      0|		  }							      \
  |  |   70|      0|	      }								      \
  |  |   71|      0|	  }								      \
  |  |   72|      0|      }									      \
  |  |   73|      0|    else if (type == STR_USER)						      \
  |  |  ------------------
  |  |  |  Branch (73:14): [True: 0, False: 0]
  |  |  ------------------
  |  |   74|      0|      {									      \
  |  |   75|      0|        pos += pos_add_next;					      	      \
  |  |   76|      0|	str_user_end = str_source->get_next_char(&next_c, &pos_add_next,      \
  |  |  ------------------
  |  |  |  |    9|      0|#define str_source ((const tre_str_source*)string)
  |  |  ------------------
  |  |   77|      0|                                                 str_source->context);	      \
  |  |  ------------------
  |  |  |  |    9|      0|#define str_source ((const tre_str_source*)string)
  |  |  ------------------
  |  |   78|      0|      }									      \
  |  |   79|  46.0k|  } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (79:24): [Folded, False: 46.0k]
  |  |  ------------------
  ------------------
  345|       |
  346|       |#ifdef TRE_DEBUG
  347|       |      DPRINT(("%3d:%2lc/%05d |", pos - 1, (tre_cint_t)prev_c, (int)prev_c));
  348|       |      tre_print_reach(tnfa, reach_next, num_tags);
  349|       |      DPRINT(("%3d:%2lc/%05d |", pos, (tre_cint_t)next_c, (int)next_c));
  350|       |      tre_print_reach(tnfa, reach_next, num_tags);
  351|       |#endif /* TRE_DEBUG */
  352|       |
  353|       |      /* Swap `reach' and `reach_next'. */
  354|  46.0k|      reach_i = reach;
  355|  46.0k|      reach = reach_next;
  356|  46.0k|      reach_next = reach_i;
  357|       |
  358|       |      /* For each state in `reach', weed out states that don't fulfill the
  359|       |	 minimal matching conditions. */
  360|  46.0k|      if (tnfa->num_minimals && new_match)
  ------------------
  |  Branch (360:11): [True: 0, False: 46.0k]
  |  Branch (360:33): [True: 0, False: 0]
  ------------------
  361|      0|	{
  362|      0|	  new_match = 0;
  363|      0|	  reach_next_i = reach_next;
  364|      0|	  for (reach_i = reach; reach_i->state; reach_i++)
  ------------------
  |  Branch (364:26): [True: 0, False: 0]
  ------------------
  365|      0|	    {
  366|      0|	      int skip = 0;
  367|      0|	      for (i = 0; tnfa->minimal_tags[i] >= 0; i += 2)
  ------------------
  |  Branch (367:20): [True: 0, False: 0]
  ------------------
  368|      0|		{
  369|      0|		  int end = tnfa->minimal_tags[i];
  370|      0|		  int start = tnfa->minimal_tags[i + 1];
  371|      0|		  DPRINT(("  Minimal start %d, end %d\n", start, end));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  372|      0|		  if (end >= num_tags)
  ------------------
  |  Branch (372:9): [True: 0, False: 0]
  ------------------
  373|      0|		    {
  374|      0|		      DPRINT(("	 Throwing %p out.\n", reach_i->state));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  375|      0|		      skip = 1;
  376|      0|		      break;
  377|      0|		    }
  378|      0|		  else if (reach_i->tags[start] == match_tags[start]
  ------------------
  |  Branch (378:14): [True: 0, False: 0]
  ------------------
  379|      0|			   && reach_i->tags[end] < match_tags[end])
  ------------------
  |  Branch (379:10): [True: 0, False: 0]
  ------------------
  380|      0|		    {
  381|      0|		      DPRINT(("	 Throwing %p out because t%d < %d\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  382|      0|			      reach_i->state, end, match_tags[end]));
  383|      0|		      skip = 1;
  384|      0|		      break;
  385|      0|		    }
  386|      0|		}
  387|      0|	      if (!skip)
  ------------------
  |  Branch (387:12): [True: 0, False: 0]
  ------------------
  388|      0|		{
  389|      0|		  reach_next_i->state = reach_i->state;
  390|      0|		  tmp_iptr = reach_next_i->tags;
  391|      0|		  reach_next_i->tags = reach_i->tags;
  392|      0|		  reach_i->tags = tmp_iptr;
  393|      0|		  reach_next_i++;
  394|      0|		}
  395|      0|	    }
  396|      0|	  reach_next_i->state = NULL;
  397|       |
  398|       |	  /* Swap `reach' and `reach_next'. */
  399|      0|	  reach_i = reach;
  400|      0|	  reach = reach_next;
  401|      0|	  reach_next = reach_i;
  402|      0|	}
  403|       |
  404|       |      /* For each state in `reach' see if there is a transition leaving with
  405|       |	 the current input symbol to a state not yet in `reach_next', and
  406|       |	 add the destination states to `reach_next'. */
  407|  46.0k|      reach_next_i = reach_next;
  408|  58.5k|      for (reach_i = reach; reach_i->state; reach_i++)
  ------------------
  |  Branch (408:29): [True: 12.4k, False: 46.0k]
  ------------------
  409|  12.4k|	{
  410|  28.5k|	  for (trans_i = reach_i->state; trans_i->state; trans_i++)
  ------------------
  |  Branch (410:35): [True: 16.1k, False: 12.4k]
  ------------------
  411|  16.1k|	    {
  412|       |	      /* Does this transition match the input symbol? */
  413|  16.1k|	      if (trans_i->code_min <= (tre_cint_t)prev_c &&
  ------------------
  |  Branch (413:12): [True: 15.0k, False: 1.13k]
  ------------------
  414|  15.0k|		  trans_i->code_max >= (tre_cint_t)prev_c)
  ------------------
  |  Branch (414:5): [True: 8.78k, False: 6.23k]
  ------------------
  415|  8.78k|		{
  416|  8.78k|		  if (trans_i->assertions
  ------------------
  |  Branch (416:9): [True: 112, False: 8.67k]
  ------------------
  417|    112|		      && (CHECK_ASSERTIONS(trans_i->assertions)
  ------------------
  |  |  144|    224|  (((assertions & ASSERT_AT_BOL)					      \
  |  |  ------------------
  |  |  |  |  210|    112|#define ASSERT_AT_BOL		  1   /* Beginning of line. */
  |  |  ------------------
  |  |  |  Branch (144:5): [True: 0, False: 112]
  |  |  ------------------
  |  |  145|    112|    && (pos > 0 || reg_notbol)						      \
  |  |  ------------------
  |  |  |  Branch (145:9): [True: 0, False: 0]
  |  |  |  Branch (145:20): [True: 0, False: 0]
  |  |  ------------------
  |  |  146|    112|    && (prev_c != L'\n' || !reg_newline))				      \
  |  |  ------------------
  |  |  |  Branch (146:9): [True: 0, False: 0]
  |  |  |  Branch (146:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  147|    112|   || ((assertions & ASSERT_AT_EOL)					      \
  |  |  ------------------
  |  |  |  |  211|    112|#define ASSERT_AT_EOL		  2   /* End of line. */
  |  |  ------------------
  |  |  |  Branch (147:8): [True: 112, False: 0]
  |  |  ------------------
  |  |  148|    112|       && (next_c != L'\0' || reg_noteol)				      \
  |  |  ------------------
  |  |  |  Branch (148:12): [True: 68, False: 44]
  |  |  |  Branch (148:31): [True: 0, False: 44]
  |  |  ------------------
  |  |  149|    112|       && (next_c != L'\n' || !reg_newline))				      \
  |  |  ------------------
  |  |  |  Branch (149:12): [True: 68, False: 0]
  |  |  |  Branch (149:31): [True: 0, False: 0]
  |  |  ------------------
  |  |  150|    112|   || ((assertions & ASSERT_AT_BOW)					      \
  |  |  ------------------
  |  |  |  |  214|     44|#define ASSERT_AT_BOW		 16   /* Beginning of word. */
  |  |  ------------------
  |  |  |  Branch (150:8): [True: 0, False: 44]
  |  |  ------------------
  |  |  151|     44|       && (IS_WORD_CHAR(prev_c) || !IS_WORD_CHAR(next_c)))	              \
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                      && (IS_WORD_CHAR(prev_c) || !IS_WORD_CHAR(next_c)))	              \
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  152|    112|   || ((assertions & ASSERT_AT_EOW)					      \
  |  |  ------------------
  |  |  |  |  215|     44|#define ASSERT_AT_EOW		 32   /* End of word. */
  |  |  ------------------
  |  |  |  Branch (152:8): [True: 0, False: 44]
  |  |  ------------------
  |  |  153|     44|       && (!IS_WORD_CHAR(prev_c) || IS_WORD_CHAR(next_c)))		      \
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                      && (!IS_WORD_CHAR(prev_c) || IS_WORD_CHAR(next_c)))		      \
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  154|    112|   || ((assertions & ASSERT_AT_WB)					      \
  |  |  ------------------
  |  |  |  |  216|     44|#define ASSERT_AT_WB		 64   /* Word boundary. */
  |  |  ------------------
  |  |  |  Branch (154:8): [True: 0, False: 44]
  |  |  ------------------
  |  |  155|     44|       && (pos != 0 && next_c != L'\0'					      \
  |  |  ------------------
  |  |  |  Branch (155:12): [True: 0, False: 0]
  |  |  |  Branch (155:24): [True: 0, False: 0]
  |  |  ------------------
  |  |  156|      0|	   && IS_WORD_CHAR(prev_c) == IS_WORD_CHAR(next_c)))		      \
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	   && IS_WORD_CHAR(prev_c) == IS_WORD_CHAR(next_c)))		      \
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (156:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  157|    224|   || ((assertions & ASSERT_AT_WB_NEG)					      \
  |  |  ------------------
  |  |  |  |  217|     44|#define ASSERT_AT_WB_NEG	128   /* Not a word boundary. */
  |  |  ------------------
  |  |  |  Branch (157:8): [True: 0, False: 44]
  |  |  ------------------
  |  |  158|     44|       && (pos == 0 || next_c == L'\0'					      \
  |  |  ------------------
  |  |  |  Branch (158:12): [True: 0, False: 0]
  |  |  |  Branch (158:24): [True: 0, False: 0]
  |  |  ------------------
  |  |  159|      0|	   || IS_WORD_CHAR(prev_c) != IS_WORD_CHAR(next_c))))
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	   || IS_WORD_CHAR(prev_c) != IS_WORD_CHAR(next_c))))
  |  |  ------------------
  |  |  |  |  141|      0|#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|#define tre_isalnum iswalnum
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (141:27): [True: 0, False: 0]
  |  |  |  |  |  Branch (141:42): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (159:8): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  418|     44|			  || CHECK_CHAR_CLASSES(trans_i, tnfa, eflags)))
  ------------------
  |  |  162|     44|  (((trans_i->assertions & ASSERT_CHAR_CLASS)                                 \
  |  |  ------------------
  |  |  |  |  212|     44|#define ASSERT_CHAR_CLASS	  4   /* Character class in `class'. */
  |  |  ------------------
  |  |  |  Branch (162:5): [True: 0, False: 44]
  |  |  ------------------
  |  |  163|     44|       && !(tnfa->cflags & REG_ICASE)                                         \
  |  |  ------------------
  |  |  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (163:11): [True: 0, False: 0]
  |  |  ------------------
  |  |  164|     44|       && !tre_isctype((tre_cint_t)prev_c, trans_i->u.class))                 \
  |  |  ------------------
  |  |  |  |  139|      0|#define tre_isctype(c, type) iswctype(c, type)
  |  |  ------------------
  |  |  |  Branch (164:11): [True: 0, False: 0]
  |  |  ------------------
  |  |  165|     44|    || ((trans_i->assertions & ASSERT_CHAR_CLASS)                             \
  |  |  ------------------
  |  |  |  |  212|     44|#define ASSERT_CHAR_CLASS	  4   /* Character class in `class'. */
  |  |  ------------------
  |  |  |  Branch (165:9): [True: 0, False: 44]
  |  |  ------------------
  |  |  166|     44|        && (tnfa->cflags & REG_ICASE)                                         \
  |  |  ------------------
  |  |  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (166:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  167|     44|        && !tre_isctype(tre_tolower((tre_cint_t)prev_c),trans_i->u.class)     \
  |  |  ------------------
  |  |  |  |  139|     44|#define tre_isctype(c, type) iswctype(c, type)
  |  |  ------------------
  |  |  |  Branch (167:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  168|     44|	&& !tre_isctype(tre_toupper((tre_cint_t)prev_c),trans_i->u.class))    \
  |  |  ------------------
  |  |  |  |  139|      0|#define tre_isctype(c, type) iswctype(c, type)
  |  |  ------------------
  |  |  |  Branch (168:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  169|     44|    || ((trans_i->assertions & ASSERT_CHAR_CLASS_NEG)                         \
  |  |  ------------------
  |  |  |  |  213|     44|#define ASSERT_CHAR_CLASS_NEG	  8   /* Character classes in `neg_classes'. */
  |  |  ------------------
  |  |  |  Branch (169:9): [True: 0, False: 44]
  |  |  ------------------
  |  |  170|     44|        && tre_neg_char_classes_match(trans_i->neg_classes,(tre_cint_t)prev_c,\
  |  |  ------------------
  |  |  |  Branch (170:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  171|      0|                                      tnfa->cflags & REG_ICASE)))
  |  |  ------------------
  |  |  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  419|     68|		    {
  420|     68|		      DPRINT(("assertion failed\n"));
  ------------------
  |  |   27|     68|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 68]
  |  |  ------------------
  ------------------
  421|     68|		      continue;
  422|     68|		    }
  423|       |
  424|       |		  /* Compute the tags after this transition. */
  425|  20.1k|		  for (i = 0; i < num_tags; i++)
  ------------------
  |  Branch (425:17): [True: 11.3k, False: 8.71k]
  ------------------
  426|  11.3k|		    tmp_tags[i] = reach_i->tags[i];
  427|  8.71k|		  tag_i = trans_i->tags;
  428|  8.71k|		  if (tag_i != NULL)
  ------------------
  |  Branch (428:9): [True: 1.81k, False: 6.89k]
  ------------------
  429|  6.87k|		    while (*tag_i >= 0)
  ------------------
  |  Branch (429:14): [True: 5.05k, False: 1.81k]
  ------------------
  430|  5.05k|		      {
  431|  5.05k|			if (*tag_i < num_tags)
  ------------------
  |  Branch (431:8): [True: 5.05k, False: 0]
  ------------------
  432|  5.05k|			  tmp_tags[*tag_i] = pos;
  433|  5.05k|			tag_i++;
  434|  5.05k|		      }
  435|       |
  436|  8.71k|		  if (reach_pos[trans_i->state_id].pos < pos)
  ------------------
  |  Branch (436:9): [True: 8.71k, False: 4]
  ------------------
  437|  8.71k|		    {
  438|       |		      /* Found an unvisited node. */
  439|  8.71k|		      reach_next_i->state = trans_i->state;
  440|  8.71k|		      tmp_iptr = reach_next_i->tags;
  441|  8.71k|		      reach_next_i->tags = tmp_tags;
  442|  8.71k|		      tmp_tags = tmp_iptr;
  443|  8.71k|		      reach_pos[trans_i->state_id].pos = pos;
  444|  8.71k|		      reach_pos[trans_i->state_id].tags = &reach_next_i->tags;
  445|       |
  446|  8.71k|		      if (reach_next_i->state == tnfa->final
  ------------------
  |  Branch (446:13): [True: 806, False: 7.90k]
  ------------------
  447|    806|			  && (match_eo == -1
  ------------------
  |  Branch (447:10): [True: 528, False: 278]
  ------------------
  448|    278|			      || (num_tags > 0
  ------------------
  |  Branch (448:14): [True: 278, False: 0]
  ------------------
  449|    278|				  && reach_next_i->tags[0] <= match_tags[0])))
  ------------------
  |  Branch (449:10): [True: 278, False: 0]
  ------------------
  450|    806|			{
  451|    806|			  DPRINT(("  found match %p\n", trans_i->state));
  ------------------
  |  |   27|    806|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 806]
  |  |  ------------------
  ------------------
  452|    806|			  match_eo = pos;
  453|    806|			  new_match = 1;
  454|  1.67k|			  for (i = 0; i < num_tags; i++)
  ------------------
  |  Branch (454:18): [True: 868, False: 806]
  ------------------
  455|    868|			    match_tags[i] = reach_next_i->tags[i];
  456|    806|			}
  457|  8.71k|		      reach_next_i++;
  458|       |
  459|  8.71k|		    }
  460|      4|		  else
  461|      4|		    {
  462|      4|		      assert(reach_pos[trans_i->state_id].pos == pos);
  ------------------
  |  |   68|      4|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|      4|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [True: 4, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  463|       |		      /* Another path has also reached this state.  We choose
  464|       |			 the winner by examining the tag values for both
  465|       |			 paths. */
  466|      4|		      if (tre_tag_order(num_tags, tnfa->tag_directions,
  ------------------
  |  Branch (466:13): [True: 0, False: 4]
  ------------------
  467|      4|					tmp_tags,
  468|      4|					*reach_pos[trans_i->state_id].tags))
  469|      0|			{
  470|       |			  /* The new path wins. */
  471|      0|			  tmp_iptr = *reach_pos[trans_i->state_id].tags;
  472|      0|			  *reach_pos[trans_i->state_id].tags = tmp_tags;
  473|      0|			  if (trans_i->state == tnfa->final)
  ------------------
  |  Branch (473:10): [True: 0, False: 0]
  ------------------
  474|      0|			    {
  475|      0|			      DPRINT(("	 found better match\n"));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  476|      0|			      match_eo = pos;
  477|      0|			      new_match = 1;
  478|      0|			      for (i = 0; i < num_tags; i++)
  ------------------
  |  Branch (478:22): [True: 0, False: 0]
  ------------------
  479|      0|				match_tags[i] = tmp_tags[i];
  480|      0|			    }
  481|      0|			  tmp_tags = tmp_iptr;
  482|      0|			}
  483|      4|		    }
  484|  8.71k|		}
  485|  16.1k|	    }
  486|  12.4k|	}
  487|  46.0k|      reach_next_i->state = NULL;
  488|  46.0k|    }
  489|       |
  490|  3.19k|  DPRINT(("match end offset = %d\n", match_eo));
  ------------------
  |  |   27|  3.19k|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 3.19k]
  |  |  ------------------
  ------------------
  491|       |
  492|  3.19k|#ifndef TRE_USE_ALLOCA
  493|  3.19k|  if (buf)
  ------------------
  |  Branch (493:7): [True: 3.19k, False: 0]
  ------------------
  494|  3.19k|    xfree(buf);
  ------------------
  |  |   69|  3.19k|#define xfree(ptr) free(ptr)
  ------------------
  495|  3.19k|#endif /* !TRE_USE_ALLOCA */
  496|       |
  497|  3.19k|  *match_end_ofs = match_eo;
  498|  3.19k|  return match_eo >= 0 ? REG_OK : REG_NOMATCH;
  ------------------
  |  Branch (498:10): [True: 528, False: 2.66k]
  ------------------
  499|  3.19k|}

tre-match-parallel.c:tre_tag_order:
  180|      4|{
  181|      4|  int i;
  182|      4|  for (i = 0; i < num_tags; i++)
  ------------------
  |  Branch (182:15): [True: 4, False: 0]
  ------------------
  183|      4|    {
  184|      4|      if (tag_directions[i] == TRE_TAG_MINIMIZE)
  ------------------
  |  Branch (184:11): [True: 4, False: 0]
  ------------------
  185|      4|	{
  186|      4|	  if (t1[i] < t2[i])
  ------------------
  |  Branch (186:8): [True: 0, False: 4]
  ------------------
  187|      0|	    return 1;
  188|      4|	  if (t1[i] > t2[i])
  ------------------
  |  Branch (188:8): [True: 4, False: 0]
  ------------------
  189|      4|	    return 0;
  190|      4|	}
  191|      0|      else
  192|      0|	{
  193|      0|	  if (t1[i] > t2[i])
  ------------------
  |  Branch (193:8): [True: 0, False: 0]
  ------------------
  194|      0|	    return 1;
  195|      0|	  if (t1[i] < t2[i])
  ------------------
  |  Branch (195:8): [True: 0, False: 0]
  ------------------
  196|      0|	    return 0;
  197|      0|	}
  198|      4|    }
  199|       |  /*  assert(0);*/
  200|      0|  return 0;
  201|      4|}

tre_mem_new_impl:
   30|    206|{
   31|    206|  tre_mem_t mem;
   32|    206|  if (provided)
  ------------------
  |  Branch (32:7): [True: 0, False: 206]
  ------------------
   33|      0|    {
   34|      0|      mem = provided_block;
   35|      0|      memset(mem, 0, sizeof(*mem));
   36|      0|    }
   37|    206|  else
   38|    206|    mem = xcalloc(1, sizeof(*mem));
  ------------------
  |  |   68|    206|#define xcalloc(nmemb, size) calloc(nmemb, size)
  ------------------
   39|    206|  if (mem == NULL)
  ------------------
  |  Branch (39:7): [True: 0, False: 206]
  ------------------
   40|      0|    return NULL;
   41|    206|  return mem;
   42|    206|}
tre_mem_destroy:
   48|    206|{
   49|    206|  tre_list_t *tmp, *l = mem->blocks;
   50|       |
   51|  1.08k|  while (l != NULL)
  ------------------
  |  Branch (51:10): [True: 881, False: 206]
  ------------------
   52|    881|    {
   53|    881|      xfree(l->data);
  ------------------
  |  |   69|    881|#define xfree(ptr) free(ptr)
  ------------------
   54|    881|      tmp = l->next;
   55|    881|      xfree(l);
  ------------------
  |  |   69|    881|#define xfree(ptr) free(ptr)
  ------------------
   56|    881|      l = tmp;
   57|    881|    }
   58|    206|  xfree(mem);
  ------------------
  |  |   69|    206|#define xfree(ptr) free(ptr)
  ------------------
   59|    206|}
tre_mem_alloc_impl:
   67|  12.6k|{
   68|  12.6k|  void *ptr;
   69|       |
   70|  12.6k|  if (mem->failed)
  ------------------
  |  Branch (70:7): [True: 0, False: 12.6k]
  ------------------
   71|      0|    {
   72|      0|      DPRINT(("tre_mem_alloc: oops, called after failure?!\n"));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
   73|      0|      return NULL;
   74|      0|    }
   75|       |
   76|       |#ifdef MALLOC_DEBUGGING
   77|       |  if (!provided)
   78|       |    {
   79|       |      ptr = xmalloc(1);
   80|       |      if (ptr == NULL)
   81|       |	{
   82|       |	  DPRINT(("tre_mem_alloc: xmalloc forced failure\n"));
   83|       |	  mem->failed = 1;
   84|       |	  return NULL;
   85|       |	}
   86|       |      xfree(ptr);
   87|       |    }
   88|       |#endif /* MALLOC_DEBUGGING */
   89|       |
   90|  12.6k|  if (mem->n < size)
  ------------------
  |  Branch (90:7): [True: 881, False: 11.8k]
  ------------------
   91|    881|    {
   92|       |      /* We need more memory than is available in the current block.
   93|       |	 Allocate a new block. */
   94|    881|      tre_list_t *l;
   95|    881|      if (provided)
  ------------------
  |  Branch (95:11): [True: 0, False: 881]
  ------------------
   96|      0|	{
   97|      0|	  DPRINT(("tre_mem_alloc: using provided block\n"));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
   98|      0|	  if (provided_block == NULL)
  ------------------
  |  Branch (98:8): [True: 0, False: 0]
  ------------------
   99|      0|	    {
  100|      0|	      DPRINT(("tre_mem_alloc: provided block was NULL\n"));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  101|      0|	      mem->failed = 1;
  102|      0|	      return NULL;
  103|      0|	    }
  104|      0|	  mem->ptr = provided_block;
  105|      0|	  mem->n = TRE_MEM_BLOCK_SIZE;
  ------------------
  |  |   14|      0|#define TRE_MEM_BLOCK_SIZE 1024
  ------------------
  106|      0|	}
  107|    881|      else
  108|    881|	{
  109|    881|	  size_t block_size;
  110|    881|	  if (size * 8 > TRE_MEM_BLOCK_SIZE)
  ------------------
  |  |   14|    881|#define TRE_MEM_BLOCK_SIZE 1024
  ------------------
  |  Branch (110:8): [True: 67, False: 814]
  ------------------
  111|     67|	    block_size = size * 8;
  112|    814|	  else
  113|    814|	    block_size = TRE_MEM_BLOCK_SIZE;
  ------------------
  |  |   14|    814|#define TRE_MEM_BLOCK_SIZE 1024
  ------------------
  114|    881|	  DPRINT(("tre_mem_alloc: allocating new %lu byte block\n",
  ------------------
  |  |   27|    881|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 881]
  |  |  ------------------
  ------------------
  115|    881|		  (unsigned long)block_size));
  116|    881|	  l = xmalloc(sizeof(*l));
  ------------------
  |  |   67|    881|#define xmalloc(size) malloc(size)
  ------------------
  117|    881|	  if (l == NULL)
  ------------------
  |  Branch (117:8): [True: 0, False: 881]
  ------------------
  118|      0|	    {
  119|      0|	      mem->failed = 1;
  120|      0|	      return NULL;
  121|      0|	    }
  122|    881|	  l->data = xmalloc(block_size);
  ------------------
  |  |   67|    881|#define xmalloc(size) malloc(size)
  ------------------
  123|    881|	  if (l->data == NULL)
  ------------------
  |  Branch (123:8): [True: 0, False: 881]
  ------------------
  124|      0|	    {
  125|      0|	      xfree(l);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
  126|      0|	      mem->failed = 1;
  127|      0|	      return NULL;
  128|      0|	    }
  129|    881|	  l->next = NULL;
  130|    881|	  if (mem->current != NULL)
  ------------------
  |  Branch (130:8): [True: 675, False: 206]
  ------------------
  131|    675|	    mem->current->next = l;
  132|    881|	  if (mem->blocks == NULL)
  ------------------
  |  Branch (132:8): [True: 206, False: 675]
  ------------------
  133|    206|	    mem->blocks = l;
  134|    881|	  mem->current = l;
  135|    881|	  mem->ptr = l->data;
  136|    881|	  mem->n = block_size;
  137|    881|	}
  138|    881|    }
  139|       |
  140|       |  /* Make sure the next pointer will be aligned. */
  141|  12.6k|  size += ALIGN(mem->ptr + size, anytype);
  ------------------
  |  |  154|  12.6k|  ((((size_t)ptr) % sizeof(type)) \
  |  |  ------------------
  |  |  |  Branch (154:4): [True: 364, False: 12.3k]
  |  |  ------------------
  |  |  155|  12.6k|   ? (sizeof(type) - (((size_t)ptr) % sizeof(type))) \
  |  |  156|  12.6k|   : 0)
  ------------------
  142|       |
  143|       |  /* Allocate from current block. */
  144|  12.6k|  ptr = mem->ptr;
  145|  12.6k|  mem->ptr += size;
  146|  12.6k|  mem->n -= size;
  147|       |
  148|       |  /* Set to zero if needed. */
  149|  12.6k|  if (zero)
  ------------------
  |  Branch (149:7): [True: 10.5k, False: 2.10k]
  ------------------
  150|  10.5k|    memset(ptr, 0, size);
  151|       |
  152|  12.6k|  return ptr;
  153|  12.6k|}

tre_parse:
  967|    206|{
  968|    206|  tre_ast_node_t *result = NULL;
  969|    206|  tre_parse_re_stack_symbol_t symbol;
  970|    206|  reg_errcode_t status = REG_OK;
  971|    206|  tre_stack_t *stack = ctx->stack;
  972|    206|  int bottom = tre_stack_num_objects(stack);
  973|    206|  int depth = 0;
  974|    206|  int temporary_cflags = 0;
  975|       |
  976|    206|  DPRINT(("tre_parse: parsing '%.*" STRF "', len = %d\n",
  ------------------
  |  |   27|    206|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 206]
  |  |  ------------------
  ------------------
  977|    206|	  ctx->len, ctx->re, ctx->len));
  978|       |
  979|    206|  if (!ctx->nofirstsub)
  ------------------
  |  Branch (979:7): [True: 206, False: 0]
  ------------------
  980|    206|    {
  981|    206|      STACK_PUSH(stack, int, ctx->submatch_id);
  ------------------
  |  |   53|    206|  do									      \
  |  |   54|    206|    {									      \
  |  |   55|    206|      status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   56|    206|    }									      \
  |  |   57|    206|  while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (57:23): [Folded, False: 206]
  |  |  ------------------
  ------------------
  982|    206|      STACK_PUSH(stack, int, PARSE_MARK_FOR_SUBMATCH);
  ------------------
  |  |   53|    206|  do									      \
  |  |   54|    206|    {									      \
  |  |   55|    206|      status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   56|    206|    }									      \
  |  |   57|    206|  while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (57:23): [Folded, False: 206]
  |  |  ------------------
  ------------------
  983|    206|      ctx->submatch_id++;
  984|    206|    }
  985|    206|  STACK_PUSH(stack, int, PARSE_RE);
  ------------------
  |  |   53|    206|  do									      \
  |  |   54|    206|    {									      \
  |  |   55|    206|      status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   56|    206|    }									      \
  |  |   57|    206|  while (/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (57:23): [Folded, False: 206]
  |  |  ------------------
  ------------------
  986|    206|  ctx->re_start = ctx->re;
  987|    206|  ctx->re_end = ctx->re + ctx->len;
  988|       |
  989|       |
  990|       |  /* The following is basically just a recursive descent parser.  I use
  991|       |     an explicit stack instead of recursive functions mostly because of
  992|       |     two reasons: compatibility with systems which have an overflowable
  993|       |     call stack, and efficiency (both in lines of code and speed).  */
  994|  6.95k|  while (tre_stack_num_objects(stack) > bottom && status == REG_OK)
  ------------------
  |  Branch (994:10): [True: 6.75k, False: 206]
  |  Branch (994:51): [True: 6.75k, False: 0]
  ------------------
  995|  6.75k|    {
  996|  6.75k|      if (status != REG_OK)
  ------------------
  |  Branch (996:11): [True: 0, False: 6.75k]
  ------------------
  997|      0|	break;
  998|  6.75k|      symbol = tre_stack_pop_int(stack);
  999|  6.75k|      switch (symbol)
 1000|  6.75k|	{
 1001|    371|	case PARSE_RE:
  ------------------
  |  Branch (1001:2): [True: 371, False: 6.37k]
  ------------------
 1002|       |	  /* Parse a full regexp.  A regexp is one or more branches,
 1003|       |	     separated by the union operator `|'. */
 1004|    371|#ifdef REG_LITERAL
 1005|    371|	  if (!(ctx->cflags & REG_LITERAL)
  ------------------
  |  |  105|    371|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  ------------------
  |  |  |  |  101|    371|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|    371|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   99|    371|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   98|    371|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1005:8): [True: 371, False: 0]
  ------------------
 1006|    371|	      && ctx->cflags & REG_EXTENDED)
  ------------------
  |  |   98|    371|#define REG_EXTENDED	1
  ------------------
  |  Branch (1006:11): [True: 371, False: 0]
  ------------------
 1007|    371|#endif /* REG_LITERAL */
 1008|    371|	    STACK_PUSHX(stack, int, PARSE_UNION);
  ------------------
  |  |   60|    371|  {									      \
  |  |   61|    371|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    371|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 371]
  |  |  ------------------
  |  |   63|    371|      break;								      \
  |  |   64|    371|  }
  ------------------
 1009|    371|	  STACK_PUSHX(stack, int, PARSE_BRANCH);
  ------------------
  |  |   60|    371|  {									      \
  |  |   61|    371|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    371|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 371]
  |  |  ------------------
  |  |   63|    371|      break;								      \
  |  |   64|    371|  }
  ------------------
 1010|    371|	  break;
 1011|       |
 1012|    400|	case PARSE_BRANCH:
  ------------------
  |  Branch (1012:2): [True: 400, False: 6.35k]
  ------------------
 1013|       |	  /* Parse a branch.  A branch is one or more pieces, concatenated.
 1014|       |	     A piece is an atom possibly followed by a postfix operator. */
 1015|    400|	  STACK_PUSHX(stack, int, PARSE_CATENATION);
  ------------------
  |  |   60|    400|  {									      \
  |  |   61|    400|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    400|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 400]
  |  |  ------------------
  |  |   63|    400|      break;								      \
  |  |   64|    400|  }
  ------------------
 1016|    400|	  STACK_PUSHX(stack, int, PARSE_PIECE);
  ------------------
  |  |   60|    400|  {									      \
  |  |   61|    400|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    400|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 400]
  |  |  ------------------
  |  |   63|    400|      break;								      \
  |  |   64|    400|  }
  ------------------
 1017|    400|	  break;
 1018|       |
 1019|  1.07k|	case PARSE_PIECE:
  ------------------
  |  Branch (1019:2): [True: 1.07k, False: 5.67k]
  ------------------
 1020|       |	  /* Parse a piece.  A piece is an atom possibly followed by one
 1021|       |	     or more postfix operators. */
 1022|  1.07k|#ifdef REG_LITERAL
 1023|  1.07k|	  if (!(ctx->cflags & REG_LITERAL))
  ------------------
  |  |  105|  1.07k|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  ------------------
  |  |  |  |  101|  1.07k|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|  1.07k|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   99|  1.07k|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   98|  1.07k|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1023:8): [True: 1.07k, False: 0]
  ------------------
 1024|  1.07k|#endif /* REG_LITERAL */
 1025|  1.07k|	    STACK_PUSHX(stack, int, PARSE_POSTFIX);
  ------------------
  |  |   60|  1.07k|  {									      \
  |  |   61|  1.07k|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|  1.07k|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 1.07k]
  |  |  ------------------
  |  |   63|  1.07k|      break;								      \
  |  |   64|  1.07k|  }
  ------------------
 1026|  1.07k|	  STACK_PUSHX(stack, int, PARSE_ATOM);
  ------------------
  |  |   60|  1.07k|  {									      \
  |  |   61|  1.07k|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|  1.07k|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 1.07k]
  |  |  ------------------
  |  |   63|  1.07k|      break;								      \
  |  |   64|  1.07k|  }
  ------------------
 1027|  1.07k|	  break;
 1028|       |
 1029|  1.07k|	case PARSE_CATENATION:
  ------------------
  |  Branch (1029:2): [True: 1.07k, False: 5.67k]
  ------------------
 1030|       |	  /* If the expression has not ended, parse another piece. */
 1031|  1.07k|	  {
 1032|  1.07k|	    tre_char_t c;
 1033|  1.07k|	    if (ctx->re >= ctx->re_end)
  ------------------
  |  Branch (1033:10): [True: 206, False: 866]
  ------------------
 1034|    206|	      break;
 1035|    866|	    c = *ctx->re;
 1036|    866|#ifdef REG_LITERAL
 1037|    866|	    if (!(ctx->cflags & REG_LITERAL))
  ------------------
  |  |  105|    866|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  ------------------
  |  |  |  |  101|    866|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|    866|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   99|    866|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   98|    866|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1037:10): [True: 866, False: 0]
  ------------------
 1038|    866|	      {
 1039|    866|#endif /* REG_LITERAL */
 1040|    866|		if (ctx->cflags & REG_EXTENDED && c == CHAR_PIPE)
  ------------------
  |  |   98|  1.73k|#define REG_EXTENDED	1
  ------------------
              		if (ctx->cflags & REG_EXTENDED && c == CHAR_PIPE)
  ------------------
  |  |   32|    866|#define CHAR_PIPE	   L'|'
  ------------------
  |  Branch (1040:7): [True: 866, False: 0]
  |  Branch (1040:37): [True: 29, False: 837]
  ------------------
 1041|     29|		  break;
 1042|    837|		if ((ctx->cflags & REG_EXTENDED
  ------------------
  |  |   98|  1.67k|#define REG_EXTENDED	1
  ------------------
  |  Branch (1042:8): [True: 837, False: 0]
  ------------------
 1043|    837|		     && c == CHAR_RPAREN && depth > 0)
  ------------------
  |  |   34|  1.67k|#define CHAR_RPAREN	   L')'
  ------------------
  |  Branch (1043:11): [True: 165, False: 672]
  |  Branch (1043:31): [True: 165, False: 0]
  ------------------
 1044|    672|		    || (!(ctx->cflags & REG_EXTENDED)
  ------------------
  |  |   98|    672|#define REG_EXTENDED	1
  ------------------
  |  Branch (1044:11): [True: 0, False: 672]
  ------------------
 1045|      0|			&& (c == CHAR_BACKSLASH
  ------------------
  |  |   49|      0|#define CHAR_BACKSLASH	   L'\\'
  ------------------
  |  Branch (1045:8): [True: 0, False: 0]
  ------------------
 1046|      0|			    && ctx->re + 1 < ctx->re_end
  ------------------
  |  Branch (1046:11): [True: 0, False: 0]
  ------------------
 1047|      0|			    && *(ctx->re + 1) == CHAR_RPAREN)))
  ------------------
  |  |   34|      0|#define CHAR_RPAREN	   L')'
  ------------------
  |  Branch (1047:11): [True: 0, False: 0]
  ------------------
 1048|    165|		  {
 1049|    165|		    if (!(ctx->cflags & REG_EXTENDED) && depth == 0)
  ------------------
  |  |   98|    165|#define REG_EXTENDED	1
  ------------------
  |  Branch (1049:11): [True: 0, False: 165]
  |  Branch (1049:44): [True: 0, False: 0]
  ------------------
 1050|      0|		      status = REG_EPAREN;
 1051|    165|		    DPRINT(("tre_parse:	  group end: '%.*" STRF "'\n",
  ------------------
  |  |   27|    165|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 165]
  |  |  ------------------
  ------------------
 1052|    165|			    REST(ctx->re)));
 1053|    165|		    depth--;
 1054|    165|		    if (!(ctx->cflags & REG_EXTENDED))
  ------------------
  |  |   98|    165|#define REG_EXTENDED	1
  ------------------
  |  Branch (1054:11): [True: 0, False: 165]
  ------------------
 1055|      0|		      ctx->re += 2;
 1056|    165|		    break;
 1057|    165|		  }
 1058|    837|#ifdef REG_LITERAL
 1059|    837|	      }
 1060|    672|#endif /* REG_LITERAL */
 1061|       |
 1062|    672|#ifdef REG_RIGHT_ASSOC
 1063|    672|	    if (ctx->cflags & REG_RIGHT_ASSOC)
  ------------------
  |  |  106|    672|#define REG_RIGHT_ASSOC (REG_LITERAL << 1)
  |  |  ------------------
  |  |  |  |  105|    672|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  101|    672|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  100|    672|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   99|    672|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   98|    672|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1063:10): [True: 0, False: 672]
  ------------------
 1064|      0|	      {
 1065|       |		/* Right associative concatenation. */
 1066|      0|		STACK_PUSHX(stack, voidptr, result);
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1067|      0|		STACK_PUSHX(stack, int, PARSE_POST_CATENATION);
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1068|      0|		STACK_PUSHX(stack, int, PARSE_CATENATION);
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1069|      0|		STACK_PUSHX(stack, int, PARSE_PIECE);
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1070|      0|	      }
 1071|    672|	    else
 1072|    672|#endif /* REG_RIGHT_ASSOC */
 1073|    672|	      {
 1074|       |		/* Default case, left associative concatenation. */
 1075|    672|		STACK_PUSHX(stack, int, PARSE_CATENATION);
  ------------------
  |  |   60|    672|  {									      \
  |  |   61|    672|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    672|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 672]
  |  |  ------------------
  |  |   63|    672|      break;								      \
  |  |   64|    672|  }
  ------------------
 1076|    672|		STACK_PUSHX(stack, voidptr, result);
  ------------------
  |  |   60|    672|  {									      \
  |  |   61|    672|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    672|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 672]
  |  |  ------------------
  |  |   63|    672|      break;								      \
  |  |   64|    672|  }
  ------------------
 1077|    672|		STACK_PUSHX(stack, int, PARSE_POST_CATENATION);
  ------------------
  |  |   60|    672|  {									      \
  |  |   61|    672|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    672|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 672]
  |  |  ------------------
  |  |   63|    672|      break;								      \
  |  |   64|    672|  }
  ------------------
 1078|    672|		STACK_PUSHX(stack, int, PARSE_PIECE);
  ------------------
  |  |   60|    672|  {									      \
  |  |   61|    672|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    672|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 672]
  |  |  ------------------
  |  |   63|    672|      break;								      \
  |  |   64|    672|  }
  ------------------
 1079|    672|	      }
 1080|    672|	    break;
 1081|    672|	  }
 1082|       |
 1083|    672|	case PARSE_POST_CATENATION:
  ------------------
  |  Branch (1083:2): [True: 672, False: 6.07k]
  ------------------
 1084|    672|	  {
 1085|    672|	    tre_ast_node_t *tree = tre_stack_pop_voidptr(stack);
 1086|    672|	    tre_ast_node_t *tmp_node;
 1087|    672|	    tmp_node = tre_ast_new_catenation(ctx->mem, tree, result);
 1088|    672|	    if (!tmp_node)
  ------------------
  |  Branch (1088:10): [True: 0, False: 672]
  ------------------
 1089|      0|	      return REG_ESPACE;
 1090|    672|	    result = tmp_node;
 1091|    672|	    break;
 1092|    672|	  }
 1093|       |
 1094|    400|	case PARSE_UNION:
  ------------------
  |  Branch (1094:2): [True: 400, False: 6.35k]
  ------------------
 1095|    400|	  if (ctx->re >= ctx->re_end)
  ------------------
  |  Branch (1095:8): [True: 206, False: 194]
  ------------------
 1096|    206|	    break;
 1097|    194|#ifdef REG_LITERAL
 1098|    194|	  if (ctx->cflags & REG_LITERAL)
  ------------------
  |  |  105|    194|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  ------------------
  |  |  |  |  101|    194|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|    194|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   99|    194|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   98|    194|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1098:8): [True: 0, False: 194]
  ------------------
 1099|      0|	    break;
 1100|    194|#endif /* REG_LITERAL */
 1101|    194|	  switch (*ctx->re)
 1102|    194|	    {
 1103|     29|	    case CHAR_PIPE:
  ------------------
  |  |   32|     29|#define CHAR_PIPE	   L'|'
  ------------------
  |  Branch (1103:6): [True: 29, False: 165]
  ------------------
 1104|     29|	      DPRINT(("tre_parse:	union: '%.*" STRF "'\n",
  ------------------
  |  |   27|     29|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 29]
  |  |  ------------------
  ------------------
 1105|     29|		      REST(ctx->re)));
 1106|     29|	      STACK_PUSHX(stack, int, PARSE_UNION);
  ------------------
  |  |   60|     29|  {									      \
  |  |   61|     29|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|     29|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 29]
  |  |  ------------------
  |  |   63|     29|      break;								      \
  |  |   64|     29|  }
  ------------------
 1107|     29|	      STACK_PUSHX(stack, voidptr, result);
  ------------------
  |  |   60|     29|  {									      \
  |  |   61|     29|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|     29|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 29]
  |  |  ------------------
  |  |   63|     29|      break;								      \
  |  |   64|     29|  }
  ------------------
 1108|     29|	      STACK_PUSHX(stack, int, PARSE_POST_UNION);
  ------------------
  |  |   60|     29|  {									      \
  |  |   61|     29|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|     29|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 29]
  |  |  ------------------
  |  |   63|     29|      break;								      \
  |  |   64|     29|  }
  ------------------
 1109|     29|	      STACK_PUSHX(stack, int, PARSE_BRANCH);
  ------------------
  |  |   60|     29|  {									      \
  |  |   61|     29|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|     29|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 29]
  |  |  ------------------
  |  |   63|     29|      break;								      \
  |  |   64|     29|  }
  ------------------
 1110|     29|	      ctx->re++;
 1111|     29|	      break;
 1112|       |
 1113|    165|	    case CHAR_RPAREN:
  ------------------
  |  |   34|    165|#define CHAR_RPAREN	   L')'
  ------------------
  |  Branch (1113:6): [True: 165, False: 29]
  ------------------
 1114|    165|	      ctx->re++;
 1115|    165|	      break;
 1116|       |
 1117|      0|	    default:
  ------------------
  |  Branch (1117:6): [True: 0, False: 194]
  ------------------
 1118|      0|	      break;
 1119|    194|	    }
 1120|    194|	  break;
 1121|       |
 1122|    194|	case PARSE_POST_UNION:
  ------------------
  |  Branch (1122:2): [True: 29, False: 6.72k]
  ------------------
 1123|     29|	  {
 1124|     29|	    tre_ast_node_t *tmp_node;
 1125|     29|	    tre_ast_node_t *tree = tre_stack_pop_voidptr(stack);
 1126|     29|	    tmp_node = tre_ast_new_union(ctx->mem, tree, result);
 1127|     29|	    if (!tmp_node)
  ------------------
  |  Branch (1127:10): [True: 0, False: 29]
  ------------------
 1128|      0|	      return REG_ESPACE;
 1129|     29|	    result = tmp_node;
 1130|     29|	    break;
 1131|     29|	  }
 1132|       |
 1133|  1.29k|	case PARSE_POSTFIX:
  ------------------
  |  Branch (1133:2): [True: 1.29k, False: 5.45k]
  ------------------
 1134|       |	  /* Parse postfix operators. */
 1135|  1.29k|	  if (ctx->re >= ctx->re_end)
  ------------------
  |  Branch (1135:8): [True: 206, False: 1.08k]
  ------------------
 1136|    206|	    break;
 1137|  1.08k|#ifdef REG_LITERAL
 1138|  1.08k|	  if (ctx->cflags & REG_LITERAL)
  ------------------
  |  |  105|  1.08k|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  ------------------
  |  |  |  |  101|  1.08k|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|  1.08k|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   99|  1.08k|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   98|  1.08k|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1138:8): [True: 0, False: 1.08k]
  ------------------
 1139|      0|	    break;
 1140|  1.08k|#endif /* REG_LITERAL */
 1141|  1.08k|	  switch (*ctx->re)
  ------------------
  |  Branch (1141:12): [True: 271, False: 814]
  ------------------
 1142|  1.08k|	    {
 1143|    129|	    case CHAR_PLUS:
  ------------------
  |  |   42|    129|#define CHAR_PLUS	   L'+'
  ------------------
  |  Branch (1143:6): [True: 129, False: 956]
  ------------------
 1144|    129|	    case CHAR_QUESTIONMARK:
  ------------------
  |  |   41|    129|#define CHAR_QUESTIONMARK  L'?'
  ------------------
  |  Branch (1144:6): [True: 0, False: 1.08k]
  ------------------
 1145|    129|	      if (!(ctx->cflags & REG_EXTENDED))
  ------------------
  |  |   98|    129|#define REG_EXTENDED	1
  ------------------
  |  Branch (1145:12): [True: 0, False: 129]
  ------------------
 1146|      0|		break;
 1147|       |		/*FALLTHROUGH*/
 1148|    219|	    case CHAR_STAR:
  ------------------
  |  |   40|    219|#define CHAR_STAR	   L'*'
  ------------------
  |  Branch (1148:6): [True: 90, False: 995]
  ------------------
 1149|    219|	      {
 1150|    219|		tre_ast_node_t *tmp_node;
 1151|    219|		int minimal = (ctx->cflags & REG_UNGREEDY) ? 1 : 0;
  ------------------
  |  |  107|    219|#define REG_UNGREEDY    (REG_RIGHT_ASSOC << 1)
  |  |  ------------------
  |  |  |  |  106|    219|#define REG_RIGHT_ASSOC (REG_LITERAL << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|    219|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  101|    219|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  100|    219|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   99|    219|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   98|    219|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1151:17): [True: 0, False: 219]
  ------------------
 1152|    219|		int rep_min = 0;
 1153|    219|		int rep_max = -1;
 1154|       |#ifdef TRE_DEBUG
 1155|       |		const tre_char_t *tmp_re;
 1156|       |#endif
 1157|       |
 1158|    219|		if (*ctx->re == CHAR_PLUS)
  ------------------
  |  |   42|    219|#define CHAR_PLUS	   L'+'
  ------------------
  |  Branch (1158:7): [True: 129, False: 90]
  ------------------
 1159|    129|		  rep_min = 1;
 1160|    219|		if (*ctx->re == CHAR_QUESTIONMARK)
  ------------------
  |  |   41|    219|#define CHAR_QUESTIONMARK  L'?'
  ------------------
  |  Branch (1160:7): [True: 0, False: 219]
  ------------------
 1161|      0|		  rep_max = 1;
 1162|       |#ifdef TRE_DEBUG
 1163|       |		tmp_re = ctx->re;
 1164|       |#endif
 1165|       |
 1166|    219|		if (ctx->re + 1 < ctx->re_end)
  ------------------
  |  Branch (1166:7): [True: 217, False: 2]
  ------------------
 1167|    217|		  {
 1168|    217|		    if (*(ctx->re + 1) == CHAR_QUESTIONMARK)
  ------------------
  |  |   41|    217|#define CHAR_QUESTIONMARK  L'?'
  ------------------
  |  Branch (1168:11): [True: 0, False: 217]
  ------------------
 1169|      0|		      {
 1170|      0|			minimal = !(ctx->cflags & REG_UNGREEDY);
  ------------------
  |  |  107|      0|#define REG_UNGREEDY    (REG_RIGHT_ASSOC << 1)
  |  |  ------------------
  |  |  |  |  106|      0|#define REG_RIGHT_ASSOC (REG_LITERAL << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|      0|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  101|      0|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  100|      0|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1171|      0|			ctx->re++;
 1172|      0|		      }
 1173|    217|		    else if (*(ctx->re + 1) == CHAR_STAR
  ------------------
  |  |   40|    434|#define CHAR_STAR	   L'*'
  ------------------
  |  Branch (1173:16): [True: 0, False: 217]
  ------------------
 1174|    217|			     || *(ctx->re + 1) == CHAR_PLUS)
  ------------------
  |  |   42|    217|#define CHAR_PLUS	   L'+'
  ------------------
  |  Branch (1174:12): [True: 0, False: 217]
  ------------------
 1175|      0|		      {
 1176|       |			/* These are reserved for future extensions. */
 1177|      0|			return REG_BADRPT;
 1178|      0|		      }
 1179|    217|		  }
 1180|       |
 1181|    219|		DPRINT(("tre_parse: %s star: '%.*" STRF "'\n",
  ------------------
  |  |   27|    219|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 219]
  |  |  ------------------
  ------------------
 1182|    219|			minimal ? "  minimal" : "greedy", REST(tmp_re)));
 1183|    219|		ctx->re++;
 1184|    219|		tmp_node = tre_ast_new_iter(ctx->mem, result, rep_min, rep_max,
 1185|    219|					    minimal);
 1186|    219|		if (tmp_node == NULL)
  ------------------
  |  Branch (1186:7): [True: 0, False: 219]
  ------------------
 1187|      0|		  return REG_ESPACE;
 1188|    219|		result = tmp_node;
 1189|    219|		STACK_PUSHX(stack, int, PARSE_POSTFIX);
  ------------------
  |  |   60|    219|  {									      \
  |  |   61|    219|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    219|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 219]
  |  |  ------------------
  |  |   63|    219|      break;								      \
  |  |   64|    219|  }
  ------------------
 1190|    219|	      }
 1191|      0|	      break;
 1192|       |
 1193|     52|	    case CHAR_BACKSLASH:
  ------------------
  |  |   49|     52|#define CHAR_BACKSLASH	   L'\\'
  ------------------
  |  Branch (1193:6): [True: 52, False: 1.03k]
  ------------------
 1194|       |	      /* "\{" is special without REG_EXTENDED */
 1195|     52|	      if (!(ctx->cflags & REG_EXTENDED)
  ------------------
  |  |   98|     52|#define REG_EXTENDED	1
  ------------------
  |  Branch (1195:12): [True: 0, False: 52]
  ------------------
 1196|      0|		  && ctx->re + 1 < ctx->re_end
  ------------------
  |  Branch (1196:8): [True: 0, False: 0]
  ------------------
 1197|      0|		  && *(ctx->re + 1) == CHAR_LBRACE)
  ------------------
  |  |   35|      0|#define CHAR_LBRACE	   L'{'
  ------------------
  |  Branch (1197:8): [True: 0, False: 0]
  ------------------
 1198|      0|		{
 1199|      0|		  ctx->re++;
 1200|      0|		  goto parse_brace;
 1201|      0|		}
 1202|     52|	      else
 1203|     52|		break;
 1204|       |
 1205|      0|	    case CHAR_LBRACE:
  ------------------
  |  |   35|      0|#define CHAR_LBRACE	   L'{'
  ------------------
  |  Branch (1205:6): [True: 0, False: 1.08k]
  ------------------
 1206|       |	      /* "{" is literal without REG_EXTENDED */
 1207|      0|	      if (!(ctx->cflags & REG_EXTENDED))
  ------------------
  |  |   98|      0|#define REG_EXTENDED	1
  ------------------
  |  Branch (1207:12): [True: 0, False: 0]
  ------------------
 1208|      0|		break;
 1209|       |
 1210|      0|	    parse_brace:
 1211|      0|	      DPRINT(("tre_parse:	bound: '%.*" STRF "'\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1212|      0|		      REST(ctx->re)));
 1213|      0|	      ctx->re++;
 1214|       |
 1215|      0|	      status = tre_parse_bound(ctx, &result);
 1216|      0|	      if (status != REG_OK)
  ------------------
  |  Branch (1216:12): [True: 0, False: 0]
  ------------------
 1217|      0|		return status;
 1218|      0|	      STACK_PUSHX(stack, int, PARSE_POSTFIX);
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1219|      0|	      break;
 1220|  1.08k|	    }
 1221|  1.08k|	  break;
 1222|       |
 1223|  1.08k|	case PARSE_ATOM:
  ------------------
  |  Branch (1223:2): [True: 1.07k, False: 5.67k]
  ------------------
 1224|       |	  /* Parse an atom.  An atom is a regular expression enclosed in `()',
 1225|       |	     an empty set of `()', a bracket expression, `.', `^', `$',
 1226|       |	     a `\' followed by a character, or a single character. */
 1227|       |
 1228|       |	  /* End of regexp? (empty string). */
 1229|  1.07k|	  if (ctx->re >= ctx->re_end)
  ------------------
  |  Branch (1229:8): [True: 0, False: 1.07k]
  ------------------
 1230|      0|	    goto parse_literal;
 1231|       |
 1232|  1.07k|#ifdef REG_LITERAL
 1233|  1.07k|	  if (ctx->cflags & REG_LITERAL)
  ------------------
  |  |  105|  1.07k|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  ------------------
  |  |  |  |  101|  1.07k|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|  1.07k|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   99|  1.07k|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   98|  1.07k|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1233:8): [True: 0, False: 1.07k]
  ------------------
 1234|      0|	    goto parse_literal;
 1235|  1.07k|#endif /* REG_LITERAL */
 1236|       |
 1237|  1.07k|	  switch (*ctx->re)
 1238|  1.07k|	    {
 1239|    165|	    case CHAR_LPAREN:  /* parenthesized subexpression */
  ------------------
  |  |   33|    165|#define CHAR_LPAREN	   L'('
  ------------------
  |  Branch (1239:6): [True: 165, False: 907]
  ------------------
 1240|       |
 1241|       |	      /* Handle "(?...)" extensions.  They work in a way similar
 1242|       |		 to Perls corresponding extensions. */
 1243|    165|	      if (ctx->cflags & REG_EXTENDED
  ------------------
  |  |   98|    330|#define REG_EXTENDED	1
  ------------------
  |  Branch (1243:12): [True: 165, False: 0]
  ------------------
 1244|    165|		  && ctx->re + 1 < ctx->re_end
  ------------------
  |  Branch (1244:8): [True: 165, False: 0]
  ------------------
 1245|    165|		  && *(ctx->re + 1) == CHAR_QUESTIONMARK)
  ------------------
  |  |   41|    165|#define CHAR_QUESTIONMARK  L'?'
  ------------------
  |  Branch (1245:8): [True: 0, False: 165]
  ------------------
 1246|      0|		{
 1247|      0|		  int new_cflags = ctx->cflags;
 1248|      0|		  int bit = 1;
 1249|      0|		  DPRINT(("tre_parse:	extension: '%.*" STRF "\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1250|      0|			  REST(ctx->re)));
 1251|      0|		  ctx->re += 2;
 1252|      0|		  while (/*CONSTCOND*/(void)1,1)
  ------------------
  |  Branch (1252:25): [True: 0, Folded]
  ------------------
 1253|      0|		    {
 1254|      0|		      if (ctx->re >= ctx->re_end)
  ------------------
  |  Branch (1254:13): [True: 0, False: 0]
  ------------------
 1255|      0|			return REG_BADPAT;
 1256|      0|		      if (*ctx->re == L'i')
  ------------------
  |  Branch (1256:13): [True: 0, False: 0]
  ------------------
 1257|      0|			{
 1258|      0|			  DPRINT(("tre_parse:	    icase: '%.*" STRF "\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1259|      0|				  REST(ctx->re)));
 1260|      0|			  if (bit)
  ------------------
  |  Branch (1260:10): [True: 0, False: 0]
  ------------------
 1261|      0|			    new_cflags |= REG_ICASE;
  ------------------
  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  ------------------
  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  ------------------
  ------------------
 1262|      0|			  else
 1263|      0|			    new_cflags &= ~REG_ICASE;
  ------------------
  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  ------------------
  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  ------------------
  ------------------
 1264|      0|			  ctx->re++;
 1265|      0|			}
 1266|      0|		      else if (*ctx->re == L'n')
  ------------------
  |  Branch (1266:18): [True: 0, False: 0]
  ------------------
 1267|      0|			{
 1268|      0|			  DPRINT(("tre_parse:	  newline: '%.*" STRF "\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1269|      0|				  REST(ctx->re)));
 1270|      0|			  if (bit)
  ------------------
  |  Branch (1270:10): [True: 0, False: 0]
  ------------------
 1271|      0|			    new_cflags |= REG_NEWLINE;
  ------------------
  |  |  100|      0|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  ------------------
  |  |  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1272|      0|			  else
 1273|      0|			    new_cflags &= ~REG_NEWLINE;
  ------------------
  |  |  100|      0|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  ------------------
  |  |  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1274|      0|			  ctx->re++;
 1275|      0|			}
 1276|      0|#ifdef REG_RIGHT_ASSOC
 1277|      0|		      else if (*ctx->re == L'r')
  ------------------
  |  Branch (1277:18): [True: 0, False: 0]
  ------------------
 1278|      0|			{
 1279|      0|			  DPRINT(("tre_parse: right assoc: '%.*" STRF "\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1280|      0|				  REST(ctx->re)));
 1281|      0|			  if (bit)
  ------------------
  |  Branch (1281:10): [True: 0, False: 0]
  ------------------
 1282|      0|			    new_cflags |= REG_RIGHT_ASSOC;
  ------------------
  |  |  106|      0|#define REG_RIGHT_ASSOC (REG_LITERAL << 1)
  |  |  ------------------
  |  |  |  |  105|      0|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  101|      0|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  100|      0|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1283|      0|			  else
 1284|      0|			    new_cflags &= ~REG_RIGHT_ASSOC;
  ------------------
  |  |  106|      0|#define REG_RIGHT_ASSOC (REG_LITERAL << 1)
  |  |  ------------------
  |  |  |  |  105|      0|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  101|      0|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  100|      0|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1285|      0|			  ctx->re++;
 1286|      0|			}
 1287|      0|#endif /* REG_RIGHT_ASSOC */
 1288|      0|#ifdef REG_UNGREEDY
 1289|      0|		      else if (*ctx->re == L'U')
  ------------------
  |  Branch (1289:18): [True: 0, False: 0]
  ------------------
 1290|      0|			{
 1291|      0|			  DPRINT(("tre_parse:    ungreedy: '%.*" STRF "\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1292|      0|				  REST(ctx->re)));
 1293|      0|			  if (bit)
  ------------------
  |  Branch (1293:10): [True: 0, False: 0]
  ------------------
 1294|      0|			    new_cflags |= REG_UNGREEDY;
  ------------------
  |  |  107|      0|#define REG_UNGREEDY    (REG_RIGHT_ASSOC << 1)
  |  |  ------------------
  |  |  |  |  106|      0|#define REG_RIGHT_ASSOC (REG_LITERAL << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|      0|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  101|      0|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  100|      0|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1295|      0|			  else
 1296|      0|			    new_cflags &= ~REG_UNGREEDY;
  ------------------
  |  |  107|      0|#define REG_UNGREEDY    (REG_RIGHT_ASSOC << 1)
  |  |  ------------------
  |  |  |  |  106|      0|#define REG_RIGHT_ASSOC (REG_LITERAL << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|      0|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  101|      0|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  100|      0|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1297|      0|			  ctx->re++;
 1298|      0|			}
 1299|      0|#endif /* REG_UNGREEDY */
 1300|      0|		      else if (*ctx->re == CHAR_MINUS)
  ------------------
  |  |   39|      0|#define CHAR_MINUS	   L'-'
  ------------------
  |  Branch (1300:18): [True: 0, False: 0]
  ------------------
 1301|      0|			{
 1302|      0|			  DPRINT(("tre_parse:	 turn off: '%.*" STRF "\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1303|      0|				  REST(ctx->re)));
 1304|      0|			  ctx->re++;
 1305|      0|			  bit = 0;
 1306|      0|			}
 1307|      0|		      else if (*ctx->re == CHAR_COLON)
  ------------------
  |  |   44|      0|#define CHAR_COLON	   L':'
  ------------------
  |  Branch (1307:18): [True: 0, False: 0]
  ------------------
 1308|      0|			{
 1309|      0|			  DPRINT(("tre_parse:	 no group: '%.*" STRF "\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1310|      0|				  REST(ctx->re)));
 1311|      0|			  ctx->re++;
 1312|      0|			  depth++;
 1313|      0|			  break;
 1314|      0|			}
 1315|      0|		      else if (*ctx->re == CHAR_HASH)
  ------------------
  |  |   50|      0|#define CHAR_HASH	   L'#'
  ------------------
  |  Branch (1315:18): [True: 0, False: 0]
  ------------------
 1316|      0|			{
 1317|      0|			  DPRINT(("tre_parse:    comment: '%.*" STRF "\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1318|      0|				  REST(ctx->re)));
 1319|       |			  /* A comment can contain any character except a
 1320|       |			     right parenthesis */
 1321|      0|			  while (ctx->re < ctx->re_end
  ------------------
  |  Branch (1321:13): [True: 0, False: 0]
  ------------------
 1322|      0|				 && *ctx->re != CHAR_RPAREN)
  ------------------
  |  |   34|      0|#define CHAR_RPAREN	   L')'
  ------------------
  |  Branch (1322:9): [True: 0, False: 0]
  ------------------
 1323|      0|			    ctx->re++;
 1324|      0|			  if (ctx->re < ctx->re_end && *ctx->re == CHAR_RPAREN)
  ------------------
  |  |   34|      0|#define CHAR_RPAREN	   L')'
  ------------------
  |  Branch (1324:10): [True: 0, False: 0]
  |  Branch (1324:35): [True: 0, False: 0]
  ------------------
 1325|      0|			    {
 1326|      0|			      ctx->re++;
 1327|      0|			      break;
 1328|      0|			    }
 1329|      0|			  else
 1330|      0|			    return REG_BADPAT;
 1331|      0|			}
 1332|      0|		      else if (*ctx->re == CHAR_RPAREN)
  ------------------
  |  |   34|      0|#define CHAR_RPAREN	   L')'
  ------------------
  |  Branch (1332:18): [True: 0, False: 0]
  ------------------
 1333|      0|			{
 1334|      0|			  ctx->re++;
 1335|      0|			  break;
 1336|      0|			}
 1337|      0|		      else
 1338|      0|			return REG_BADPAT;
 1339|      0|		    }
 1340|       |
 1341|       |		  /* Turn on the cflags changes for the rest of the
 1342|       |		     enclosing group. */
 1343|      0|		  STACK_PUSHX(stack, int, ctx->cflags);
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1344|      0|		  STACK_PUSHX(stack, int, PARSE_RESTORE_CFLAGS);
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1345|      0|		  STACK_PUSHX(stack, int, PARSE_RE);
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1346|      0|		  ctx->cflags = new_cflags;
 1347|      0|		  break;
 1348|      0|		}
 1349|       |
 1350|    165|	      if (ctx->cflags & REG_EXTENDED
  ------------------
  |  |   98|    330|#define REG_EXTENDED	1
  ------------------
  |  Branch (1350:12): [True: 165, False: 0]
  ------------------
 1351|      0|		  || (ctx->re > ctx->re_start
  ------------------
  |  Branch (1351:9): [True: 0, False: 0]
  ------------------
 1352|      0|		      && *(ctx->re - 1) == CHAR_BACKSLASH))
  ------------------
  |  |   49|      0|#define CHAR_BACKSLASH	   L'\\'
  ------------------
  |  Branch (1352:12): [True: 0, False: 0]
  ------------------
 1353|    165|		{
 1354|    165|		  depth++;
 1355|    165|		  if (ctx->re + 2 < ctx->re_end
  ------------------
  |  Branch (1355:9): [True: 165, False: 0]
  ------------------
 1356|    165|		      && *(ctx->re + 1) == CHAR_QUESTIONMARK
  ------------------
  |  |   41|    330|#define CHAR_QUESTIONMARK  L'?'
  ------------------
  |  Branch (1356:12): [True: 0, False: 165]
  ------------------
 1357|      0|		      && *(ctx->re + 2) == CHAR_COLON)
  ------------------
  |  |   44|      0|#define CHAR_COLON	   L':'
  ------------------
  |  Branch (1357:12): [True: 0, False: 0]
  ------------------
 1358|      0|		    {
 1359|      0|		      DPRINT(("tre_parse: group begin: '%.*" STRF
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1360|      0|			      "', no submatch\n", REST(ctx->re)));
 1361|       |		      /* Don't mark for submatching. */
 1362|      0|		      ctx->re += 3;
 1363|      0|		      STACK_PUSHX(stack, int, PARSE_RE);
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1364|      0|		    }
 1365|    165|		  else
 1366|    165|		    {
 1367|    165|		      DPRINT(("tre_parse: group begin: '%.*" STRF
  ------------------
  |  |   27|    165|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 165]
  |  |  ------------------
  ------------------
 1368|    165|			      "', submatch %d\n", REST(ctx->re),
 1369|    165|			      ctx->submatch_id));
 1370|    165|		      ctx->re++;
 1371|       |		      /* First parse a whole RE, then mark the resulting tree
 1372|       |			 for submatching. */
 1373|    165|		      STACK_PUSHX(stack, int, ctx->submatch_id);
  ------------------
  |  |   60|    165|  {									      \
  |  |   61|    165|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    165|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 165]
  |  |  ------------------
  |  |   63|    165|      break;								      \
  |  |   64|    165|  }
  ------------------
 1374|    165|		      STACK_PUSHX(stack, int, PARSE_MARK_FOR_SUBMATCH);
  ------------------
  |  |   60|    165|  {									      \
  |  |   61|    165|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    165|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 165]
  |  |  ------------------
  |  |   63|    165|      break;								      \
  |  |   64|    165|  }
  ------------------
 1375|    165|		      STACK_PUSHX(stack, int, PARSE_RE);
  ------------------
  |  |   60|    165|  {									      \
  |  |   61|    165|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|    165|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 165]
  |  |  ------------------
  |  |   63|    165|      break;								      \
  |  |   64|    165|  }
  ------------------
 1376|    165|		      ctx->submatch_id++;
 1377|    165|		    }
 1378|    165|		}
 1379|      0|	      else
 1380|      0|		goto parse_literal;
 1381|    165|	      break;
 1382|       |
 1383|    165|	    case CHAR_RPAREN:  /* end of current subexpression */
  ------------------
  |  |   34|      0|#define CHAR_RPAREN	   L')'
  ------------------
  |  Branch (1383:6): [True: 0, False: 1.07k]
  ------------------
 1384|      0|	      if ((ctx->cflags & REG_EXTENDED && depth > 0)
  ------------------
  |  |   98|      0|#define REG_EXTENDED	1
  ------------------
  |  Branch (1384:13): [True: 0, False: 0]
  |  Branch (1384:43): [True: 0, False: 0]
  ------------------
 1385|      0|		  || (!(ctx->cflags & REG_EXTENDED) && ctx->re > ctx->re_start
  ------------------
  |  |   98|      0|#define REG_EXTENDED	1
  ------------------
  |  Branch (1385:9): [True: 0, False: 0]
  |  Branch (1385:42): [True: 0, False: 0]
  ------------------
 1386|      0|		      && *(ctx->re - 1) == CHAR_BACKSLASH))
  ------------------
  |  |   49|      0|#define CHAR_BACKSLASH	   L'\\'
  ------------------
  |  Branch (1386:12): [True: 0, False: 0]
  ------------------
 1387|      0|		{
 1388|      0|		  DPRINT(("tre_parse:	    empty: '%.*" STRF "'\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1389|      0|			  REST(ctx->re)));
 1390|       |		  /* We were expecting an atom, but instead the current
 1391|       |		     subexpression was closed.	POSIX leaves the meaning of
 1392|       |		     this to be implementation-defined.	 We interpret this as
 1393|       |		     an empty expression (which matches an empty string).  */
 1394|      0|		  result = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
  ------------------
  |  |   26|      0|#define EMPTY	  -1   /* Empty leaf (denotes empty string). */
  ------------------
 1395|      0|		  if (result == NULL)
  ------------------
  |  Branch (1395:9): [True: 0, False: 0]
  ------------------
 1396|      0|		    return REG_ESPACE;
 1397|      0|		  if (!(ctx->cflags & REG_EXTENDED))
  ------------------
  |  |   98|      0|#define REG_EXTENDED	1
  ------------------
  |  Branch (1397:9): [True: 0, False: 0]
  ------------------
 1398|      0|		    ctx->re--;
 1399|      0|		}
 1400|      0|	      else
 1401|      0|		goto parse_literal;
 1402|      0|	      break;
 1403|       |
 1404|    259|	    case CHAR_LBRACKET: /* bracket expression */
  ------------------
  |  |   37|    259|#define CHAR_LBRACKET	   L'['
  ------------------
  |  Branch (1404:6): [True: 259, False: 813]
  ------------------
 1405|    259|	      DPRINT(("tre_parse:     bracket: '%.*" STRF "'\n",
  ------------------
  |  |   27|    259|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 259]
  |  |  ------------------
  ------------------
 1406|    259|		      REST(ctx->re)));
 1407|    259|	      ctx->re++;
 1408|    259|	      status = tre_parse_bracket(ctx, &result);
 1409|    259|	      if (status != REG_OK)
  ------------------
  |  Branch (1409:12): [True: 0, False: 259]
  ------------------
 1410|      0|		return status;
 1411|    259|	      break;
 1412|       |
 1413|    259|	    case CHAR_BACKSLASH:
  ------------------
  |  |   49|     56|#define CHAR_BACKSLASH	   L'\\'
  ------------------
  |  Branch (1413:6): [True: 56, False: 1.01k]
  ------------------
 1414|       |	      /* If this is "\(" or "\)" chew off the backslash and
 1415|       |		 try again. */
 1416|     56|	      if (!(ctx->cflags & REG_EXTENDED)
  ------------------
  |  |   98|     56|#define REG_EXTENDED	1
  ------------------
  |  Branch (1416:12): [True: 0, False: 56]
  ------------------
 1417|      0|		  && ctx->re + 1 < ctx->re_end
  ------------------
  |  Branch (1417:8): [True: 0, False: 0]
  ------------------
 1418|      0|		  && (*(ctx->re + 1) == CHAR_LPAREN
  ------------------
  |  |   33|      0|#define CHAR_LPAREN	   L'('
  ------------------
  |  Branch (1418:9): [True: 0, False: 0]
  ------------------
 1419|      0|		      || *(ctx->re + 1) == CHAR_RPAREN))
  ------------------
  |  |   34|      0|#define CHAR_RPAREN	   L')'
  ------------------
  |  Branch (1419:12): [True: 0, False: 0]
  ------------------
 1420|      0|		{
 1421|      0|		  ctx->re++;
 1422|      0|		  STACK_PUSHX(stack, int, PARSE_ATOM);
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1423|      0|		  break;
 1424|      0|		}
 1425|       |
 1426|       |	      /* If a macro is used, parse the expanded macro recursively. */
 1427|     56|	      {
 1428|     56|		tre_char_t buf[64];
 1429|     56|		tre_expand_macro(ctx->re + 1, ctx->re_end,
 1430|     56|				 buf, elementsof(buf));
  ------------------
  |  |   30|     56|#define elementsof(x)	( sizeof(x) / sizeof(x[0]) )
  ------------------
 1431|     56|		if (buf[0] != 0)
  ------------------
  |  Branch (1431:7): [True: 0, False: 56]
  ------------------
 1432|      0|		  {
 1433|      0|		    tre_parse_ctx_t subctx;
 1434|      0|		    memcpy(&subctx, ctx, sizeof(subctx));
 1435|      0|		    subctx.re = buf;
 1436|      0|		    subctx.len = tre_strlen(buf);
  ------------------
  |  |   97|      0|#define tre_strlen  wcslen
  ------------------
 1437|      0|		    subctx.nofirstsub = 1;
 1438|      0|		    status = tre_parse(&subctx);
 1439|      0|		    if (status != REG_OK)
  ------------------
  |  Branch (1439:11): [True: 0, False: 0]
  ------------------
 1440|      0|		      return status;
 1441|      0|		    ctx->re += 2;
 1442|      0|		    ctx->position = subctx.position;
 1443|      0|		    result = subctx.result;
 1444|      0|		    break;
 1445|      0|		  }
 1446|     56|	      }
 1447|       |
 1448|     56|	      if (ctx->re + 1 >= ctx->re_end)
  ------------------
  |  Branch (1448:12): [True: 0, False: 56]
  ------------------
 1449|       |		/* Trailing backslash. */
 1450|      0|		return REG_EESCAPE;
 1451|       |
 1452|     56|#ifdef REG_LITERAL
 1453|     56|	      if (*(ctx->re + 1) == L'Q')
  ------------------
  |  Branch (1453:12): [True: 0, False: 56]
  ------------------
 1454|      0|		{
 1455|      0|		  DPRINT(("tre_parse: tmp literal: '%.*" STRF "'\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1456|      0|			  REST(ctx->re)));
 1457|      0|		  ctx->cflags |= REG_LITERAL;
  ------------------
  |  |  105|      0|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  ------------------
  |  |  |  |  101|      0|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|      0|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1458|      0|		  temporary_cflags |= REG_LITERAL;
  ------------------
  |  |  105|      0|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  ------------------
  |  |  |  |  101|      0|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|      0|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1459|      0|		  ctx->re += 2;
 1460|      0|		  STACK_PUSHX(stack, int, PARSE_ATOM);
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1461|      0|		  break;
 1462|      0|		}
 1463|     56|#endif /* REG_LITERAL */
 1464|       |
 1465|     56|	      DPRINT(("tre_parse:  bleep: '%.*" STRF "'\n", REST(ctx->re)));
  ------------------
  |  |   27|     56|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 56]
  |  |  ------------------
  ------------------
 1466|     56|	      ctx->re++;
 1467|     56|	      switch (*ctx->re)
 1468|     56|		{
 1469|      0|		case L'b':
  ------------------
  |  Branch (1469:3): [True: 0, False: 56]
  ------------------
 1470|      0|		  result = tre_ast_new_literal(ctx->mem, ASSERTION,
  ------------------
  |  |   27|      0|#define ASSERTION -2   /* Assertion leaf. */
  ------------------
 1471|      0|					       ASSERT_AT_WB, -1);
  ------------------
  |  |  216|      0|#define ASSERT_AT_WB		 64   /* Word boundary. */
  ------------------
 1472|      0|		  ctx->re++;
 1473|      0|		  break;
 1474|      0|		case L'B':
  ------------------
  |  Branch (1474:3): [True: 0, False: 56]
  ------------------
 1475|      0|		  result = tre_ast_new_literal(ctx->mem, ASSERTION,
  ------------------
  |  |   27|      0|#define ASSERTION -2   /* Assertion leaf. */
  ------------------
 1476|      0|					       ASSERT_AT_WB_NEG, -1);
  ------------------
  |  |  217|      0|#define ASSERT_AT_WB_NEG	128   /* Not a word boundary. */
  ------------------
 1477|      0|		  ctx->re++;
 1478|      0|		  break;
 1479|      0|		case L'<':
  ------------------
  |  Branch (1479:3): [True: 0, False: 56]
  ------------------
 1480|      0|		  result = tre_ast_new_literal(ctx->mem, ASSERTION,
  ------------------
  |  |   27|      0|#define ASSERTION -2   /* Assertion leaf. */
  ------------------
 1481|      0|					       ASSERT_AT_BOW, -1);
  ------------------
  |  |  214|      0|#define ASSERT_AT_BOW		 16   /* Beginning of word. */
  ------------------
 1482|      0|		  ctx->re++;
 1483|      0|		  break;
 1484|      0|		case L'>':
  ------------------
  |  Branch (1484:3): [True: 0, False: 56]
  ------------------
 1485|      0|		  result = tre_ast_new_literal(ctx->mem, ASSERTION,
  ------------------
  |  |   27|      0|#define ASSERTION -2   /* Assertion leaf. */
  ------------------
 1486|      0|					       ASSERT_AT_EOW, -1);
  ------------------
  |  |  215|      0|#define ASSERT_AT_EOW		 32   /* End of word. */
  ------------------
 1487|      0|		  ctx->re++;
 1488|      0|		  break;
 1489|      0|		case L'x':
  ------------------
  |  Branch (1489:3): [True: 0, False: 56]
  ------------------
 1490|      0|		  ctx->re++;
 1491|      0|		  if (ctx->re < ctx->re_end && ctx->re[0] != CHAR_LBRACE)
  ------------------
  |  |   35|      0|#define CHAR_LBRACE	   L'{'
  ------------------
  |  Branch (1491:9): [True: 0, False: 0]
  |  Branch (1491:34): [True: 0, False: 0]
  ------------------
 1492|      0|		    {
 1493|       |		      /* 8 bit hex char. */
 1494|      0|		      char tmp[3] = {0, 0, 0};
 1495|      0|		      long val;
 1496|      0|		      DPRINT(("tre_parse:  8 bit hex: '%.*" STRF "'\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1497|      0|			      REST(ctx->re - 2)));
 1498|       |
 1499|      0|		      if (ctx->re < ctx->re_end && tre_isxdigit(ctx->re[0]))
  ------------------
  |  |   86|      0|#define tre_isxdigit iswxdigit
  ------------------
  |  Branch (1499:13): [True: 0, False: 0]
  |  Branch (1499:38): [True: 0, False: 0]
  ------------------
 1500|      0|			{
 1501|      0|			  tmp[0] = (char)ctx->re[0];
 1502|      0|			  ctx->re++;
 1503|      0|			}
 1504|      0|		      if (ctx->re < ctx->re_end && tre_isxdigit(ctx->re[0]))
  ------------------
  |  |   86|      0|#define tre_isxdigit iswxdigit
  ------------------
  |  Branch (1504:13): [True: 0, False: 0]
  |  Branch (1504:38): [True: 0, False: 0]
  ------------------
 1505|      0|			{
 1506|      0|			  tmp[1] = (char)ctx->re[0];
 1507|      0|			  ctx->re++;
 1508|      0|			}
 1509|      0|		      val = strtol(tmp, NULL, 16);
 1510|      0|		      result = tre_ast_new_literal(ctx->mem, (int)val,
 1511|      0|						   (int)val, ctx->position);
 1512|      0|		      ctx->position++;
 1513|      0|		      break;
 1514|      0|		    }
 1515|      0|		  else if (ctx->re < ctx->re_end)
  ------------------
  |  Branch (1515:14): [True: 0, False: 0]
  ------------------
 1516|      0|		    {
 1517|       |		      /* Wide char. */
 1518|      0|		      char tmp[32];
 1519|      0|		      long val;
 1520|      0|		      int i = 0;
 1521|      0|		      ctx->re++;
 1522|      0|		      while (ctx->re < ctx->re_end)
  ------------------
  |  Branch (1522:16): [True: 0, False: 0]
  ------------------
 1523|      0|			{
 1524|      0|			  if (ctx->re[0] == CHAR_RBRACE)
  ------------------
  |  |   36|      0|#define CHAR_RBRACE	   L'}'
  ------------------
  |  Branch (1524:10): [True: 0, False: 0]
  ------------------
 1525|      0|			    break;
 1526|      0|			  if (tre_isxdigit(ctx->re[0]))
  ------------------
  |  |   86|      0|#define tre_isxdigit iswxdigit
  ------------------
  |  Branch (1526:10): [True: 0, False: 0]
  ------------------
 1527|      0|			    {
 1528|      0|			      if (i >= (int)sizeof(tmp) - 1)
  ------------------
  |  Branch (1528:14): [True: 0, False: 0]
  ------------------
 1529|      0|				return REG_EBRACE;
 1530|      0|			      tmp[i] = (char)ctx->re[0];
 1531|      0|			      i++;
 1532|      0|			      ctx->re++;
 1533|      0|			      continue;
 1534|      0|			    }
 1535|      0|			  return REG_EBRACE;
 1536|      0|			}
 1537|      0|		      ctx->re++;
 1538|      0|		      tmp[i] = 0;
 1539|      0|		      val = strtol(tmp, NULL, 16);
 1540|      0|		      result = tre_ast_new_literal(ctx->mem, (int)val, (int)val,
 1541|      0|						   ctx->position);
 1542|      0|		      ctx->position++;
 1543|      0|		      break;
 1544|      0|		    }
 1545|       |		  /*FALLTHROUGH*/
 1546|       |
 1547|     56|		default:
  ------------------
  |  Branch (1547:3): [True: 56, False: 0]
  ------------------
 1548|     56|		  if (ctx->re >= ctx->re_end)
  ------------------
  |  Branch (1548:9): [True: 0, False: 56]
  ------------------
 1549|      0|		    return REG_EESCAPE;
 1550|     56|		  if (tre_isdigit(*ctx->re))
  ------------------
  |  |   79|     56|#define tre_isdigit iswdigit
  ------------------
  |  Branch (1550:9): [True: 0, False: 56]
  ------------------
 1551|      0|		    {
 1552|       |		      /* Back reference. */
 1553|      0|		      int val = *ctx->re - L'0';
 1554|      0|		      DPRINT(("tre_parse:     backref: '%.*" STRF "'\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1555|      0|			      REST(ctx->re - 1)));
 1556|      0|		      result = tre_ast_new_literal(ctx->mem, BACKREF, val,
  ------------------
  |  |   29|      0|#define BACKREF	  -4   /* Back reference leaf. */
  ------------------
 1557|      0|						   ctx->position);
 1558|      0|		      if (result == NULL)
  ------------------
  |  Branch (1558:13): [True: 0, False: 0]
  ------------------
 1559|      0|			return REG_ESPACE;
 1560|      0|		      ctx->position++;
 1561|      0|		      ctx->max_backref = MAX(val, ctx->max_backref);
  ------------------
  |  |  169|      0|#define MAX(a, b) (((a) >= (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (169:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1562|      0|		      ctx->re++;
 1563|      0|		    }
 1564|     56|		  else
 1565|     56|		    {
 1566|       |		      /* Escaped character. */
 1567|     56|		      DPRINT(("tre_parse:     escaped: '%.*" STRF "'\n",
  ------------------
  |  |   27|     56|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 56]
  |  |  ------------------
  ------------------
 1568|     56|			      REST(ctx->re - 1)));
 1569|     56|		      result = tre_ast_new_literal(ctx->mem, *ctx->re, *ctx->re,
 1570|     56|						   ctx->position);
 1571|     56|		      ctx->position++;
 1572|     56|		      ctx->re++;
 1573|     56|		    }
 1574|     56|		  break;
 1575|     56|		}
 1576|     56|	      if (result == NULL)
  ------------------
  |  Branch (1576:12): [True: 0, False: 56]
  ------------------
 1577|      0|		return REG_ESPACE;
 1578|     56|	      break;
 1579|       |
 1580|     56|	    case CHAR_PERIOD:	 /* the any-symbol */
  ------------------
  |  |   43|     52|#define CHAR_PERIOD	   L'.'
  ------------------
  |  Branch (1580:6): [True: 52, False: 1.02k]
  ------------------
 1581|     52|	      DPRINT(("tre_parse:	  any: '%.*" STRF "'\n",
  ------------------
  |  |   27|     52|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 52]
  |  |  ------------------
  ------------------
 1582|     52|		      REST(ctx->re)));
 1583|     52|	      if (ctx->cflags & REG_NEWLINE)
  ------------------
  |  |  100|     52|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  ------------------
  |  |  |  |   99|     52|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   98|     52|#define REG_EXTENDED	1
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1583:12): [True: 0, False: 52]
  ------------------
 1584|      0|		{
 1585|      0|		  tre_ast_node_t *tmp1;
 1586|      0|		  tre_ast_node_t *tmp2;
 1587|      0|		  tmp1 = tre_ast_new_literal(ctx->mem, 0, L'\n' - 1,
 1588|      0|					     ctx->position);
 1589|      0|		  if (!tmp1)
  ------------------
  |  Branch (1589:9): [True: 0, False: 0]
  ------------------
 1590|      0|		    return REG_ESPACE;
 1591|      0|		  tmp2 = tre_ast_new_literal(ctx->mem, L'\n' + 1, TRE_CHAR_MAX,
  ------------------
  |  |   64|      0|# define TRE_CHAR_MAX WCHAR_MAX
  ------------------
 1592|      0|					     ctx->position + 1);
 1593|      0|		  if (!tmp2)
  ------------------
  |  Branch (1593:9): [True: 0, False: 0]
  ------------------
 1594|      0|		    return REG_ESPACE;
 1595|      0|		  result = tre_ast_new_union(ctx->mem, tmp1, tmp2);
 1596|      0|		  if (!result)
  ------------------
  |  Branch (1596:9): [True: 0, False: 0]
  ------------------
 1597|      0|		    return REG_ESPACE;
 1598|      0|		  ctx->position += 2;
 1599|      0|		}
 1600|     52|	      else
 1601|     52|		{
 1602|     52|		  result = tre_ast_new_literal(ctx->mem, 0, TRE_CHAR_MAX,
  ------------------
  |  |   64|     52|# define TRE_CHAR_MAX WCHAR_MAX
  ------------------
 1603|     52|					       ctx->position);
 1604|     52|		  if (!result)
  ------------------
  |  Branch (1604:9): [True: 0, False: 52]
  ------------------
 1605|      0|		    return REG_ESPACE;
 1606|     52|		  ctx->position++;
 1607|     52|		}
 1608|     52|	      ctx->re++;
 1609|     52|	      break;
 1610|       |
 1611|     93|	    case CHAR_CARET:	 /* beginning of line assertion */
  ------------------
  |  |   47|     93|#define CHAR_CARET	   L'^'
  ------------------
  |  Branch (1611:6): [True: 93, False: 979]
  ------------------
 1612|       |	      /* '^' has a special meaning everywhere in EREs, and in the
 1613|       |		 beginning of the RE and after \( is BREs. */
 1614|     93|	      if (ctx->cflags & REG_EXTENDED
  ------------------
  |  |   98|    186|#define REG_EXTENDED	1
  ------------------
  |  Branch (1614:12): [True: 93, False: 0]
  ------------------
 1615|      0|		  || (ctx->re - 2 >= ctx->re_start
  ------------------
  |  Branch (1615:9): [True: 0, False: 0]
  ------------------
 1616|      0|		      && *(ctx->re - 2) == CHAR_BACKSLASH
  ------------------
  |  |   49|      0|#define CHAR_BACKSLASH	   L'\\'
  ------------------
  |  Branch (1616:12): [True: 0, False: 0]
  ------------------
 1617|      0|		      && *(ctx->re - 1) == CHAR_LPAREN)
  ------------------
  |  |   33|      0|#define CHAR_LPAREN	   L'('
  ------------------
  |  Branch (1617:12): [True: 0, False: 0]
  ------------------
 1618|      0|		  || ctx->re == ctx->re_start)
  ------------------
  |  Branch (1618:8): [True: 0, False: 0]
  ------------------
 1619|     93|		{
 1620|     93|		  DPRINT(("tre_parse:	      BOL: '%.*" STRF "'\n",
  ------------------
  |  |   27|     93|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 93]
  |  |  ------------------
  ------------------
 1621|     93|			  REST(ctx->re)));
 1622|     93|		  result = tre_ast_new_literal(ctx->mem, ASSERTION,
  ------------------
  |  |   27|     93|#define ASSERTION -2   /* Assertion leaf. */
  ------------------
 1623|     93|					       ASSERT_AT_BOL, -1);
  ------------------
  |  |  210|     93|#define ASSERT_AT_BOL		  1   /* Beginning of line. */
  ------------------
 1624|     93|		  if (result == NULL)
  ------------------
  |  Branch (1624:9): [True: 0, False: 93]
  ------------------
 1625|      0|		    return REG_ESPACE;
 1626|     93|		  ctx->re++;
 1627|     93|		}
 1628|      0|	      else
 1629|      0|		goto parse_literal;
 1630|     93|	      break;
 1631|       |
 1632|     93|	    case CHAR_DOLLAR:	 /* end of line assertion. */
  ------------------
  |  |   48|     55|#define CHAR_DOLLAR	   L'$'
  ------------------
  |  Branch (1632:6): [True: 55, False: 1.01k]
  ------------------
 1633|       |	      /* '$' is special everywhere in EREs, and in the end of the
 1634|       |		 string and before \) is BREs. */
 1635|     55|	      if (ctx->cflags & REG_EXTENDED
  ------------------
  |  |   98|    110|#define REG_EXTENDED	1
  ------------------
  |  Branch (1635:12): [True: 55, False: 0]
  ------------------
 1636|      0|		  || (ctx->re + 2 < ctx->re_end
  ------------------
  |  Branch (1636:9): [True: 0, False: 0]
  ------------------
 1637|      0|		      && *(ctx->re + 1) == CHAR_BACKSLASH
  ------------------
  |  |   49|      0|#define CHAR_BACKSLASH	   L'\\'
  ------------------
  |  Branch (1637:12): [True: 0, False: 0]
  ------------------
 1638|      0|		      && *(ctx->re + 2) == CHAR_RPAREN)
  ------------------
  |  |   34|      0|#define CHAR_RPAREN	   L')'
  ------------------
  |  Branch (1638:12): [True: 0, False: 0]
  ------------------
 1639|      0|		  || ctx->re + 1 == ctx->re_end)
  ------------------
  |  Branch (1639:8): [True: 0, False: 0]
  ------------------
 1640|     55|		{
 1641|     55|		  DPRINT(("tre_parse:	      EOL: '%.*" STRF "'\n",
  ------------------
  |  |   27|     55|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 55]
  |  |  ------------------
  ------------------
 1642|     55|			  REST(ctx->re)));
 1643|     55|		  result = tre_ast_new_literal(ctx->mem, ASSERTION,
  ------------------
  |  |   27|     55|#define ASSERTION -2   /* Assertion leaf. */
  ------------------
 1644|     55|					       ASSERT_AT_EOL, -1);
  ------------------
  |  |  211|     55|#define ASSERT_AT_EOL		  2   /* End of line. */
  ------------------
 1645|     55|		  if (result == NULL)
  ------------------
  |  Branch (1645:9): [True: 0, False: 55]
  ------------------
 1646|      0|		    return REG_ESPACE;
 1647|     55|		  ctx->re++;
 1648|     55|		}
 1649|      0|	      else
 1650|      0|		goto parse_literal;
 1651|     55|	      break;
 1652|       |
 1653|    392|	    default:
  ------------------
  |  Branch (1653:6): [True: 392, False: 680]
  ------------------
 1654|    392|	    parse_literal:
 1655|       |
 1656|    392|	      if (temporary_cflags && ctx->re + 1 < ctx->re_end
  ------------------
  |  Branch (1656:12): [True: 0, False: 392]
  |  Branch (1656:32): [True: 0, False: 0]
  ------------------
 1657|      0|		  && *ctx->re == CHAR_BACKSLASH && *(ctx->re + 1) == L'E')
  ------------------
  |  |   49|    392|#define CHAR_BACKSLASH	   L'\\'
  ------------------
  |  Branch (1657:8): [True: 0, False: 0]
  |  Branch (1657:38): [True: 0, False: 0]
  ------------------
 1658|      0|		{
 1659|      0|		  DPRINT(("tre_parse:	 end tmps: '%.*" STRF "'\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1660|      0|			  REST(ctx->re)));
 1661|      0|		  ctx->cflags &= ~temporary_cflags;
 1662|      0|		  temporary_cflags = 0;
 1663|      0|		  ctx->re += 2;
 1664|      0|		  STACK_PUSHX(stack, int, PARSE_PIECE);
  ------------------
  |  |   60|      0|  {									      \
  |  |   61|      0|    status = tre_stack_push_ ## typetag(s, value);			      \
  |  |   62|      0|    if (status != REG_OK)						      \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      break;								      \
  |  |   64|      0|  }
  ------------------
 1665|      0|		  break;
 1666|      0|		}
 1667|       |
 1668|       |
 1669|       |	      /* We are expecting an atom.  If the subexpression (or the whole
 1670|       |		 regexp) ends here, we interpret it as an empty expression
 1671|       |		 (which matches an empty string).  */
 1672|    392|	      if (
 1673|    392|#ifdef REG_LITERAL
 1674|    392|		  !(ctx->cflags & REG_LITERAL) &&
  ------------------
  |  |  105|    392|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  ------------------
  |  |  |  |  101|    392|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|    392|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   99|    392|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   98|    392|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1674:5): [True: 392, False: 0]
  ------------------
 1675|    392|#endif /* REG_LITERAL */
 1676|    392|		  (ctx->re >= ctx->re_end
  ------------------
  |  Branch (1676:6): [True: 0, False: 392]
  ------------------
 1677|    392|		   || *ctx->re == CHAR_STAR
  ------------------
  |  |   40|    784|#define CHAR_STAR	   L'*'
  ------------------
  |  Branch (1677:9): [True: 0, False: 392]
  ------------------
 1678|    392|		   || (ctx->cflags & REG_EXTENDED
  ------------------
  |  |   98|    784|#define REG_EXTENDED	1
  ------------------
  |  Branch (1678:10): [True: 392, False: 0]
  ------------------
 1679|    392|		       && (*ctx->re == CHAR_PIPE
  ------------------
  |  |   32|    784|#define CHAR_PIPE	   L'|'
  ------------------
  |  Branch (1679:14): [True: 0, False: 392]
  ------------------
 1680|    392|			   || *ctx->re == CHAR_LBRACE
  ------------------
  |  |   35|    784|#define CHAR_LBRACE	   L'{'
  ------------------
  |  Branch (1680:10): [True: 0, False: 392]
  ------------------
 1681|    392|			   || *ctx->re == CHAR_PLUS
  ------------------
  |  |   42|    784|#define CHAR_PLUS	   L'+'
  ------------------
  |  Branch (1681:10): [True: 0, False: 392]
  ------------------
 1682|    392|			   || *ctx->re == CHAR_QUESTIONMARK))
  ------------------
  |  |   41|    392|#define CHAR_QUESTIONMARK  L'?'
  ------------------
  |  Branch (1682:10): [True: 0, False: 392]
  ------------------
 1683|       |		   /* Test for "\)" in BRE mode. */
 1684|    392|		   || (!(ctx->cflags & REG_EXTENDED)
  ------------------
  |  |   98|    392|#define REG_EXTENDED	1
  ------------------
  |  Branch (1684:10): [True: 0, False: 392]
  ------------------
 1685|      0|		       && ctx->re + 1 < ctx->re_end
  ------------------
  |  Branch (1685:13): [True: 0, False: 0]
  ------------------
 1686|      0|		       && *ctx->re == CHAR_BACKSLASH
  ------------------
  |  |   49|    392|#define CHAR_BACKSLASH	   L'\\'
  ------------------
  |  Branch (1686:13): [True: 0, False: 0]
  ------------------
 1687|      0|		       && *(ctx->re + 1) == CHAR_LBRACE)))
  ------------------
  |  |   35|      0|#define CHAR_LBRACE	   L'{'
  ------------------
  |  Branch (1687:13): [True: 0, False: 0]
  ------------------
 1688|      0|		{
 1689|      0|		  DPRINT(("tre_parse:	    empty: '%.*" STRF "'\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1690|      0|			  REST(ctx->re)));
 1691|      0|		  result = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
  ------------------
  |  |   26|      0|#define EMPTY	  -1   /* Empty leaf (denotes empty string). */
  ------------------
 1692|      0|		  if (!result)
  ------------------
  |  Branch (1692:9): [True: 0, False: 0]
  ------------------
 1693|      0|		    return REG_ESPACE;
 1694|      0|		  break;
 1695|      0|		}
 1696|       |
 1697|       |/* R change */
 1698|    392|	      if ((ctx->cflags & REG_LITERAL)
  ------------------
  |  |  105|    392|#define REG_LITERAL	(REG_NOSUB << 1)
  |  |  ------------------
  |  |  |  |  101|    392|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  100|    392|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   99|    392|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   98|    392|#define REG_EXTENDED	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1698:12): [True: 0, False: 392]
  ------------------
 1699|      0|		  && (ctx->re >= ctx->re_end || !ctx->re[0])) {
  ------------------
  |  Branch (1699:9): [True: 0, False: 0]
  |  Branch (1699:35): [True: 0, False: 0]
  ------------------
 1700|      0|		  DPRINT(("tre_parse:	    literal empty: '%.*" STRF "'\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1701|      0|			  REST(ctx->re)));
 1702|      0|		  result = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
  ------------------
  |  |   26|      0|#define EMPTY	  -1   /* Empty leaf (denotes empty string). */
  ------------------
 1703|      0|		  if (!result)
  ------------------
  |  Branch (1703:9): [True: 0, False: 0]
  ------------------
 1704|      0|		    return REG_ESPACE;
 1705|      0|		  break;
 1706|      0|	      }
 1707|       |/* end R change */
 1708|       |
 1709|    392|	      DPRINT(("tre_parse:     literal: '%.*" STRF "'\n",
  ------------------
  |  |   27|    392|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 392]
  |  |  ------------------
  ------------------
 1710|    392|		      REST(ctx->re)));
 1711|       |	      /* Note that we can't use an tre_isalpha() test here, since there
 1712|       |		 may be characters which are alphabetic but neither upper or
 1713|       |		 lower case. */
 1714|    392|	      if (ctx->cflags & REG_ICASE
  ------------------
  |  |   99|    784|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  ------------------
  |  |  |  |   98|    392|#define REG_EXTENDED	1
  |  |  ------------------
  ------------------
  |  Branch (1714:12): [True: 0, False: 392]
  ------------------
 1715|      0|		  && (tre_isupper(*ctx->re) || tre_islower(*ctx->re)))
  ------------------
  |  |   85|      0|#define tre_isupper iswupper
  ------------------
              		  && (tre_isupper(*ctx->re) || tre_islower(*ctx->re)))
  ------------------
  |  |   81|      0|#define tre_islower iswlower
  ------------------
  |  Branch (1715:9): [True: 0, False: 0]
  |  Branch (1715:34): [True: 0, False: 0]
  ------------------
 1716|      0|		{
 1717|      0|		  tre_ast_node_t *tmp1;
 1718|      0|		  tre_ast_node_t *tmp2;
 1719|       |
 1720|       |		  /* XXX - Can there be more than one opposite-case
 1721|       |		     counterpoints for some character in some locale?  Or
 1722|       |		     more than two characters which all should be regarded
 1723|       |		     the same character if case is ignored?  If yes, there
 1724|       |		     does not seem to be a portable way to detect it.  I guess
 1725|       |		     that at least for multi-character collating elements there
 1726|       |		     could be several opposite-case counterpoints, but they
 1727|       |		     cannot be supported portably anyway. */
 1728|      0|		  tmp1 = tre_ast_new_literal(ctx->mem, tre_toupper(*ctx->re),
  ------------------
  |  |   95|      0|#define tre_toupper towupper
  ------------------
 1729|      0|					     tre_toupper(*ctx->re),
  ------------------
  |  |   95|      0|#define tre_toupper towupper
  ------------------
 1730|      0|					     ctx->position);
 1731|      0|		  if (!tmp1)
  ------------------
  |  Branch (1731:9): [True: 0, False: 0]
  ------------------
 1732|      0|		    return REG_ESPACE;
 1733|      0|		  tmp2 = tre_ast_new_literal(ctx->mem, tre_tolower(*ctx->re),
  ------------------
  |  |   94|      0|#define tre_tolower towlower
  ------------------
 1734|      0|					     tre_tolower(*ctx->re),
  ------------------
  |  |   94|      0|#define tre_tolower towlower
  ------------------
 1735|      0|					     ctx->position);
 1736|      0|		  if (!tmp2)
  ------------------
  |  Branch (1736:9): [True: 0, False: 0]
  ------------------
 1737|      0|		    return REG_ESPACE;
 1738|      0|		  result = tre_ast_new_union(ctx->mem, tmp1, tmp2);
 1739|      0|		  if (!result)
  ------------------
  |  Branch (1739:9): [True: 0, False: 0]
  ------------------
 1740|      0|		    return REG_ESPACE;
 1741|      0|		}
 1742|    392|	      else
 1743|    392|		{
 1744|    392|		  result = tre_ast_new_literal(ctx->mem, *ctx->re, *ctx->re,
 1745|    392|					       ctx->position);
 1746|    392|		  if (!result)
  ------------------
  |  Branch (1746:9): [True: 0, False: 392]
  ------------------
 1747|      0|		    return REG_ESPACE;
 1748|    392|		}
 1749|    392|	      ctx->position++;
 1750|    392|	      ctx->re++;
 1751|    392|	      break;
 1752|  1.07k|	    }
 1753|  1.07k|	  break;
 1754|       |
 1755|  1.07k|	case PARSE_MARK_FOR_SUBMATCH:
  ------------------
  |  Branch (1755:2): [True: 371, False: 6.37k]
  ------------------
 1756|    371|	  {
 1757|    371|	    int submatch_id = tre_stack_pop_int(stack);
 1758|       |
 1759|    371|            if(result) {
  ------------------
  |  Branch (1759:16): [True: 371, False: 0]
  ------------------
 1760|    371|	      if (result->submatch_id >= 0)
  ------------------
  |  Branch (1760:12): [True: 29, False: 342]
  ------------------
 1761|     29|	        {
 1762|     29|		  tre_ast_node_t *n, *tmp_node;
 1763|     29|		  n = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
  ------------------
  |  |   26|     29|#define EMPTY	  -1   /* Empty leaf (denotes empty string). */
  ------------------
 1764|     29|		  if (n == NULL)
  ------------------
  |  Branch (1764:9): [True: 0, False: 29]
  ------------------
 1765|      0|		    return REG_ESPACE;
 1766|     29|		  tmp_node = tre_ast_new_catenation(ctx->mem, n, result);
 1767|     29|		  if (tmp_node == NULL)
  ------------------
  |  Branch (1767:9): [True: 0, False: 29]
  ------------------
 1768|      0|		    return REG_ESPACE;
 1769|     29|		  tmp_node->num_submatches = result->num_submatches;
 1770|     29|		  result = tmp_node;
 1771|     29|	        }
 1772|    371|	      result->submatch_id = submatch_id;
 1773|    371|	      result->num_submatches++;
 1774|    371|	    }
 1775|    371|	    break;
 1776|    371|	  }
 1777|       |
 1778|    371|	case PARSE_RESTORE_CFLAGS:
  ------------------
  |  Branch (1778:2): [True: 0, False: 6.75k]
  ------------------
 1779|      0|	  ctx->cflags = tre_stack_pop_int(stack);
 1780|      0|	  break;
 1781|       |
 1782|      0|	default:
  ------------------
  |  Branch (1782:2): [True: 0, False: 6.75k]
  ------------------
 1783|      0|	  assert(0);
  ------------------
  |  |   29|      0|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|      0|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1784|      0|	  break;
 1785|  6.75k|	}
 1786|  6.75k|    }
 1787|       |
 1788|       |  /* Check for missing closing parentheses. */
 1789|    206|  if (depth > 0)
  ------------------
  |  Branch (1789:7): [True: 0, False: 206]
  ------------------
 1790|      0|    return REG_EPAREN;
 1791|       |
 1792|    206|  if (status == REG_OK)
  ------------------
  |  Branch (1792:7): [True: 206, False: 0]
  ------------------
 1793|    206|    ctx->result = result;
 1794|       |
 1795|    206|  return status;
 1796|    206|}
tre-parse.c:tre_parse_bracket:
  440|    259|{
  441|    259|  tre_ast_node_t *node = NULL;
  442|    259|  int negate = 0;
  443|    259|  reg_errcode_t status = REG_OK;
  444|    259|  tre_ast_node_t **items, *u, *n;
  445|    259|  int i = 0, j, max_i = 32, curr_max, curr_min;
  446|    259|  tre_ctype_t neg_classes[MAX_NEG_CLASSES];
  447|    259|  int num_neg_classes = 0;
  448|       |
  449|       |  /* Start off with an array of `max_i' elements. */
  450|    259|  items = xmalloc(sizeof(*items) * max_i);
  ------------------
  |  |   67|    259|#define xmalloc(size) malloc(size)
  ------------------
  451|    259|  if (items == NULL)
  ------------------
  |  Branch (451:7): [True: 0, False: 259]
  ------------------
  452|      0|    return REG_ESPACE;
  453|       |
  454|    259|  if (ctx->re >= ctx->re_end)
  ------------------
  |  Branch (454:7): [True: 0, False: 259]
  ------------------
  455|      0|    {
  456|      0|      xfree(items);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
  457|      0|      return REG_EBRACK;
  458|      0|    }
  459|       |
  460|    259|  if (*ctx->re == CHAR_CARET)
  ------------------
  |  |   47|    259|#define CHAR_CARET	   L'^'
  ------------------
  |  Branch (460:7): [True: 56, False: 203]
  ------------------
  461|     56|    {
  462|     56|      DPRINT(("tre_parse_bracket: negate: '%.*" STRF "'\n", REST(ctx->re)));
  ------------------
  |  |   27|     56|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 56]
  |  |  ------------------
  ------------------
  463|     56|      negate = 1;
  464|     56|      ctx->re++;
  465|     56|    }
  466|       |
  467|    259|  status = tre_parse_bracket_items(ctx, negate, neg_classes, &num_neg_classes,
  468|    259|				   &items, &i, &max_i);
  469|       |
  470|    259|  if (status != REG_OK)
  ------------------
  |  Branch (470:7): [True: 0, False: 259]
  ------------------
  471|      0|    goto parse_bracket_done;
  472|       |
  473|       |  /* Sort the array if we need to negate it. */
  474|    259|  if (negate)
  ------------------
  |  Branch (474:7): [True: 56, False: 203]
  ------------------
  475|     56|    qsort(items, (unsigned)i, sizeof(*items), tre_compare_items);
  476|       |
  477|    259|  curr_max = curr_min = 0;
  478|       |  /* Build a union of the items in the array, negated if necessary. */
  479|    592|  for (j = 0; j < i && status == REG_OK; j++)
  ------------------
  |  Branch (479:15): [True: 333, False: 259]
  |  Branch (479:24): [True: 333, False: 0]
  ------------------
  480|    333|    {
  481|    333|      int min, max;
  482|    333|      tre_literal_t *l = items[j]->obj;
  483|    333|      min = (int) l->code_min;
  484|    333|      max = (int) l->code_max;
  485|       |
  486|    333|      DPRINT(("item: %d - %d, class %p, curr_max = %d\n",
  ------------------
  |  |   27|    333|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 333]
  |  |  ------------------
  ------------------
  487|    333|	      (int)l->code_min, (int)l->code_max, (void *)l->u.class, curr_max));
  488|       |
  489|    333|      if (negate)
  ------------------
  |  Branch (489:11): [True: 56, False: 277]
  ------------------
  490|     56|	{
  491|     56|	  if (min < curr_max)
  ------------------
  |  Branch (491:8): [True: 0, False: 56]
  ------------------
  492|      0|	    {
  493|       |	      /* Overlap. */
  494|      0|	      curr_max = MAX(max + 1, curr_max);
  ------------------
  |  |  169|      0|#define MAX(a, b) (((a) >= (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (169:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  495|      0|	      DPRINT(("overlap, curr_max = %d\n", curr_max));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  496|      0|	      l = NULL;
  497|      0|	    }
  498|     56|	  else
  499|     56|	    {
  500|       |	      /* No overlap. */
  501|     56|	      curr_max = min - 1;
  502|     56|	      if (curr_max >= curr_min)
  ------------------
  |  Branch (502:12): [True: 56, False: 0]
  ------------------
  503|     56|		{
  504|     56|		  DPRINT(("no overlap\n"));
  ------------------
  |  |   27|     56|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 56]
  |  |  ------------------
  ------------------
  505|     56|		  l->code_min = curr_min;
  506|     56|		  l->code_max = curr_max;
  507|     56|		}
  508|      0|	      else
  509|      0|		{
  510|      0|		  DPRINT(("no overlap, zero room\n"));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  511|      0|		  l = NULL;
  512|      0|		}
  513|     56|	      curr_min = curr_max = max + 1;
  514|     56|	    }
  515|     56|	}
  516|       |
  517|    333|      if (l != NULL)
  ------------------
  |  Branch (517:11): [True: 333, False: 0]
  ------------------
  518|    333|	{
  519|    333|	  int k;
  520|    333|	  DPRINT(("creating %d - %d\n", (int)l->code_min, (int)l->code_max));
  ------------------
  |  |   27|    333|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 333]
  |  |  ------------------
  ------------------
  521|    333|	  l->position = ctx->position;
  522|    333|	  if (num_neg_classes > 0)
  ------------------
  |  Branch (522:8): [True: 0, False: 333]
  ------------------
  523|      0|	    {
  524|      0|	      l->neg_classes = tre_mem_alloc(ctx->mem,
  ------------------
  |  |   40|      0|#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
  ------------------
  525|      0|					     (sizeof(l->neg_classes)
  526|      0|					      * (num_neg_classes + 1)));
  527|      0|	      if (l->neg_classes == NULL)
  ------------------
  |  Branch (527:12): [True: 0, False: 0]
  ------------------
  528|      0|		{
  529|      0|		  status = REG_ESPACE;
  530|      0|		  break;
  531|      0|		}
  532|      0|	      for (k = 0; k < num_neg_classes; k++)
  ------------------
  |  Branch (532:20): [True: 0, False: 0]
  ------------------
  533|      0|		l->neg_classes[k] = neg_classes[k];
  534|      0|	      l->neg_classes[k] = (tre_ctype_t)0;
  535|      0|	    }
  536|    333|	  else
  537|    333|	    l->neg_classes = NULL;
  538|    333|	  if (node == NULL)
  ------------------
  |  Branch (538:8): [True: 259, False: 74]
  ------------------
  539|    259|	    node = items[j];
  540|     74|	  else
  541|     74|	    {
  542|     74|	      u = tre_ast_new_union(ctx->mem, node, items[j]);
  543|     74|	      if (u == NULL)
  ------------------
  |  Branch (543:12): [True: 0, False: 74]
  ------------------
  544|      0|		status = REG_ESPACE;
  545|     74|	      node = u;
  546|     74|	    }
  547|    333|	}
  548|    333|    }
  549|       |
  550|    259|  if (status != REG_OK)
  ------------------
  |  Branch (550:7): [True: 0, False: 259]
  ------------------
  551|      0|    goto parse_bracket_done;
  552|       |
  553|    259|  if (negate)
  ------------------
  |  Branch (553:7): [True: 56, False: 203]
  ------------------
  554|     56|    {
  555|     56|      int k;
  556|     56|      DPRINT(("final: creating %d - %d\n", curr_min, (int)TRE_CHAR_MAX));
  ------------------
  |  |   27|     56|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 56]
  |  |  ------------------
  ------------------
  557|     56|      n = tre_ast_new_literal(ctx->mem, curr_min, TRE_CHAR_MAX, ctx->position);
  ------------------
  |  |   64|     56|# define TRE_CHAR_MAX WCHAR_MAX
  ------------------
  558|     56|      if (n == NULL)
  ------------------
  |  Branch (558:11): [True: 0, False: 56]
  ------------------
  559|      0|	status = REG_ESPACE;
  560|     56|      else
  561|     56|	{
  562|     56|	  tre_literal_t *l = n->obj;
  563|     56|	  if (num_neg_classes > 0)
  ------------------
  |  Branch (563:8): [True: 0, False: 56]
  ------------------
  564|      0|	    {
  565|      0|	      l->neg_classes = tre_mem_alloc(ctx->mem,
  ------------------
  |  |   40|      0|#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
  ------------------
  566|      0|					     (sizeof(l->neg_classes)
  567|      0|					      * (num_neg_classes + 1)));
  568|      0|	      if (l->neg_classes == NULL)
  ------------------
  |  Branch (568:12): [True: 0, False: 0]
  ------------------
  569|      0|		{
  570|      0|		  status = REG_ESPACE;
  571|      0|		  goto parse_bracket_done;
  572|      0|		}
  573|      0|	      for (k = 0; k < num_neg_classes; k++)
  ------------------
  |  Branch (573:20): [True: 0, False: 0]
  ------------------
  574|      0|		l->neg_classes[k] = neg_classes[k];
  575|      0|	      l->neg_classes[k] = (tre_ctype_t)0;
  576|      0|	    }
  577|     56|	  else
  578|     56|	    l->neg_classes = NULL;
  579|     56|	  if (node == NULL)
  ------------------
  |  Branch (579:8): [True: 0, False: 56]
  ------------------
  580|      0|	    node = n;
  581|     56|	  else
  582|     56|	    {
  583|     56|	      u = tre_ast_new_union(ctx->mem, node, n);
  584|     56|	      if (u == NULL)
  ------------------
  |  Branch (584:12): [True: 0, False: 56]
  ------------------
  585|      0|		status = REG_ESPACE;
  586|     56|	      node = u;
  587|     56|	    }
  588|     56|	}
  589|     56|    }
  590|       |
  591|    259|  if (status != REG_OK)
  ------------------
  |  Branch (591:7): [True: 0, False: 259]
  ------------------
  592|      0|    goto parse_bracket_done;
  593|       |
  594|       |#ifdef TRE_DEBUG
  595|       |  tre_ast_print(node);
  596|       |#endif /* TRE_DEBUG */
  597|       |
  598|    259| parse_bracket_done:
  599|    259|  xfree(items);
  ------------------
  |  |   69|    259|#define xfree(ptr) free(ptr)
  ------------------
  600|    259|  ctx->position++;
  601|    259|  *result = node;
  602|    259|  return status;
  603|    259|}
tre-parse.c:tre_parse_bracket_items:
  266|    259|{
  267|    259|  const tre_char_t *re = ctx->re;
  268|    259|  reg_errcode_t status = REG_OK;
  269|    259|  tre_ctype_t class = (tre_ctype_t)0;
  270|    259|  int i = *num_items;
  271|    259|  int max_i = *items_size;
  272|    259|  int skip;
  273|       |
  274|       |  /* Build an array of the items in the bracket expression. */
  275|    586|  while (status == REG_OK)
  ------------------
  |  Branch (275:10): [True: 586, False: 0]
  ------------------
  276|    586|    {
  277|    586|      skip = 0;
  278|    586|      if (re >= ctx->re_end)
  ------------------
  |  Branch (278:11): [True: 0, False: 586]
  ------------------
  279|      0|	{
  280|      0|	  status = REG_EBRACK;
  281|      0|	}
  282|    586|      else if (*re == CHAR_RBRACKET && re > ctx->re)
  ------------------
  |  |   38|  1.17k|#define CHAR_RBRACKET	   L']'
  ------------------
  |  Branch (282:16): [True: 259, False: 327]
  |  Branch (282:40): [True: 259, False: 0]
  ------------------
  283|    259|	{
  284|    259|	  DPRINT(("tre_parse_bracket:	done: '%.*" STRF "'\n", REST(re)));
  ------------------
  |  |   27|    259|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 259]
  |  |  ------------------
  ------------------
  285|    259|	  re++;
  286|    259|	  break;
  287|    259|	}
  288|    327|      else
  289|    327|	{
  290|    327|	  tre_cint_t min = 0, max = 0;
  291|       |
  292|    327|	  class = (tre_ctype_t)0;
  293|    327|	  if (re + 2 < ctx->re_end
  ------------------
  |  Branch (293:8): [True: 287, False: 40]
  ------------------
  294|    287|	      && *(re + 1) == CHAR_MINUS && *(re + 2) != CHAR_RBRACKET)
  ------------------
  |  |   39|    614|#define CHAR_MINUS	   L'-'
  ------------------
              	      && *(re + 1) == CHAR_MINUS && *(re + 2) != CHAR_RBRACKET)
  ------------------
  |  |   38|     79|#define CHAR_RBRACKET	   L']'
  ------------------
  |  Branch (294:11): [True: 79, False: 208]
  |  Branch (294:38): [True: 11, False: 68]
  ------------------
  295|     11|	    {
  296|     11|	      DPRINT(("tre_parse_bracket:  range: '%.*" STRF "'\n", REST(re)));
  ------------------
  |  |   27|     11|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 11]
  |  |  ------------------
  ------------------
  297|     11|	      min = *re;
  298|     11|	      max = *(re + 2);
  299|     11|	      re += 3;
  300|       |	      /* XXX - Should use collation order instead of encoding values
  301|       |		 in character ranges. */
  302|     11|	      if (min > max)
  ------------------
  |  Branch (302:12): [True: 0, False: 11]
  ------------------
  303|      0|		status = REG_ERANGE;
  304|     11|	    }
  305|    316|	  else if (re + 1 < ctx->re_end
  ------------------
  |  Branch (305:13): [True: 316, False: 0]
  ------------------
  306|    316|		   && *re == CHAR_LBRACKET && *(re + 1) == CHAR_PERIOD)
  ------------------
  |  |   37|    632|#define CHAR_LBRACKET	   L'['
  ------------------
              		   && *re == CHAR_LBRACKET && *(re + 1) == CHAR_PERIOD)
  ------------------
  |  |   43|     96|#define CHAR_PERIOD	   L'.'
  ------------------
  |  Branch (306:9): [True: 96, False: 220]
  |  Branch (306:33): [True: 0, False: 96]
  ------------------
  307|      0|	    status = REG_ECOLLATE;
  308|    316|	  else if (re + 1 < ctx->re_end
  ------------------
  |  Branch (308:13): [True: 316, False: 0]
  ------------------
  309|    316|		   && *re == CHAR_LBRACKET && *(re + 1) == CHAR_EQUAL)
  ------------------
  |  |   37|    632|#define CHAR_LBRACKET	   L'['
  ------------------
              		   && *re == CHAR_LBRACKET && *(re + 1) == CHAR_EQUAL)
  ------------------
  |  |   45|     96|#define CHAR_EQUAL	   L'='
  ------------------
  |  Branch (309:9): [True: 96, False: 220]
  |  Branch (309:33): [True: 0, False: 96]
  ------------------
  310|      0|	    status = REG_ECOLLATE;
  311|    316|	  else if (re + 1 < ctx->re_end
  ------------------
  |  Branch (311:13): [True: 316, False: 0]
  ------------------
  312|    316|		   && *re == CHAR_LBRACKET && *(re + 1) == CHAR_COLON)
  ------------------
  |  |   37|    632|#define CHAR_LBRACKET	   L'['
  ------------------
              		   && *re == CHAR_LBRACKET && *(re + 1) == CHAR_COLON)
  ------------------
  |  |   44|     96|#define CHAR_COLON	   L':'
  ------------------
  |  Branch (312:9): [True: 96, False: 220]
  |  Branch (312:33): [True: 96, False: 0]
  ------------------
  313|     96|	    {
  314|     96|	      char tmp_str[64];
  315|     96|	      const tre_char_t *endptr = re + 2;
  316|     96|	      size_t len;
  317|     96|	      DPRINT(("tre_parse_bracket:  class: '%.*" STRF "'\n", REST(re)));
  ------------------
  |  |   27|     96|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 96]
  |  |  ------------------
  ------------------
  318|    576|	      while (endptr < ctx->re_end && *endptr != CHAR_COLON)
  ------------------
  |  |   44|    576|#define CHAR_COLON	   L':'
  ------------------
  |  Branch (318:15): [True: 576, False: 0]
  |  Branch (318:39): [True: 480, False: 96]
  ------------------
  319|    480|		endptr++;
  320|     96|	      if (endptr != ctx->re_end)
  ------------------
  |  Branch (320:12): [True: 96, False: 0]
  ------------------
  321|     96|		{
  322|     96|		  len = MIN(endptr - re - 2, 63);
  ------------------
  |  |  170|     96|#define MIN(a, b) (((a) <= (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (170:20): [True: 96, False: 0]
  |  |  ------------------
  ------------------
  323|     96|#ifdef TRE_WCHAR
  324|     96|		  {
  325|     96|		    tre_char_t tmp_wcs[64];
  326|     96|		    wcsncpy(tmp_wcs, re + 2, len);
  327|     96|		    tmp_wcs[len] = L'\0';
  328|       |#if defined HAVE_WCSRTOMBS
  329|       |		    {
  330|       |		      mbstate_t state;
  331|       |		      const tre_char_t *src = tmp_wcs;
  332|       |		      memset(&state, '\0', sizeof(state));
  333|       |		      len = wcsrtombs(tmp_str, &src, sizeof(tmp_str), &state);
  334|       |		    }
  335|       |#elif defined HAVE_WCSTOMBS
  336|       |		    len = wcstombs(tmp_str, tmp_wcs, 63);
  337|     96|#endif /* defined HAVE_WCSTOMBS */
  338|     96|		  }
  339|       |#else /* !TRE_WCHAR */
  340|       |		  strncpy(tmp_str, (const char*)re + 2, len);
  341|       |#endif /* !TRE_WCHAR */
  342|       |		  /* wcsrtombs()/wcstombs() return (size_t)-1 if the class name
  343|       |		     contains characters that do not convert, and may return a
  344|       |		     length equal to the buffer size if it converts exactly.
  345|       |		     Either way tmp_str[len] would land outside tmp_str. */
  346|     96|		  if (len == (size_t)-1)
  ------------------
  |  Branch (346:9): [True: 0, False: 96]
  ------------------
  347|      0|		    len = 0;
  348|     96|		  else if (len >= sizeof(tmp_str))
  ------------------
  |  Branch (348:14): [True: 0, False: 96]
  ------------------
  349|      0|		    len = sizeof(tmp_str) - 1;
  350|     96|		  tmp_str[len] = '\0';
  351|     96|		  DPRINT(("  class name: %s\n", tmp_str));
  ------------------
  |  |   27|     96|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 96]
  |  |  ------------------
  ------------------
  352|     96|		  class = tre_ctype(tmp_str);
  ------------------
  |  |  140|     96|#define tre_ctype(s)   wctype(s)
  ------------------
  353|     96|		  if (!class)
  ------------------
  |  Branch (353:9): [True: 0, False: 96]
  ------------------
  354|      0|		    status = REG_ECTYPE;
  355|       |		  /* Optimize character classes for 8 bit character sets. */
  356|     96|		  if (status == REG_OK && ctx->cur_max == 1)
  ------------------
  |  Branch (356:9): [True: 96, False: 0]
  |  Branch (356:29): [True: 96, False: 0]
  ------------------
  357|     96|		    {
  358|     96|		      status = tre_expand_ctype(ctx->mem, class, items,
  359|     96|						&i, &max_i, ctx->cflags);
  360|     96|		      class = (tre_ctype_t)0;
  361|     96|		      skip = 1;
  362|     96|		    }
  363|     96|		  re = endptr + 2;
  364|     96|		}
  365|      0|	      else
  366|      0|		status = REG_ECTYPE;
  367|     96|	      min = 0;
  368|     96|	      max = TRE_CHAR_MAX;
  ------------------
  |  |   64|     96|# define TRE_CHAR_MAX WCHAR_MAX
  ------------------
  369|     96|	    }
  370|    220|	  else
  371|    220|	    {
  372|    220|	      DPRINT(("tre_parse_bracket:   char: '%.*" STRF "'\n", REST(re)));
  ------------------
  |  |   27|    220|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 220]
  |  |  ------------------
  ------------------
  373|    220|	      if (*re == CHAR_MINUS && re + 1 < ctx->re_end
  ------------------
  |  |   39|    440|#define CHAR_MINUS	   L'-'
  ------------------
  |  Branch (373:12): [True: 68, False: 152]
  |  Branch (373:33): [True: 68, False: 0]
  ------------------
  374|     68|		  && *(re + 1) != CHAR_RBRACKET && ctx->re != re)
  ------------------
  |  |   38|    288|#define CHAR_RBRACKET	   L']'
  ------------------
  |  Branch (374:8): [True: 0, False: 68]
  |  Branch (374:38): [True: 0, False: 0]
  ------------------
  375|       |		/* Two ranges are not allowed to share and endpoint. */
  376|      0|		status = REG_ERANGE;
  377|    220|	      min = max = *re++;
  378|    220|	    }
  379|       |
  380|    327|	  if (status != REG_OK)
  ------------------
  |  Branch (380:8): [True: 0, False: 327]
  ------------------
  381|      0|	    break;
  382|       |
  383|    327|	  if (class && negate)
  ------------------
  |  Branch (383:8): [True: 0, False: 327]
  |  Branch (383:17): [True: 0, False: 0]
  ------------------
  384|      0|	    if (*num_neg_classes >= MAX_NEG_CLASSES)
  ------------------
  |  |  254|      0|#define MAX_NEG_CLASSES 64
  ------------------
  |  Branch (384:10): [True: 0, False: 0]
  ------------------
  385|      0|	      status = REG_ESPACE;
  386|      0|	    else
  387|      0|	      neg_classes[(*num_neg_classes)++] = class;
  388|    327|	  else if (!skip)
  ------------------
  |  Branch (388:13): [True: 231, False: 96]
  ------------------
  389|    231|	    {
  390|    231|	      status = tre_new_item(ctx->mem, min, max, &i, &max_i, items);
  391|    231|	      if (status != REG_OK)
  ------------------
  |  Branch (391:12): [True: 0, False: 231]
  ------------------
  392|      0|		break;
  393|    231|	      ((tre_literal_t*)((*items)[i-1])->obj)->u.class = class;
  394|    231|	    }
  395|       |
  396|       |	  /* Add opposite-case counterpoints if REG_ICASE is present.
  397|       |	     This is broken if there are more than two "same" characters. */
  398|    327|	  if (ctx->cflags & REG_ICASE && !class && status == REG_OK && !skip)
  ------------------
  |  |   99|    654|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  ------------------
  |  |  |  |   98|    327|#define REG_EXTENDED	1
  |  |  ------------------
  ------------------
  |  Branch (398:8): [True: 0, False: 327]
  |  Branch (398:35): [True: 0, False: 0]
  |  Branch (398:45): [True: 0, False: 0]
  |  Branch (398:65): [True: 0, False: 0]
  ------------------
  399|      0|	    {
  400|      0|	      tre_cint_t cmin, ccurr;
  401|       |
  402|      0|	      DPRINT(("adding opposite-case counterpoints\n"));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  403|      0|	      while (min <= max)
  ------------------
  |  Branch (403:15): [True: 0, False: 0]
  ------------------
  404|      0|		{
  405|      0|		  if (tre_islower(min))
  ------------------
  |  |   81|      0|#define tre_islower iswlower
  ------------------
  |  Branch (405:9): [True: 0, False: 0]
  ------------------
  406|      0|		    {
  407|      0|		      cmin = ccurr = tre_toupper(min++);
  ------------------
  |  |   95|      0|#define tre_toupper towupper
  ------------------
  408|      0|		      while (tre_islower(min) && tre_toupper(min) == ccurr + 1
  ------------------
  |  |   81|      0|#define tre_islower iswlower
  ------------------
              		      while (tre_islower(min) && tre_toupper(min) == ccurr + 1
  ------------------
  |  |   95|      0|#define tre_toupper towupper
  ------------------
  |  Branch (408:16): [True: 0, False: 0]
  |  Branch (408:36): [True: 0, False: 0]
  ------------------
  409|      0|			     && min <= max)
  ------------------
  |  Branch (409:12): [True: 0, False: 0]
  ------------------
  410|      0|			ccurr = tre_toupper(min++);
  ------------------
  |  |   95|      0|#define tre_toupper towupper
  ------------------
  411|      0|		      status = tre_new_item(ctx->mem, cmin, ccurr,
  412|      0|					    &i, &max_i, items);
  413|      0|		    }
  414|      0|		  else if (tre_isupper(min))
  ------------------
  |  |   85|      0|#define tre_isupper iswupper
  ------------------
  |  Branch (414:14): [True: 0, False: 0]
  ------------------
  415|      0|		    {
  416|      0|		      cmin = ccurr = tre_tolower(min++);
  ------------------
  |  |   94|      0|#define tre_tolower towlower
  ------------------
  417|      0|		      while (tre_isupper(min) && tre_tolower(min) == ccurr + 1
  ------------------
  |  |   85|      0|#define tre_isupper iswupper
  ------------------
              		      while (tre_isupper(min) && tre_tolower(min) == ccurr + 1
  ------------------
  |  |   94|      0|#define tre_tolower towlower
  ------------------
  |  Branch (417:16): [True: 0, False: 0]
  |  Branch (417:36): [True: 0, False: 0]
  ------------------
  418|      0|			     && min <= max)
  ------------------
  |  Branch (418:12): [True: 0, False: 0]
  ------------------
  419|      0|			ccurr = tre_tolower(min++);
  ------------------
  |  |   94|      0|#define tre_tolower towlower
  ------------------
  420|      0|		      status = tre_new_item(ctx->mem, cmin, ccurr,
  421|      0|					    &i, &max_i, items);
  422|      0|		    }
  423|      0|		  else min++;
  424|      0|		  if (status != REG_OK)
  ------------------
  |  Branch (424:9): [True: 0, False: 0]
  ------------------
  425|      0|		    break;
  426|      0|		}
  427|      0|	      if (status != REG_OK)
  ------------------
  |  Branch (427:12): [True: 0, False: 0]
  ------------------
  428|      0|		break;
  429|      0|	    }
  430|    327|	}
  431|    586|    }
  432|    259|  *num_items = i;
  433|    259|  *items_size = max_i;
  434|    259|  ctx->re = re;
  435|    259|  return status;
  436|    259|}
tre-parse.c:tre_expand_ctype:
  129|     96|{
  130|     96|  reg_errcode_t status = REG_OK;
  131|     96|  tre_cint_t c;
  132|     96|  int j, min = -1, max = 0;
  133|       |  //assert(TRE_MB_CUR_MAX == 1); It is the ctx->cur_max that matters
  134|       |
  135|     96|  DPRINT(("  expanding class to character ranges\n"));
  ------------------
  |  |   27|     96|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 96]
  |  |  ------------------
  ------------------
  136|  24.6k|  for (j = 0; (j < 256) && (status == REG_OK); j++)
  ------------------
  |  Branch (136:15): [True: 24.5k, False: 96]
  |  Branch (136:28): [True: 24.5k, False: 0]
  ------------------
  137|  24.5k|    {
  138|  24.5k|      c = (tre_cint_t) j;
  139|  24.5k|      if (tre_isctype(c, class)
  ------------------
  |  |  139|  49.1k|#define tre_isctype(c, type) iswctype(c, type)
  |  |  ------------------
  |  |  |  Branch (139:30): [True: 1.04k, False: 23.5k]
  |  |  ------------------
  ------------------
  140|  23.5k|	  || ((cflags & REG_ICASE)
  ------------------
  |  |   99|  23.5k|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  ------------------
  |  |  |  |   98|  23.5k|#define REG_EXTENDED	1
  |  |  ------------------
  ------------------
  |  Branch (140:8): [True: 0, False: 23.5k]
  ------------------
  141|      0|	      && (tre_isctype(tre_tolower(c), class)
  ------------------
  |  |  139|      0|#define tre_isctype(c, type) iswctype(c, type)
  |  |  ------------------
  |  |  |  Branch (139:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  142|      0|		  || tre_isctype(tre_toupper(c), class))))
  ------------------
  |  |  139|      0|#define tre_isctype(c, type) iswctype(c, type)
  |  |  ------------------
  |  |  |  Branch (139:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  143|  1.04k|{
  144|  1.04k|	  if (min < 0)
  ------------------
  |  Branch (144:8): [True: 102, False: 946]
  ------------------
  145|    102|	    min = c;
  146|  1.04k|	  max = c;
  147|  1.04k|	}
  148|  23.5k|      else if (min >= 0)
  ------------------
  |  Branch (148:16): [True: 102, False: 23.4k]
  ------------------
  149|    102|	{
  150|    102|	  DPRINT(("  range %c (%d) to %c (%d)\n", min, min, max, max));
  ------------------
  |  |   27|    102|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 102]
  |  |  ------------------
  ------------------
  151|    102|	  status = tre_new_item(mem, min, max, i, max_i, items);
  152|    102|	  min = -1;
  153|    102|	}
  154|  24.5k|    }
  155|     96|  if (min >= 0 && status == REG_OK)
  ------------------
  |  Branch (155:7): [True: 0, False: 96]
  |  Branch (155:19): [True: 0, False: 0]
  ------------------
  156|      0|    status = tre_new_item(mem, min, max, i, max_i, items);
  157|     96|  return status;
  158|     96|}
tre-parse.c:tre_new_item:
   99|    333|{
  100|    333|  reg_errcode_t status;
  101|    333|  tre_ast_node_t **array = *items;
  102|       |  /* Allocate more space if necessary. */
  103|    333|  if (*i >= *max_i)
  ------------------
  |  Branch (103:7): [True: 0, False: 333]
  ------------------
  104|      0|    {
  105|      0|      tre_ast_node_t **new_items;
  106|      0|      DPRINT(("out of array space, i = %d\n", *i));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  107|       |      /* If the array is already 1024 items large, give up -- there's
  108|       |	 probably an error in the regexp (e.g. not a '\0' terminated
  109|       |	 string and missing ']') */
  110|      0|      if (*max_i > 1024)
  ------------------
  |  Branch (110:11): [True: 0, False: 0]
  ------------------
  111|      0|	return REG_ESPACE;
  112|      0|      *max_i *= 2;
  113|      0|      new_items = xrealloc(array, sizeof(*items) * *max_i);
  ------------------
  |  |   70|      0|#define xrealloc(ptr, new_size) realloc(ptr, new_size)
  ------------------
  114|      0|      if (new_items == NULL)
  ------------------
  |  Branch (114:11): [True: 0, False: 0]
  ------------------
  115|      0|	return REG_ESPACE;
  116|      0|      *items = array = new_items;
  117|      0|    }
  118|    333|  array[*i] = tre_ast_new_literal(mem, min, max, -1);
  119|    333|  status = array[*i] == NULL ? REG_ESPACE : REG_OK;
  ------------------
  |  Branch (119:12): [True: 0, False: 333]
  ------------------
  120|    333|  (*i)++;
  121|    333|  return status;
  122|    333|}
tre-parse.c:tre_expand_macro:
   73|     56|{
   74|     56|  int i;
   75|       |
   76|     56|  buf[0] = 0;
   77|     56|  if (regex >= regex_end)
  ------------------
  |  Branch (77:7): [True: 0, False: 56]
  ------------------
   78|      0|    return;
   79|       |
   80|    728|  for (i = 0; tre_macros[i].expansion; i++)
  ------------------
  |  Branch (80:15): [True: 672, False: 56]
  ------------------
   81|    672|    {
   82|    672|      if (tre_macros[i].c == *regex)
  ------------------
  |  Branch (82:11): [True: 0, False: 672]
  ------------------
   83|      0|	{
   84|      0|	  unsigned int j;
   85|      0|	  DPRINT(("Expanding macro '%c' => '%s'\n",
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
   86|      0|		  tre_macros[i].c, tre_macros[i].expansion));
   87|       |	  // R_change:  - 1 is r62537
   88|      0|	  for (j = 0; tre_macros[i].expansion[j] && j < buf_len - 1; j++)
  ------------------
  |  Branch (88:16): [True: 0, False: 0]
  |  Branch (88:46): [True: 0, False: 0]
  ------------------
   89|      0|	    buf[j] = tre_macros[i].expansion[j];
   90|      0|	  buf[j] = 0;
   91|      0|	  break;
   92|      0|	}
   93|    672|    }
   94|     56|}

tre_stack_new:
   37|    618|{
   38|    618|  tre_stack_t *s;
   39|       |
   40|    618|  s = xmalloc(sizeof(*s));
  ------------------
  |  |   67|    618|#define xmalloc(size) malloc(size)
  ------------------
   41|    618|  if (s != NULL)
  ------------------
  |  Branch (41:7): [True: 618, False: 0]
  ------------------
   42|    618|    {
   43|    618|      s->stack = xmalloc(sizeof(*s->stack) * size);
  ------------------
  |  |   67|    618|#define xmalloc(size) malloc(size)
  ------------------
   44|    618|      if (s->stack == NULL)
  ------------------
  |  Branch (44:11): [True: 0, False: 618]
  ------------------
   45|      0|	{
   46|      0|	  xfree(s);
  ------------------
  |  |   69|      0|#define xfree(ptr) free(ptr)
  ------------------
   47|      0|	  return NULL;
   48|      0|	}
   49|    618|      s->size = size;
   50|    618|      s->max_size = max_size;
   51|    618|      s->increment = increment;
   52|    618|      s->ptr = 0;
   53|    618|    }
   54|    618|  return s;
   55|    618|}
tre_stack_destroy:
   59|    618|{
   60|    618|  xfree(s->stack);
  ------------------
  |  |   69|    618|#define xfree(ptr) free(ptr)
  ------------------
   61|    618|  xfree(s);
  ------------------
  |  |   69|    618|#define xfree(ptr) free(ptr)
  ------------------
   62|    618|}
tre_stack_num_objects:
   66|  35.9k|{
   67|  35.9k|  return s->ptr;
   68|  35.9k|}
tre_stack_push_int:
  110|  23.9k|  declare_pushf(typetag, type) {     \
  111|  23.9k|    union tre_stack_item item;	     \
  112|  23.9k|    item.typetag ## _value = value;  \
  113|  23.9k|    return tre_stack_push(s, item);  \
  114|  23.9k|}
tre_stack_push_voidptr:
  110|  23.3k|  declare_pushf(typetag, type) {     \
  111|  23.3k|    union tre_stack_item item;	     \
  112|  23.3k|    item.typetag ## _value = value;  \
  113|  23.3k|    return tre_stack_push(s, item);  \
  114|  23.3k|}
tre_stack_pop_int:
  120|  23.9k|  declare_popf(typetag, type) {			    \
  121|  23.9k|    return s->stack[--s->ptr].typetag ## _value;    \
  122|  23.9k|  }
tre_stack_pop_voidptr:
  120|  23.3k|  declare_popf(typetag, type) {			    \
  121|  23.3k|    return s->stack[--s->ptr].typetag ## _value;    \
  122|  23.3k|  }
tre-stack.c:tre_stack_push:
   72|  47.3k|{
   73|  47.3k|  if (s->ptr < s->size)
  ------------------
  |  Branch (73:7): [True: 47.3k, False: 0]
  ------------------
   74|  47.3k|    {
   75|  47.3k|      s->stack[s->ptr] = value;
   76|  47.3k|      s->ptr++;
   77|  47.3k|    }
   78|      0|  else
   79|      0|    {
   80|      0|      if (s->size >= s->max_size)
  ------------------
  |  Branch (80:11): [True: 0, False: 0]
  ------------------
   81|      0|	{
   82|      0|	  DPRINT(("tre_stack_push: stack full\n"));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
   83|      0|	  return REG_ESPACE;
   84|      0|	}
   85|      0|      else
   86|      0|	{
   87|      0|	  union tre_stack_item *new_buffer;
   88|      0|	  int new_size;
   89|      0|	  DPRINT(("tre_stack_push: trying to realloc more space\n"));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
   90|      0|	  new_size = s->size + s->increment;
   91|      0|	  if (new_size > s->max_size)
  ------------------
  |  Branch (91:8): [True: 0, False: 0]
  ------------------
   92|      0|	    new_size = s->max_size;
   93|      0|	  new_buffer = xrealloc(s->stack, sizeof(*new_buffer) * new_size);
  ------------------
  |  |   70|      0|#define xrealloc(ptr, new_size) realloc(ptr, new_size)
  ------------------
   94|      0|	  if (new_buffer == NULL)
  ------------------
  |  Branch (94:8): [True: 0, False: 0]
  ------------------
   95|      0|	    {
   96|      0|	      DPRINT(("tre_stack_push: realloc failed.\n"));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
   97|      0|	      return REG_ESPACE;
   98|      0|	    }
   99|      0|	  DPRINT(("tre_stack_push: realloc succeeded.\n"));
  ------------------
  |  |   27|      0|#define DPRINT(msg) do { } while(/*CONSTCOND*/(void)0,0)
  |  |  ------------------
  |  |  |  Branch (27:47): [Folded, False: 0]
  |  |  ------------------
  ------------------
  100|      0|	  assert(new_size > s->size);
  ------------------
  |  |   19|      0|#define assert(a) R_assert(a)
  |  |  ------------------
  |  |  |  |  230|      0|#define R_assert(e) ((e) ? (void) 0 : Rf_error("assertion '%s' failed in executing regexp: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (230:22): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  101|      0|	  s->size = new_size;
  102|      0|	  s->stack = new_buffer;
  103|      0|	  tre_stack_push(s, value);
  104|      0|	}
  105|      0|    }
  106|  47.3k|  return REG_OK;
  107|  47.3k|}

Rf_allocVector:
  608|  18.1M|{
  609|  18.1M|    return allocVector3(type, length, NULL);
  ------------------
  |  |  876|  18.1M|#define allocVector3		Rf_allocVector3
  ------------------
  610|  18.1M|}
CHKVEC:
  109|  80.5M|/*HIDDEN (inlining)*/ INLINE_FUN void CHKVEC(SEXP x) {
  110|  80.5M|    switch (TYPEOF(x)) {
  111|      0|    case CHARSXP:
  ------------------
  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (111:5): [True: 0, False: 80.5M]
  ------------------
  112|  8.30M|    case LGLSXP:
  ------------------
  |  |  121|  8.30M|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (112:5): [True: 8.30M, False: 72.2M]
  ------------------
  113|  52.5M|    case INTSXP:
  ------------------
  |  |  123|  52.5M|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (113:5): [True: 44.2M, False: 36.2M]
  ------------------
  114|  53.5M|    case REALSXP:
  ------------------
  |  |  124|  53.5M|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (114:5): [True: 983k, False: 79.5M]
  ------------------
  115|  53.5M|    case CPLXSXP:
  ------------------
  |  |  125|  53.5M|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (115:5): [True: 0, False: 80.5M]
  ------------------
  116|  60.2M|    case STRSXP:
  ------------------
  |  |  126|  60.2M|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (116:5): [True: 6.68M, False: 73.8M]
  ------------------
  117|  80.5M|    case VECSXP:
  ------------------
  |  |  131|  80.5M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (117:5): [True: 20.3M, False: 60.2M]
  ------------------
  118|  80.5M|    case EXPRSXP:
  ------------------
  |  |  132|  80.5M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (118:5): [True: 58, False: 80.5M]
  ------------------
  119|  80.5M|    case RAWSXP:
  ------------------
  |  |  136|  80.5M|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (119:5): [True: 7.07k, False: 80.5M]
  ------------------
  120|  80.5M|    case WEAKREFSXP:
  ------------------
  |  |  135|  80.5M|#define WEAKREFSXP  23    /* weak reference */
  ------------------
  |  Branch (120:5): [True: 0, False: 80.5M]
  ------------------
  121|  80.5M|	break;
  122|      0|    default:
  ------------------
  |  Branch (122:5): [True: 0, False: 80.5M]
  ------------------
  123|      0|	error("cannot get data pointer of '%s' objects", R_typeToChar(x));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  124|  80.5M|    }
  125|  80.5M|}
DATAPTR:
  130|  64.8M|INLINE_FUN void *DATAPTR(SEXP x) {
  131|  64.8M|    CHKVEC(x);
  132|  64.8M|    if (ALTREP(x))
  ------------------
  |  Branch (132:9): [True: 0, False: 64.8M]
  ------------------
  133|      0|	return ALTVEC_DATAPTR(x);
  134|  64.8M|#ifdef CATCH_ZERO_LENGTH_ACCESS
  135|       |    /* Attempts to read or write elements of a zero length vector will
  136|       |       result in a segfault, rather than read and write random memory.
  137|       |       Returning NULL would be more natural, but Matrix seems to assume
  138|       |       that even zero-length vectors have non-NULL data pointers, so
  139|       |       return (void *) 1 instead. Zero-length CHARSXP objects still
  140|       |       have a trailing zero byte so they are not handled. */
  141|  64.8M|    else if (STDVEC_LENGTH(x) == 0 && TYPEOF(x) != CHARSXP)
  ------------------
  |  |  120|  5.16k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (141:14): [True: 5.16k, False: 64.8M]
  |  Branch (141:39): [True: 5.16k, False: 0]
  ------------------
  142|  5.16k|	return (void *) 1;
  143|  64.8M|#endif
  144|  64.8M|    else
  145|  64.8M|	return STDVEC_DATAPTR(x);
  146|  64.8M|}
DATAPTR_RO:
  148|  15.6M|INLINE_FUN const void *DATAPTR_RO(SEXP x) {
  149|  15.6M|    CHKVEC(x);
  150|  15.6M|    if (ALTREP(x))
  ------------------
  |  Branch (150:9): [True: 852, False: 15.6M]
  ------------------
  151|    852|	return ALTVEC_DATAPTR_RO(x);
  152|  15.6M|    else
  153|  15.6M|	return STDVEC_DATAPTR(x);
  154|  15.6M|}
DATAPTR_OR_NULL:
  156|  2.22k|INLINE_FUN const void *DATAPTR_OR_NULL(SEXP x) {
  157|  2.22k|    CHKVEC(x);
  158|  2.22k|    if (ALTREP(x))
  ------------------
  |  Branch (158:9): [True: 0, False: 2.22k]
  ------------------
  159|      0|	return ALTVEC_DATAPTR_OR_NULL(x);
  160|  2.22k|    else
  161|  2.22k|	return STDVEC_DATAPTR(x);
  162|  2.22k|}
XLENGTH_EX:
  215|   303M|{
  216|   303M|    return ALTREP(x) ? ALTREP_LENGTH(x) : STDVEC_LENGTH(x);
  ------------------
  |  Branch (216:12): [True: 3.17k, False: 303M]
  ------------------
  217|   303M|}
XTRUELENGTH:
  220|  7.89M|{
  221|  7.89M|    return ALTREP(x) ? ALTREP_TRUELENGTH(x) : STDVEC_TRUELENGTH(x);
  ------------------
  |  Branch (221:12): [True: 0, False: 7.89M]
  ------------------
  222|  7.89M|}
LENGTH_EX:
  225|  37.7M|{
  226|  37.7M|    if (x == R_NilValue) return 0;
  ------------------
  |  Branch (226:9): [True: 0, False: 37.7M]
  ------------------
  227|  37.7M|    R_xlen_t len = XLENGTH(x);
  228|  37.7M|#ifdef LONG_VECTOR_SUPPORT
  229|  37.7M|    if (len > R_SHORT_LEN_MAX)
  ------------------
  |  |   77|  37.7M|# define R_SHORT_LEN_MAX 2147483647
  ------------------
  |  Branch (229:9): [True: 0, False: 37.7M]
  ------------------
  230|      0|	R_BadLongVector(x, file, line);
  231|  37.7M|#endif
  232|  37.7M|    return (int) len;
  233|  37.7M|}
LOGICAL0:
  333|  2.74M|/*HIDDEN (inlining)*/ INLINE_FUN int *LOGICAL0(SEXP x) {
  334|  2.74M|    CHECK_STDVEC_LGL(x);
  ------------------
  |  |  236|  2.74M|# define CHECK_STDVEC_LGL(x) do {				\
  |  |  237|  2.74M|	CHECK_VECTOR_LGL(x);					\
  |  |  ------------------
  |  |  |  |  165|  2.74M|# define CHECK_VECTOR_LGL(x) do {				\
  |  |  |  |  166|  2.74M|	if (TYPEOF(x) != LGLSXP) error("bad LGLSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|  2.74M|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  |               	if (TYPEOF(x) != LGLSXP) error("bad LGLSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (166:6): [True: 0, False: 2.74M]
  |  |  |  |  ------------------
  |  |  |  |  167|  2.74M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (167:14): [Folded, False: 2.74M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  238|  2.74M|	if (ALTREP(x)) error("bad standard LGLSXP vector");	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (238:6): [True: 0, False: 2.74M]
  |  |  ------------------
  |  |  239|  2.74M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (239:14): [Folded, False: 2.74M]
  |  |  ------------------
  ------------------
  335|  2.74M|    return (int *) STDVEC_DATAPTR(x);
  336|  2.74M|}
SCALAR_LVAL:
  338|  5.14M|HIDDEN INLINE_FUN int SCALAR_LVAL(SEXP x) {
  339|  5.14M|    CHECK_SCALAR_LGL(x);
  ------------------
  |  |  257|  5.14M|# define CHECK_SCALAR_LGL(x) do {				\
  |  |  258|  5.14M|	CHECK_VECTOR_LGL(x);					\
  |  |  ------------------
  |  |  |  |  165|  5.14M|# define CHECK_VECTOR_LGL(x) do {				\
  |  |  |  |  166|  5.14M|	if (TYPEOF(x) != LGLSXP) error("bad LGLSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|  5.14M|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  |               	if (TYPEOF(x) != LGLSXP) error("bad LGLSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (166:6): [True: 0, False: 5.14M]
  |  |  |  |  ------------------
  |  |  |  |  167|  5.14M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (167:14): [Folded, False: 5.14M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  259|  5.14M|	if (XLENGTH(x) != 1) error("bad LGLSXP scalar");	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (259:6): [True: 0, False: 5.14M]
  |  |  ------------------
  |  |  260|  5.14M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (260:14): [Folded, False: 5.14M]
  |  |  ------------------
  ------------------
  340|  5.14M|    return LOGICAL(x)[0];
  341|  5.14M|}
INTEGER0:
  348|  3.21M|/*HIDDEN (inlining)*/ INLINE_FUN int *INTEGER0(SEXP x) {
  349|  3.21M|    CHECK_STDVEC_INT(x);
  ------------------
  |  |  240|  3.21M|# define CHECK_STDVEC_INT(x) do {				\
  |  |  241|  3.21M|	CHECK_VECTOR_INT(x);					\
  |  |  ------------------
  |  |  |  |  168|  3.21M|# define CHECK_VECTOR_INT(x) do {				\
  |  |  |  |  169|  3.21M|	if (! (TYPEOF(x) == INTSXP || TYPEOF(x) == LGLSXP))	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|  6.42M|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  |               	if (! (TYPEOF(x) == INTSXP || TYPEOF(x) == LGLSXP))	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (169:9): [True: 3.21M, False: 0]
  |  |  |  |  |  Branch (169:32): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  170|  3.21M|	    error("bad INTSXP vector");				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  171|  3.21M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (171:14): [Folded, False: 3.21M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  242|  3.21M|	if (ALTREP(x)) error("bad standard INTSXP vector");	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (242:6): [True: 0, False: 3.21M]
  |  |  ------------------
  |  |  243|  3.21M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (243:14): [Folded, False: 3.21M]
  |  |  ------------------
  ------------------
  350|  3.21M|    return (int *) STDVEC_DATAPTR(x);
  351|  3.21M|}
SCALAR_IVAL:
  352|  2.33M|HIDDEN INLINE_FUN int SCALAR_IVAL(SEXP x) {
  353|  2.33M|    CHECK_SCALAR_INT(x);
  ------------------
  |  |  261|  2.33M|# define CHECK_SCALAR_INT(x) do {				\
  |  |  262|  2.33M|	CHECK_VECTOR_INT(x);					\
  |  |  ------------------
  |  |  |  |  168|  2.33M|# define CHECK_VECTOR_INT(x) do {				\
  |  |  |  |  169|  2.33M|	if (! (TYPEOF(x) == INTSXP || TYPEOF(x) == LGLSXP))	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|  4.66M|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  |               	if (! (TYPEOF(x) == INTSXP || TYPEOF(x) == LGLSXP))	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (169:9): [True: 2.33M, False: 0]
  |  |  |  |  |  Branch (169:32): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  170|  2.33M|	    error("bad INTSXP vector");				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  171|  2.33M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (171:14): [Folded, False: 2.33M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  263|  2.33M|	if (XLENGTH(x) != 1) error("bad INTSXP scalar");	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (263:6): [True: 0, False: 2.33M]
  |  |  ------------------
  |  |  264|  2.33M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (264:14): [Folded, False: 2.33M]
  |  |  ------------------
  ------------------
  354|  2.33M|    return INTEGER(x)[0];
  355|  2.33M|}
SET_SCALAR_IVAL:
  356|  3.10M|/*HIDDEN (inlining)*/ INLINE_FUN void SET_SCALAR_IVAL(SEXP x, int v) {
  357|  3.10M|    CHECK_SCALAR_INT(x);
  ------------------
  |  |  261|  3.10M|# define CHECK_SCALAR_INT(x) do {				\
  |  |  262|  3.10M|	CHECK_VECTOR_INT(x);					\
  |  |  ------------------
  |  |  |  |  168|  3.10M|# define CHECK_VECTOR_INT(x) do {				\
  |  |  |  |  169|  3.10M|	if (! (TYPEOF(x) == INTSXP || TYPEOF(x) == LGLSXP))	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|  6.20M|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  |               	if (! (TYPEOF(x) == INTSXP || TYPEOF(x) == LGLSXP))	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (169:9): [True: 3.10M, False: 0]
  |  |  |  |  |  Branch (169:32): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  170|  3.10M|	    error("bad INTSXP vector");				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  171|  3.10M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (171:14): [Folded, False: 3.10M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  263|  3.10M|	if (XLENGTH(x) != 1) error("bad INTSXP scalar");	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (263:6): [True: 0, False: 3.10M]
  |  |  ------------------
  |  |  264|  3.10M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (264:14): [Folded, False: 3.10M]
  |  |  ------------------
  ------------------
  358|  3.10M|    INTEGER(x)[0] = v;
  359|  3.10M|}
REAL0:
  361|  1.59M|/*HIDDEN*/ INLINE_FUN double *REAL0(SEXP x) {
  362|  1.59M|    CHECK_STDVEC_REAL(x);
  ------------------
  |  |  244|  1.59M|# define CHECK_STDVEC_REAL(x) do {				\
  |  |  245|  1.59M|	CHECK_VECTOR_REAL(x);					\
  |  |  ------------------
  |  |  |  |  172|  1.59M|# define CHECK_VECTOR_REAL(x) do {				\
  |  |  |  |  173|  1.59M|	if (TYPEOF(x) != REALSXP) error("bad REALSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|  1.59M|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  |               	if (TYPEOF(x) != REALSXP) error("bad REALSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (173:6): [True: 0, False: 1.59M]
  |  |  |  |  ------------------
  |  |  |  |  174|  1.59M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (174:14): [Folded, False: 1.59M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  246|  1.59M|	if (ALTREP(x)) error("bad standard REALSXP vector");	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (246:6): [True: 0, False: 1.59M]
  |  |  ------------------
  |  |  247|  1.59M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (247:14): [Folded, False: 1.59M]
  |  |  ------------------
  ------------------
  363|  1.59M|    return (double *) STDVEC_DATAPTR(x);
  364|  1.59M|}
SCALAR_DVAL:
  365|  1.65k|HIDDEN INLINE_FUN double SCALAR_DVAL(SEXP x) {
  366|  1.65k|    CHECK_SCALAR_REAL(x);
  ------------------
  |  |  265|  1.65k|# define CHECK_SCALAR_REAL(x) do {				\
  |  |  266|  1.65k|	CHECK_VECTOR_REAL(x);					\
  |  |  ------------------
  |  |  |  |  172|  1.65k|# define CHECK_VECTOR_REAL(x) do {				\
  |  |  |  |  173|  1.65k|	if (TYPEOF(x) != REALSXP) error("bad REALSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|  1.65k|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  |               	if (TYPEOF(x) != REALSXP) error("bad REALSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (173:6): [True: 0, False: 1.65k]
  |  |  |  |  ------------------
  |  |  |  |  174|  1.65k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (174:14): [Folded, False: 1.65k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  267|  1.65k|	if (XLENGTH(x) != 1) error("bad REALSXP scalar");	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (267:6): [True: 0, False: 1.65k]
  |  |  ------------------
  |  |  268|  1.65k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (268:14): [Folded, False: 1.65k]
  |  |  ------------------
  ------------------
  367|  1.65k|    return REAL(x)[0];
  368|  1.65k|}
SET_SCALAR_DVAL:
  369|  3.27k|/*HIDDEN (inlining)*/ INLINE_FUN void SET_SCALAR_DVAL(SEXP x, double v) {
  370|  3.27k|    CHECK_SCALAR_REAL(x);
  ------------------
  |  |  265|  3.27k|# define CHECK_SCALAR_REAL(x) do {				\
  |  |  266|  3.27k|	CHECK_VECTOR_REAL(x);					\
  |  |  ------------------
  |  |  |  |  172|  3.27k|# define CHECK_VECTOR_REAL(x) do {				\
  |  |  |  |  173|  3.27k|	if (TYPEOF(x) != REALSXP) error("bad REALSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|  3.27k|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  |               	if (TYPEOF(x) != REALSXP) error("bad REALSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (173:6): [True: 0, False: 3.27k]
  |  |  |  |  ------------------
  |  |  |  |  174|  3.27k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (174:14): [Folded, False: 3.27k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  267|  3.27k|	if (XLENGTH(x) != 1) error("bad REALSXP scalar");	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (267:6): [True: 0, False: 3.27k]
  |  |  ------------------
  |  |  268|  3.27k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (268:14): [Folded, False: 3.27k]
  |  |  ------------------
  ------------------
  371|  3.27k|    REAL(x)[0] = v;
  372|  3.27k|}
RAW0:
  387|  1.21M|/*HIDDEN (inlining)*/ INLINE_FUN Rbyte *RAW0(SEXP x) {
  388|  1.21M|    CHECK_STDVEC_RAW(x);
  ------------------
  |  |  252|  1.21M|# define CHECK_STDVEC_RAW(x) do {				\
  |  |  253|  1.21M|	CHECK_VECTOR_RAW(x);					\
  |  |  ------------------
  |  |  |  |  178|  1.21M|# define CHECK_VECTOR_RAW(x) do {				\
  |  |  |  |  179|  1.21M|	if (TYPEOF(x) != RAWSXP) error("bad RAWSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  136|  1.21M|#define RAWSXP      24    /* raw bytes */
  |  |  |  |  ------------------
  |  |  |  |               	if (TYPEOF(x) != RAWSXP) error("bad RAWSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:6): [True: 0, False: 1.21M]
  |  |  |  |  ------------------
  |  |  |  |  180|  1.21M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (180:14): [Folded, False: 1.21M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  254|  1.21M|	if (ALTREP(x)) error("bad standard RAWSXP vector");	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (254:6): [True: 0, False: 1.21M]
  |  |  ------------------
  |  |  255|  1.21M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (255:14): [Folded, False: 1.21M]
  |  |  ------------------
  ------------------
  389|  1.21M|    return (Rbyte *) STDVEC_DATAPTR(x);
  390|  1.21M|}
ALTREP_CLASS:
  400|  5.74k|INLINE_FUN SEXP ALTREP_CLASS(SEXP x) { return TAG(x); }
R_altrep_data1:
  402|  6.21k|INLINE_FUN SEXP R_altrep_data1(SEXP x) { return CAR(x); }
R_altrep_data2:
  403|  4.72k|INLINE_FUN SEXP R_altrep_data2(SEXP x) { return CDR(x); }
R_set_altrep_data1:
  404|      8|INLINE_FUN void R_set_altrep_data1(SEXP x, SEXP v) { SETCAR(x, v); }
R_set_altrep_data2:
  405|    201|INLINE_FUN void R_set_altrep_data2(SEXP x, SEXP v) { SETCDR(x, v); }
INTEGER_ELT:
  408|  1.95M|{
  409|  1.95M|    CHECK_VECTOR_INT_ELT(x, i);
  ------------------
  |  |  289|  1.95M|# define CHECK_VECTOR_INT_ELT(x, i) do {	\
  |  |  290|  1.95M|	SEXP ce__x__ = (x);			\
  |  |  291|  1.95M|	R_xlen_t ce__i__ = (i);			\
  |  |  292|  1.95M|	CHECK_VECTOR_INT(ce__x__);		\
  |  |  ------------------
  |  |  |  |  168|  1.95M|# define CHECK_VECTOR_INT(x) do {				\
  |  |  |  |  169|  1.95M|	if (! (TYPEOF(x) == INTSXP || TYPEOF(x) == LGLSXP))	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|  3.91M|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  |               	if (! (TYPEOF(x) == INTSXP || TYPEOF(x) == LGLSXP))	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (169:9): [True: 1.95M, False: 0]
  |  |  |  |  |  Branch (169:32): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  170|  1.95M|	    error("bad INTSXP vector");				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  171|  1.95M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (171:14): [Folded, False: 1.95M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  293|  1.95M|	CHECK_BOUNDS_ELT(ce__x__, ce__i__);	\
  |  |  ------------------
  |  |  |  |  278|  1.95M|# define CHECK_BOUNDS_ELT(x, i) do {			\
  |  |  |  |  279|  1.95M|	if (i < 0 || i > XLENGTH(x))			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (279:6): [True: 0, False: 1.95M]
  |  |  |  |  |  Branch (279:15): [True: 0, False: 1.95M]
  |  |  |  |  ------------------
  |  |  |  |  280|  1.95M|	    error("subscript out of bounds");		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  281|  1.95M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (281:14): [Folded, False: 1.95M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  294|  1.95M|} while (0)
  |  |  ------------------
  |  |  |  Branch (294:10): [Folded, False: 1.95M]
  |  |  ------------------
  ------------------
  410|  1.95M|    return ALTREP(x) ? ALTINTEGER_ELT(x, i) : INTEGER0(x)[i];
  ------------------
  |  Branch (410:12): [True: 337, False: 1.95M]
  ------------------
  411|  1.95M|}
SET_INTEGER_ELT:
  414|      2|{
  415|      2|    CHECK_VECTOR_INT_ELT(x, i);
  ------------------
  |  |  289|      2|# define CHECK_VECTOR_INT_ELT(x, i) do {	\
  |  |  290|      2|	SEXP ce__x__ = (x);			\
  |  |  291|      2|	R_xlen_t ce__i__ = (i);			\
  |  |  292|      2|	CHECK_VECTOR_INT(ce__x__);		\
  |  |  ------------------
  |  |  |  |  168|      2|# define CHECK_VECTOR_INT(x) do {				\
  |  |  |  |  169|      2|	if (! (TYPEOF(x) == INTSXP || TYPEOF(x) == LGLSXP))	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  |               	if (! (TYPEOF(x) == INTSXP || TYPEOF(x) == LGLSXP))	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (169:9): [True: 2, False: 0]
  |  |  |  |  |  Branch (169:32): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  170|      2|	    error("bad INTSXP vector");				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  171|      2|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (171:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  293|      2|	CHECK_BOUNDS_ELT(ce__x__, ce__i__);	\
  |  |  ------------------
  |  |  |  |  278|      2|# define CHECK_BOUNDS_ELT(x, i) do {			\
  |  |  |  |  279|      2|	if (i < 0 || i > XLENGTH(x))			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (279:6): [True: 0, False: 2]
  |  |  |  |  |  Branch (279:15): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  |  280|      2|	    error("subscript out of bounds");		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  281|      2|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (281:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  294|      2|} while (0)
  |  |  ------------------
  |  |  |  Branch (294:10): [Folded, False: 2]
  |  |  ------------------
  ------------------
  416|      2|    if (ALTREP(x)) ALTINTEGER_SET_ELT(x, i, v);
  ------------------
  |  Branch (416:9): [True: 0, False: 2]
  ------------------
  417|      2|    else INTEGER0(x)[i] = v;
  418|      2|}
LOGICAL_ELT:
  421|  2.34M|{
  422|  2.34M|    CHECK_VECTOR_LGL_ELT(x, i);
  ------------------
  |  |  283|  2.34M|# define CHECK_VECTOR_LGL_ELT(x, i) do {	\
  |  |  284|  2.34M|	SEXP ce__x__ = (x);			\
  |  |  285|  2.34M|	R_xlen_t ce__i__ = (i);			\
  |  |  286|  2.34M|	CHECK_VECTOR_LGL(ce__x__);		\
  |  |  ------------------
  |  |  |  |  165|  2.34M|# define CHECK_VECTOR_LGL(x) do {				\
  |  |  |  |  166|  2.34M|	if (TYPEOF(x) != LGLSXP) error("bad LGLSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|  2.34M|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  |               	if (TYPEOF(x) != LGLSXP) error("bad LGLSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (166:6): [True: 0, False: 2.34M]
  |  |  |  |  ------------------
  |  |  |  |  167|  2.34M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (167:14): [Folded, False: 2.34M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  287|  2.34M|	CHECK_BOUNDS_ELT(ce__x__, ce__i__);	\
  |  |  ------------------
  |  |  |  |  278|  2.34M|# define CHECK_BOUNDS_ELT(x, i) do {			\
  |  |  |  |  279|  2.34M|	if (i < 0 || i > XLENGTH(x))			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (279:6): [True: 0, False: 2.34M]
  |  |  |  |  |  Branch (279:15): [True: 0, False: 2.34M]
  |  |  |  |  ------------------
  |  |  |  |  280|  2.34M|	    error("subscript out of bounds");		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  281|  2.34M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (281:14): [Folded, False: 2.34M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  288|  2.34M|} while (0)
  |  |  ------------------
  |  |  |  Branch (288:10): [Folded, False: 2.34M]
  |  |  ------------------
  ------------------
  423|  2.34M|    return ALTREP(x) ? ALTLOGICAL_ELT(x, i) : LOGICAL0(x)[i];
  ------------------
  |  Branch (423:12): [True: 0, False: 2.34M]
  ------------------
  424|  2.34M|}
REAL_ELT:
  434|  1.10M|{
  435|  1.10M|    CHECK_VECTOR_REAL_ELT(x, i);
  ------------------
  |  |  295|  1.10M|# define CHECK_VECTOR_REAL_ELT(x, i) do {	\
  |  |  296|  1.10M|	SEXP ce__x__ = (x);			\
  |  |  297|  1.10M|	R_xlen_t ce__i__ = (i);			\
  |  |  298|  1.10M|	CHECK_VECTOR_REAL(ce__x__);		\
  |  |  ------------------
  |  |  |  |  172|  1.10M|# define CHECK_VECTOR_REAL(x) do {				\
  |  |  |  |  173|  1.10M|	if (TYPEOF(x) != REALSXP) error("bad REALSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|  1.10M|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  |               	if (TYPEOF(x) != REALSXP) error("bad REALSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (173:6): [True: 0, False: 1.10M]
  |  |  |  |  ------------------
  |  |  |  |  174|  1.10M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (174:14): [Folded, False: 1.10M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  299|  1.10M|	CHECK_BOUNDS_ELT(ce__x__, ce__i__);	\
  |  |  ------------------
  |  |  |  |  278|  1.10M|# define CHECK_BOUNDS_ELT(x, i) do {			\
  |  |  |  |  279|  1.10M|	if (i < 0 || i > XLENGTH(x))			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (279:6): [True: 0, False: 1.10M]
  |  |  |  |  |  Branch (279:15): [True: 0, False: 1.10M]
  |  |  |  |  ------------------
  |  |  |  |  280|  1.10M|	    error("subscript out of bounds");		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  281|  1.10M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (281:14): [Folded, False: 1.10M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  300|  1.10M|} while (0)
  |  |  ------------------
  |  |  |  Branch (300:10): [Folded, False: 1.10M]
  |  |  ------------------
  ------------------
  436|  1.10M|    return ALTREP(x) ? ALTREAL_ELT(x, i) : REAL0(x)[i];
  ------------------
  |  Branch (436:12): [True: 0, False: 1.10M]
  ------------------
  437|  1.10M|}
RAW_ELT:
  460|  49.4k|{
  461|  49.4k|    CHECK_VECTOR_RAW_ELT(x, i);
  ------------------
  |  |  307|  49.4k|# define CHECK_VECTOR_RAW_ELT(x, i) do {	\
  |  |  308|  49.4k|	SEXP ce__x__ = (x);			\
  |  |  309|  49.4k|	R_xlen_t ce__i__ = (i);			\
  |  |  310|  49.4k|	CHECK_VECTOR_RAW(ce__x__);		\
  |  |  ------------------
  |  |  |  |  178|  49.4k|# define CHECK_VECTOR_RAW(x) do {				\
  |  |  |  |  179|  49.4k|	if (TYPEOF(x) != RAWSXP) error("bad RAWSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  136|  49.4k|#define RAWSXP      24    /* raw bytes */
  |  |  |  |  ------------------
  |  |  |  |               	if (TYPEOF(x) != RAWSXP) error("bad RAWSXP vector");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:6): [True: 0, False: 49.4k]
  |  |  |  |  ------------------
  |  |  |  |  180|  49.4k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (180:14): [Folded, False: 49.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  311|  49.4k|	CHECK_BOUNDS_ELT(ce__x__, ce__i__);	\
  |  |  ------------------
  |  |  |  |  278|  49.4k|# define CHECK_BOUNDS_ELT(x, i) do {			\
  |  |  |  |  279|  49.4k|	if (i < 0 || i > XLENGTH(x))			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (279:6): [True: 0, False: 49.4k]
  |  |  |  |  |  Branch (279:15): [True: 0, False: 49.4k]
  |  |  |  |  ------------------
  |  |  |  |  280|  49.4k|	    error("subscript out of bounds");		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  281|  49.4k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (281:14): [Folded, False: 49.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  312|  49.4k|} while (0)
  |  |  ------------------
  |  |  |  Branch (312:10): [Folded, False: 49.4k]
  |  |  ------------------
  ------------------
  462|  49.4k|    return ALTREP(x) ? ALTRAW_ELT(x, i) : RAW0(x)[i];
  ------------------
  |  Branch (462:12): [True: 0, False: 49.4k]
  ------------------
  463|  49.4k|}
Rf_length:
  538|  23.0M|{
  539|  23.0M|    switch (TYPEOF(s)) {
  540|  1.18M|    case NILSXP:
  ------------------
  |  |  111|  1.18M|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (540:5): [True: 1.18M, False: 21.8M]
  ------------------
  541|  1.18M|	return 0;
  542|    833|    case LGLSXP:
  ------------------
  |  |  121|    833|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (542:5): [True: 833, False: 23.0M]
  ------------------
  543|   399k|    case INTSXP:
  ------------------
  |  |  123|   399k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (543:5): [True: 398k, False: 22.6M]
  ------------------
  544|   409k|    case REALSXP:
  ------------------
  |  |  124|   409k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (544:5): [True: 10.4k, False: 23.0M]
  ------------------
  545|   409k|    case CPLXSXP:
  ------------------
  |  |  125|   409k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (545:5): [True: 0, False: 23.0M]
  ------------------
  546|  6.61M|    case STRSXP:
  ------------------
  |  |  126|  6.61M|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (546:5): [True: 6.20M, False: 16.8M]
  ------------------
  547|  6.61M|    case CHARSXP:
  ------------------
  |  |  120|  6.61M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (547:5): [True: 0, False: 23.0M]
  ------------------
  548|  9.40M|    case VECSXP:
  ------------------
  |  |  131|  9.40M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (548:5): [True: 2.78M, False: 20.2M]
  ------------------
  549|  9.40M|    case EXPRSXP:
  ------------------
  |  |  132|  9.40M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (549:5): [True: 12, False: 23.0M]
  ------------------
  550|  9.40M|    case RAWSXP:
  ------------------
  |  |  136|  9.40M|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (550:5): [True: 0, False: 23.0M]
  ------------------
  551|  9.40M|	return LENGTH(s);
  552|  12.0M|    case LISTSXP:
  ------------------
  |  |  113|  12.0M|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (552:5): [True: 12.0M, False: 10.9M]
  ------------------
  553|  12.4M|    case LANGSXP:
  ------------------
  |  |  117|  12.4M|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (553:5): [True: 386k, False: 22.6M]
  ------------------
  554|  12.4M|    case DOTSXP:
  ------------------
  |  |  127|  12.4M|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (554:5): [True: 1.93k, False: 23.0M]
  ------------------
  555|  12.4M|    {
  556|  12.4M|	int i = 0;
  557|  30.7M|	while (s != NULL && s != R_NilValue) {
  ------------------
  |  Branch (557:9): [True: 30.7M, False: 0]
  |  Branch (557:22): [True: 18.3M, False: 12.4M]
  ------------------
  558|  18.3M|	    i++;
  559|  18.3M|	    s = CDR(s);
  560|  18.3M|	}
  561|  12.4M|	return i;
  562|  12.4M|    }
  563|     14|    case ENVSXP:
  ------------------
  |  |  115|     14|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (563:5): [True: 14, False: 23.0M]
  ------------------
  564|     14|	return Rf_envlength(s);
  565|  2.10k|    default:
  ------------------
  |  Branch (565:5): [True: 2.10k, False: 23.0M]
  ------------------
  566|  2.10k|	return 1;
  567|  23.0M|    }
  568|  23.0M|}
Rf_xlength:
  573|  30.1M|{
  574|  30.1M|    switch (TYPEOF(s)) {
  575|    165|    case NILSXP:
  ------------------
  |  |  111|    165|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (575:5): [True: 165, False: 30.1M]
  ------------------
  576|    165|	return 0;
  577|  1.54M|    case LGLSXP:
  ------------------
  |  |  121|  1.54M|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (577:5): [True: 1.54M, False: 28.6M]
  ------------------
  578|  2.32M|    case INTSXP:
  ------------------
  |  |  123|  2.32M|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (578:5): [True: 775k, False: 29.4M]
  ------------------
  579|  2.33M|    case REALSXP:
  ------------------
  |  |  124|  2.33M|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (579:5): [True: 8.62k, False: 30.1M]
  ------------------
  580|  2.33M|    case CPLXSXP:
  ------------------
  |  |  125|  2.33M|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (580:5): [True: 0, False: 30.1M]
  ------------------
  581|  14.7M|    case STRSXP:
  ------------------
  |  |  126|  14.7M|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (581:5): [True: 12.4M, False: 17.7M]
  ------------------
  582|  14.7M|    case CHARSXP:
  ------------------
  |  |  120|  14.7M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (582:5): [True: 0, False: 30.1M]
  ------------------
  583|  30.1M|    case VECSXP:
  ------------------
  |  |  131|  30.1M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (583:5): [True: 15.4M, False: 14.7M]
  ------------------
  584|  30.1M|    case EXPRSXP:
  ------------------
  |  |  132|  30.1M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (584:5): [True: 48, False: 30.1M]
  ------------------
  585|  30.1M|    case RAWSXP:
  ------------------
  |  |  136|  30.1M|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (585:5): [True: 0, False: 30.1M]
  ------------------
  586|  30.1M|	return XLENGTH(s);
  587|     70|    case LISTSXP:
  ------------------
  |  |  113|     70|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (587:5): [True: 70, False: 30.1M]
  ------------------
  588|    948|    case LANGSXP:
  ------------------
  |  |  117|    948|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (588:5): [True: 878, False: 30.1M]
  ------------------
  589|    948|    case DOTSXP:
  ------------------
  |  |  127|    948|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (589:5): [True: 0, False: 30.1M]
  ------------------
  590|    948|    {
  591|       |	// it is implausible this would be >= 2^31 elements, but allow it
  592|    948|	R_xlen_t i = 0;
  593|  3.65k|	while (s != NULL && s != R_NilValue) {
  ------------------
  |  Branch (593:9): [True: 3.65k, False: 0]
  |  Branch (593:22): [True: 2.70k, False: 948]
  ------------------
  594|  2.70k|	    i++;
  595|  2.70k|	    s = CDR(s);
  596|  2.70k|	}
  597|    948|	return i;
  598|    948|    }
  599|      0|    case ENVSXP:
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (599:5): [True: 0, False: 30.1M]
  ------------------
  600|      0|	return Rf_envxlength(s);
  601|      0|    default:
  ------------------
  |  Branch (601:5): [True: 0, False: 30.1M]
  ------------------
  602|      0|	return 1;
  603|  30.1M|    }
  604|  30.1M|}
Rf_list1:
  648|   390k|{
  649|   390k|    return CONS(s, R_NilValue);
  ------------------
  |  |  309|   390k|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  650|   390k|}
Rf_list2:
  654|   388k|{
  655|   388k|    PROTECT(s);
  ------------------
  |  |  357|   388k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  656|   388k|    s = CONS(s, list1(t));
  ------------------
  |  |  309|   388k|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  657|   388k|    UNPROTECT(1);
  ------------------
  |  |  358|   388k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  658|   388k|    return s;
  659|   388k|}
Rf_list3:
  663|    156|{
  664|    156|    PROTECT(s);
  ------------------
  |  |  357|    156|#define PROTECT(s)	Rf_protect(s)
  ------------------
  665|    156|    s = CONS(s, list2(t, u));
  ------------------
  |  |  309|    156|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  666|    156|    UNPROTECT(1);
  ------------------
  |  |  358|    156|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  667|    156|    return s;
  668|    156|}
Rf_list4:
  672|     24|{
  673|     24|    PROTECT(s);
  ------------------
  |  |  357|     24|#define PROTECT(s)	Rf_protect(s)
  ------------------
  674|     24|    s = CONS(s, list3(t, u, v));
  ------------------
  |  |  309|     24|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  675|     24|    UNPROTECT(1);
  ------------------
  |  |  358|     24|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  676|     24|    return s;
  677|     24|}
Rf_listAppend:
  698|     26|{
  699|     26|    SEXP r;
  700|     26|    if (s == R_NilValue)
  ------------------
  |  Branch (700:9): [True: 0, False: 26]
  ------------------
  701|      0|	return t;
  702|     26|    r = s;
  703|     26|    while (CDR(r) != R_NilValue)
  ------------------
  |  Branch (703:12): [True: 0, False: 26]
  ------------------
  704|      0|	r = CDR(r);
  705|     26|    SETCDR(r, t);
  706|     26|    return s;
  707|     26|}
Rf_lcons:
  716|  2.32M|{
  717|  2.32M|    SEXP e = cons(car, cdr);
  ------------------
  |  |  897|  2.32M|#define cons			Rf_cons
  ------------------
  718|  2.32M|    SET_TYPEOF(e, LANGSXP);
  ------------------
  |  |  117|  2.32M|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  719|  2.32M|    return e;
  720|  2.32M|}
Rf_lang1:
  723|     74|{
  724|     74|    return LCONS(s, R_NilValue);
  ------------------
  |  |  310|     74|#define LCONS(a, b)	Rf_lcons((a), (b))		/* language lists */
  ------------------
  725|     74|}
Rf_lang2:
  728|  1.66k|{
  729|  1.66k|    PROTECT(s);
  ------------------
  |  |  357|  1.66k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  730|  1.66k|    s = LCONS(s, list1(t));
  ------------------
  |  |  310|  1.66k|#define LCONS(a, b)	Rf_lcons((a), (b))		/* language lists */
  ------------------
  731|  1.66k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.66k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  732|  1.66k|    return s;
  733|  1.66k|}
Rf_lang3:
  736|   388k|{
  737|   388k|    PROTECT(s);
  ------------------
  |  |  357|   388k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  738|   388k|    s = LCONS(s, list2(t, u));
  ------------------
  |  |  310|   388k|#define LCONS(a, b)	Rf_lcons((a), (b))		/* language lists */
  ------------------
  739|   388k|    UNPROTECT(1);
  ------------------
  |  |  358|   388k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  740|   388k|    return s;
  741|   388k|}
Rf_lang4:
  744|    108|{
  745|    108|    PROTECT(s);
  ------------------
  |  |  357|    108|#define PROTECT(s)	Rf_protect(s)
  ------------------
  746|    108|    s = LCONS(s, list3(t, u, v));
  ------------------
  |  |  310|    108|#define LCONS(a, b)	Rf_lcons((a), (b))		/* language lists */
  ------------------
  747|    108|    UNPROTECT(1);
  ------------------
  |  |  358|    108|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  748|    108|    return s;
  749|    108|}
Rf_inherits:
  789|   779k|{
  790|   779k|    SEXP klass;
  791|   779k|    int i, nclass;
  792|   779k|    if (OBJECT(s)) {
  ------------------
  |  Branch (792:9): [True: 386k, False: 393k]
  ------------------
  793|   386k|	klass = getAttrib(s, R_ClassSymbol);
  ------------------
  |  |  924|   386k|#define getAttrib		Rf_getAttrib
  ------------------
  794|   386k|	nclass = length(klass);
  ------------------
  |  |  987|   386k|#define length(x)		Rf_length(x)
  ------------------
  795|   386k|	for (i = 0; i < nclass; i++) {
  ------------------
  |  Branch (795:14): [True: 386k, False: 18]
  ------------------
  796|   386k|	    if (!strcmp(CHAR(STRING_ELT(klass, i)), name))
  ------------------
  |  |  203|   386k|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (796:10): [True: 386k, False: 120]
  ------------------
  797|   386k|		return TRUE;
  798|   386k|	}
  799|   386k|    }
  800|   393k|    return FALSE;
  801|   779k|}
Rf_isScalarString:
  804|  20.5M|{
  805|  20.5M|    return TYPEOF(x) == STRSXP && XLENGTH(x) == 1;
  ------------------
  |  |  126|  41.1M|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (805:12): [True: 54, False: 20.5M]
  |  Branch (805:35): [True: 54, False: 0]
  ------------------
  806|  20.5M|}
Rf_isValidString:
  810|  13.4k|{
  811|  13.4k|    return TYPEOF(x) == STRSXP && LENGTH(x) > 0 && TYPEOF(STRING_ELT(x, 0)) != NILSXP;
  ------------------
  |  |  126|  26.9k|#define STRSXP	    16	  /* string vectors */
  ------------------
                  return TYPEOF(x) == STRSXP && LENGTH(x) > 0 && TYPEOF(STRING_ELT(x, 0)) != NILSXP;
  ------------------
  |  |  111|  17.3k|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (811:12): [True: 3.89k, False: 9.55k]
  |  Branch (811:35): [True: 3.89k, False: 0]
  |  Branch (811:52): [True: 3.89k, False: 0]
  ------------------
  812|  13.4k|}
Rf_isValidStringF:
  816|  3.84k|{
  817|  3.84k|    return isValidString(x) && CHAR(STRING_ELT(x, 0))[0];
  ------------------
  |  |  972|  3.84k|#define isValidString		Rf_isValidString
  ------------------
                  return isValidString(x) && CHAR(STRING_ELT(x, 0))[0];
  ------------------
  |  |  203|  3.84k|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (817:12): [True: 3.84k, False: 0]
  |  Branch (817:32): [True: 3.84k, False: 0]
  ------------------
  818|  3.84k|}
Rf_isUserBinop:
  821|  4.19k|{
  822|  4.19k|    if (TYPEOF(s) == SYMSXP) {
  ------------------
  |  |  112|  4.19k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (822:9): [True: 4.19k, False: 0]
  ------------------
  823|  4.19k|	const char *str = CHAR(PRINTNAME(s));
  ------------------
  |  |  203|  4.19k|#define CHAR(x) R_CHAR(x)
  ------------------
  824|  4.19k|	if (strlen(str) >= 2 && str[0] == '%' && str[strlen(str)-1] == '%')
  ------------------
  |  Branch (824:6): [True: 4.17k, False: 24]
  |  Branch (824:26): [True: 0, False: 4.17k]
  |  Branch (824:43): [True: 0, False: 0]
  ------------------
  825|      0|	    return TRUE;
  826|  4.19k|    }
  827|  4.19k|    return FALSE;
  828|  4.19k|}
Rf_isFunction:
  831|  1.94M|{
  832|  1.94M|    return (TYPEOF(s) == CLOSXP ||
  ------------------
  |  |  114|  3.88M|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (832:13): [True: 387k, False: 1.55M]
  ------------------
  833|  1.55M|	    TYPEOF(s) == BUILTINSXP ||
  ------------------
  |  |  119|  3.49M|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (833:6): [True: 59, False: 1.55M]
  ------------------
  834|  1.55M|	    TYPEOF(s) == SPECIALSXP);
  ------------------
  |  |  118|  1.55M|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (834:6): [True: 16, False: 1.55M]
  ------------------
  835|  1.94M|}
Rf_isPrimitive:
  838|      2|{
  839|      2|    return (TYPEOF(s) == BUILTINSXP ||
  ------------------
  |  |  119|      4|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (839:13): [True: 0, False: 2]
  ------------------
  840|      2|	    TYPEOF(s) == SPECIALSXP);
  ------------------
  |  |  118|      2|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (840:6): [True: 2, False: 0]
  ------------------
  841|      2|}
Rf_isList:
  844|  18.5M|{
  845|  18.5M|    return (s == R_NilValue || TYPEOF(s) == LISTSXP);
  ------------------
  |  |  113|  18.5M|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (845:13): [True: 96, False: 18.5M]
  |  Branch (845:32): [True: 1.17M, False: 17.3M]
  ------------------
  846|  18.5M|}
Rf_isNewList:
  850|  1.54M|{
  851|  1.54M|    return (s == R_NilValue || TYPEOF(s) == VECSXP);
  ------------------
  |  |  131|  1.54M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (851:13): [True: 14, False: 1.54M]
  |  Branch (851:32): [True: 1.54M, False: 0]
  ------------------
  852|  1.54M|}
Rf_isPairList:
  855|  1.16M|{
  856|  1.16M|    switch (TYPEOF(s)) {
  857|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (857:5): [True: 0, False: 1.16M]
  ------------------
  858|    108|    case LISTSXP:
  ------------------
  |  |  113|    108|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (858:5): [True: 108, False: 1.16M]
  ------------------
  859|  2.72k|    case LANGSXP:
  ------------------
  |  |  117|  2.72k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (859:5): [True: 2.61k, False: 1.16M]
  ------------------
  860|  3.67k|    case DOTSXP:
  ------------------
  |  |  127|  3.67k|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (860:5): [True: 952, False: 1.16M]
  ------------------
  861|  3.67k|	return TRUE;
  862|  1.16M|    default:
  ------------------
  |  Branch (862:5): [True: 1.16M, False: 3.67k]
  ------------------
  863|  1.16M|	return FALSE;
  864|  1.16M|    }
  865|  1.16M|}
Rf_isVectorList:
  868|  1.16M|{
  869|  1.16M|    switch (TYPEOF(s)) {
  870|   782k|    case VECSXP:
  ------------------
  |  |  131|   782k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (870:5): [True: 782k, False: 386k]
  ------------------
  871|   782k|    case EXPRSXP:
  ------------------
  |  |  132|   782k|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (871:5): [True: 0, False: 1.16M]
  ------------------
  872|   782k|	return TRUE;
  873|   386k|    default:
  ------------------
  |  Branch (873:5): [True: 386k, False: 782k]
  ------------------
  874|   386k|	return FALSE;
  875|  1.16M|    }
  876|  1.16M|}
Rf_isVectorAtomic:
  879|  5.08M|{
  880|  5.08M|    switch (TYPEOF(s)) {
  881|  2.34M|    case LGLSXP:
  ------------------
  |  |  121|  2.34M|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (881:5): [True: 2.34M, False: 2.74M]
  ------------------
  882|  3.91M|    case INTSXP:
  ------------------
  |  |  123|  3.91M|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (882:5): [True: 1.56M, False: 3.52M]
  ------------------
  883|  3.91M|    case REALSXP:
  ------------------
  |  |  124|  3.91M|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (883:5): [True: 5.55k, False: 5.08M]
  ------------------
  884|  3.91M|    case CPLXSXP:
  ------------------
  |  |  125|  3.91M|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (884:5): [True: 0, False: 5.08M]
  ------------------
  885|  3.91M|    case STRSXP:
  ------------------
  |  |  126|  3.91M|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (885:5): [True: 111, False: 5.08M]
  ------------------
  886|  3.91M|    case RAWSXP:
  ------------------
  |  |  136|  3.91M|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (886:5): [True: 0, False: 5.08M]
  ------------------
  887|  3.91M|	return TRUE;
  888|  1.17M|    default: /* including NULL */
  ------------------
  |  Branch (888:5): [True: 1.17M, False: 3.91M]
  ------------------
  889|  1.17M|	return FALSE;
  890|  5.08M|    }
  891|  5.08M|}
Rf_isVector:
  894|  98.7M|{
  895|  98.7M|    switch(TYPEOF(s)) {
  896|  2.74M|    case LGLSXP:
  ------------------
  |  |  121|  2.74M|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (896:5): [True: 2.74M, False: 95.9M]
  ------------------
  897|  42.3M|    case INTSXP:
  ------------------
  |  |  123|  42.3M|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (897:5): [True: 39.5M, False: 59.1M]
  ------------------
  898|  43.9M|    case REALSXP:
  ------------------
  |  |  124|  43.9M|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (898:5): [True: 1.60M, False: 97.1M]
  ------------------
  899|  43.9M|    case CPLXSXP:
  ------------------
  |  |  125|  43.9M|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (899:5): [True: 0, False: 98.7M]
  ------------------
  900|  55.5M|    case STRSXP:
  ------------------
  |  |  126|  55.5M|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (900:5): [True: 11.6M, False: 87.0M]
  ------------------
  901|  56.7M|    case RAWSXP:
  ------------------
  |  |  136|  56.7M|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (901:5): [True: 1.21M, False: 97.5M]
  ------------------
  902|       |
  903|  98.7M|    case VECSXP:
  ------------------
  |  |  131|  98.7M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (903:5): [True: 41.9M, False: 56.7M]
  ------------------
  904|  98.7M|    case EXPRSXP:
  ------------------
  |  |  132|  98.7M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (904:5): [True: 36, False: 98.7M]
  ------------------
  905|  98.7M|	return TRUE;
  906|  1.83k|    default:
  ------------------
  |  Branch (906:5): [True: 1.83k, False: 98.7M]
  ------------------
  907|  1.83k|	return FALSE;
  908|  98.7M|    }
  909|  98.7M|}
Rf_isLanguage:
  928|  11.5M|{
  929|  11.5M|    return (s == R_NilValue || TYPEOF(s) == LANGSXP);
  ------------------
  |  |  117|  11.5M|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (929:13): [True: 0, False: 11.5M]
  |  Branch (929:32): [True: 1.76k, False: 11.5M]
  ------------------
  930|  11.5M|}
Rf_isMatrix:
  933|    648|{
  934|    648|    SEXP t;
  935|    648|    if (isVector(s)) {
  ------------------
  |  |  974|    648|#define isVector		Rf_isVector
  ------------------
  |  Branch (935:9): [True: 648, False: 0]
  ------------------
  936|    648|	t = getAttrib(s, R_DimSymbol);
  ------------------
  |  |  924|    648|#define getAttrib		Rf_getAttrib
  ------------------
  937|       |	/* You are not supposed to be able to assign a non-integer dim,
  938|       |	   although this might be possible by misuse of ATTRIB. */
  939|    648|	if (TYPEOF(t) == INTSXP && LENGTH(t) == 2)
  ------------------
  |  |  123|  1.29k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (939:6): [True: 80, False: 568]
  |  Branch (939:29): [True: 80, False: 0]
  ------------------
  940|     80|	    return TRUE;
  941|    648|    }
  942|    568|    return FALSE;
  943|    648|}
Rf_isArray:
  946|  2.71M|{
  947|  2.71M|    SEXP t;
  948|  2.71M|    if (isVector(s)) {
  ------------------
  |  |  974|  2.71M|#define isVector		Rf_isVector
  ------------------
  |  Branch (948:9): [True: 2.71M, False: 0]
  ------------------
  949|  2.71M|	t = getAttrib(s, R_DimSymbol);
  ------------------
  |  |  924|  2.71M|#define getAttrib		Rf_getAttrib
  ------------------
  950|       |	/* You are not supposed to be able to assign a 0-length dim,
  951|       |	 nor a non-integer dim */
  952|  2.71M|	if (TYPEOF(t) == INTSXP && LENGTH(t) > 0)
  ------------------
  |  |  123|  5.42M|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (952:6): [True: 2.37k, False: 2.70M]
  |  Branch (952:29): [True: 2.37k, False: 0]
  ------------------
  953|  2.37k|	    return TRUE;
  954|  2.71M|    }
  955|  2.70M|    return FALSE;
  956|  2.71M|}
Rf_isTs:
  959|  1.54M|{
  960|  1.54M|    return (isVector(s) && getAttrib(s, R_TspSymbol) != R_NilValue);
  ------------------
  |  |  974|  1.54M|#define isVector		Rf_isVector
  ------------------
                  return (isVector(s) && getAttrib(s, R_TspSymbol) != R_NilValue);
  ------------------
  |  |  924|  1.54M|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (960:13): [True: 1.54M, False: 0]
  |  Branch (960:28): [True: 0, False: 1.54M]
  ------------------
  961|  1.54M|}
Rf_isInteger:
  965|  2.45k|{
  966|  2.45k|    return (TYPEOF(s) == INTSXP && !inherits(s, "factor"));
  ------------------
  |  |  123|  4.90k|#define INTSXP	    13	  /* integer vectors */
  ------------------
                  return (TYPEOF(s) == INTSXP && !inherits(s, "factor"));
  ------------------
  |  |  933|    664|#define inherits		Rf_inherits
  ------------------
  |  Branch (966:13): [True: 664, False: 1.78k]
  |  Branch (966:36): [True: 664, False: 0]
  ------------------
  967|  2.45k|}
Rf_isFactor:
  970|    352|{
  971|    352|    return (TYPEOF(s) == INTSXP  && inherits(s, "factor"));
  ------------------
  |  |  123|    704|#define INTSXP	    13	  /* integer vectors */
  ------------------
                  return (TYPEOF(s) == INTSXP  && inherits(s, "factor"));
  ------------------
  |  |  933|      4|#define inherits		Rf_inherits
  ------------------
  |  Branch (971:13): [True: 4, False: 348]
  |  Branch (971:37): [True: 0, False: 4]
  ------------------
  972|    352|}
Rf_isNumeric:
  986|  2.19k|{
  987|  2.19k|    switch(TYPEOF(s)) {
  988|  2.16k|    case INTSXP:
  ------------------
  |  |  123|  2.16k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (988:5): [True: 2.16k, False: 30]
  ------------------
  989|  2.16k|	if (inherits(s,"factor")) return FALSE;
  ------------------
  |  |  933|  2.16k|#define inherits		Rf_inherits
  ------------------
  |  Branch (989:6): [True: 0, False: 2.16k]
  ------------------
  990|  2.17k|    case LGLSXP:
  ------------------
  |  |  121|  2.17k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (990:5): [True: 8, False: 2.18k]
  ------------------
  991|  2.19k|    case REALSXP:
  ------------------
  |  |  124|  2.19k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (991:5): [True: 22, False: 2.17k]
  ------------------
  992|  2.19k|	return TRUE;
  993|      0|    default:
  ------------------
  |  Branch (993:5): [True: 0, False: 2.19k]
  ------------------
  994|      0|	return FALSE;
  995|  2.19k|    }
  996|  2.19k|}
Rf_isNumber:
 1000|    554|{
 1001|    554|    switch(TYPEOF(s)) {
 1002|    210|    case INTSXP:
  ------------------
  |  |  123|    210|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1002:5): [True: 210, False: 344]
  ------------------
 1003|    210|	if (inherits(s,"factor")) return FALSE;
  ------------------
  |  |  933|    210|#define inherits		Rf_inherits
  ------------------
  |  Branch (1003:6): [True: 0, False: 210]
  ------------------
 1004|    554|    case LGLSXP:
  ------------------
  |  |  121|    554|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1004:5): [True: 344, False: 210]
  ------------------
 1005|    554|    case REALSXP:
  ------------------
  |  |  124|    554|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1005:5): [True: 0, False: 554]
  ------------------
 1006|    554|    case CPLXSXP:
  ------------------
  |  |  125|    554|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1006:5): [True: 0, False: 554]
  ------------------
 1007|    554|	return TRUE;
 1008|      0|    default:
  ------------------
  |  Branch (1008:5): [True: 0, False: 554]
  ------------------
 1009|      0|	return FALSE;
 1010|    554|    }
 1011|    554|}
Rf_ScalarLogical:
 1016|  4.69M|{
 1017|  4.69M|    LibExtern SEXP R_LogicalNAValue, R_TrueValue, R_FalseValue;
  ------------------
  |  |   50|  4.69M|#define LibExtern extern LibImport
  ------------------
 1018|  4.69M|    if (x == NA_LOGICAL) return R_LogicalNAValue;
  ------------------
  |  |   55|  4.69M|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1018:9): [True: 32, False: 4.69M]
  ------------------
 1019|  4.69M|    else if (x != 0) return R_TrueValue;
  ------------------
  |  Branch (1019:14): [True: 20.2k, False: 4.66M]
  ------------------
 1020|  4.66M|    else return R_FalseValue;
 1021|  4.69M|}
Rf_ScalarInteger:
 1024|  3.10M|{
 1025|  3.10M|    SEXP ans = allocVector(INTSXP, 1);
  ------------------
  |  |  875|  3.10M|#define allocVector		Rf_allocVector
  ------------------
                  SEXP ans = allocVector(INTSXP, 1);
  ------------------
  |  |  123|  3.10M|#define INTSXP	    13	  /* integer vectors */
  ------------------
 1026|  3.10M|    SET_SCALAR_IVAL(ans, x);
 1027|  3.10M|    return ans;
 1028|  3.10M|}
Rf_ScalarReal:
 1031|  3.27k|{
 1032|  3.27k|    SEXP ans = allocVector(REALSXP, 1);
  ------------------
  |  |  875|  3.27k|#define allocVector		Rf_allocVector
  ------------------
                  SEXP ans = allocVector(REALSXP, 1);
  ------------------
  |  |  124|  3.27k|#define REALSXP	    14	  /* real variables */
  ------------------
 1033|  3.27k|    SET_SCALAR_DVAL(ans, x);
 1034|  3.27k|    return ans;
 1035|  3.27k|}
Rf_ScalarString:
 1045|   780k|{
 1046|   780k|    SEXP ans;
 1047|   780k|    PROTECT(x);
  ------------------
  |  |  357|   780k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1048|   780k|    ans = allocVector(STRSXP, (R_xlen_t)1);
  ------------------
  |  |  875|   780k|#define allocVector		Rf_allocVector
  ------------------
                  ans = allocVector(STRSXP, (R_xlen_t)1);
  ------------------
  |  |  126|   780k|#define STRSXP	    16	  /* string vectors */
  ------------------
 1049|   780k|    SET_STRING_ELT(ans, (R_xlen_t)0, x);
 1050|   780k|    UNPROTECT(1);
  ------------------
  |  |  358|   780k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1051|   780k|    return ans;
 1052|   780k|}
Rf_isVectorizable:
 1066|     11|{
 1067|     11|    if (s == R_NilValue) return TRUE;
  ------------------
  |  Branch (1067:9): [True: 0, False: 11]
  ------------------
 1068|     11|    else if (isNewList(s)) {
  ------------------
  |  |  955|     11|#define isNewList		Rf_isNewList
  ------------------
  |  Branch (1068:14): [True: 11, False: 0]
  ------------------
 1069|     11|	R_xlen_t i, n;
 1070|       |
 1071|     11|	n = XLENGTH(s);
 1072|    239|	for (i = 0 ; i < n; i++)
  ------------------
  |  Branch (1072:15): [True: 228, False: 11]
  ------------------
 1073|    228|	    if (!isVector(VECTOR_ELT(s, i)) || XLENGTH(VECTOR_ELT(s, i)) > 1)
  ------------------
  |  |  974|    228|#define isVector		Rf_isVector
  ------------------
  |  Branch (1073:10): [True: 0, False: 228]
  |  Branch (1073:41): [True: 0, False: 228]
  ------------------
 1074|      0|		return FALSE;
 1075|     11|	return TRUE;
 1076|     11|    }
 1077|      0|    else if (isList(s)) {
  ------------------
  |  |  951|      0|#define isList			Rf_isList
  ------------------
  |  Branch (1077:14): [True: 0, False: 0]
  ------------------
 1078|      0|	for ( ; s != R_NilValue; s = CDR(s))
  ------------------
  |  Branch (1078:10): [True: 0, False: 0]
  ------------------
 1079|      0|	    if (!isVector(CAR(s)) || LENGTH(CAR(s)) > 1) return FALSE;
  ------------------
  |  |  974|      0|#define isVector		Rf_isVector
  ------------------
  |  Branch (1079:10): [True: 0, False: 0]
  |  Branch (1079:31): [True: 0, False: 0]
  ------------------
 1080|      0|	return TRUE;
 1081|      0|    }
 1082|      0|    else return FALSE;
 1083|     11|}
Rf_mkString:
 1116|   392k|{
 1117|   392k|    SEXP t;
 1118|       |
 1119|   392k|    PROTECT(t = allocVector(STRSXP, (R_xlen_t)1));
  ------------------
  |  |  357|   392k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1120|   392k|    SET_STRING_ELT(t, (R_xlen_t)0, mkChar(s));
  ------------------
  |  |  998|   392k|#define mkChar			Rf_mkChar
  ------------------
 1121|   392k|    UNPROTECT(1);
  ------------------
  |  |  358|   392k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1122|   392k|    return t;
 1123|   392k|}
Rf_stringPositionTr:
 1127|  2.78k|stringPositionTr(SEXP string, const char *translatedElement) {
 1128|       |
 1129|  2.78k|    int slen = LENGTH(string);
 1130|  2.78k|    int i;
 1131|       |
 1132|  2.78k|    const void *vmax = vmaxget();
 1133|  5.68k|    for (i = 0 ; i < slen; i++) {
  ------------------
  |  Branch (1133:18): [True: 4.19k, False: 1.48k]
  ------------------
 1134|  4.19k|	Rboolean found = ! strcmp(translateChar(STRING_ELT(string, i)),
  ------------------
  |  | 1037|  4.19k|#define translateChar		Rf_translateChar
  ------------------
 1135|  4.19k|				  translatedElement);
 1136|  4.19k|	vmaxset(vmax);
 1137|  4.19k|        if (found)
  ------------------
  |  Branch (1137:13): [True: 1.29k, False: 2.89k]
  ------------------
 1138|  1.29k|            return i;
 1139|  4.19k|    }
 1140|  1.48k|    return -1; /* not found */
 1141|  2.78k|}
R_FixupRHS:
 1145|   385k|{
 1146|   385k|    if( y != R_NilValue && MAYBE_REFERENCED(y) ) {
  ------------------
  |  |  251|   385k|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 385k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1146:9): [True: 385k, False: 0]
  ------------------
 1147|   385k|	if (R_cycle_detected(x, y)) {
  ------------------
  |  Branch (1147:6): [True: 0, False: 385k]
  ------------------
 1148|       |#ifdef WARNING_ON_CYCLE_DETECT
 1149|       |	    warning("cycle detected");
 1150|       |	    R_cycle_detected(x, y);
 1151|       |#endif
 1152|      0|	    y = duplicate(y);
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 1153|      0|	}
 1154|   385k|	else ENSURE_NAMEDMAX(y);
 1155|   385k|    }
 1156|   385k|    return y;
 1157|   385k|}
CAR:
   93|   384M|{
   94|   384M|    if (BNDCELL_TAG(e))
  ------------------
  |  Branch (94:9): [True: 0, False: 384M]
  ------------------
   95|      0|	error("bad binding access");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
   96|   384M|    return CAR0(e);
   97|   384M|}

R_set_command_line_arguments:
   55|      2|{
   56|       |    // nothing here is ever freed.
   57|      2|    NumCommandLineArgs = argc;
   58|      2|    CommandLineArgs = (char**) calloc((size_t) argc, sizeof(char*));
   59|      2|    if(CommandLineArgs == NULL)
  ------------------
  |  Branch (59:8): [True: 0, False: 2]
  ------------------
   60|      0|	R_Suicide("allocation failure in R_set_command_line_arguments");
   61|       |
   62|     10|    for(int i = 0; i < argc; i++) {
  ------------------
  |  Branch (62:20): [True: 8, False: 2]
  ------------------
   63|      8|	CommandLineArgs[i] = strdup(argv[i]);
   64|      8|	if(CommandLineArgs[i] == NULL)
  ------------------
  |  Branch (64:5): [True: 0, False: 8]
  ------------------
   65|      0|	    R_Suicide("allocation failure in R_set_command_line_arguments");
   66|      8|    }
   67|      2|}
R_common_command_line:
   95|      2|{
   96|      2|    int ac = *pac, newac = 1;	/* argv[0] is process name */
   97|      2|    long lval; /* this is used for ppval, so 32-bit long is fine */
   98|      2|    char *p, **av = argv, msg[1024];
   99|      2|    Rboolean processing = TRUE;
  100|       |
  101|      2|    R_RestoreHistory = 1;
  102|      8|    while(--ac) {
  ------------------
  |  Branch (102:11): [True: 6, False: 2]
  ------------------
  103|      6|	if(processing && **++av == '-') {
  ------------------
  |  Branch (103:5): [True: 6, False: 0]
  |  Branch (103:19): [True: 6, False: 0]
  ------------------
  104|      6|	    if (!strcmp(*av, "--version")) {
  ------------------
  |  Branch (104:10): [True: 0, False: 6]
  ------------------
  105|      0|		PrintVersion(msg, 1024);
  ------------------
  |  | 1974|      0|# define PrintVersion		Rf_PrintVersion
  ------------------
  106|      0|		R_ShowMessage(msg);
  107|      0|		exit(0);
  108|      0|	    }
  109|      6|	    else if(!strcmp(*av, "--args")) {
  ------------------
  |  Branch (109:14): [True: 0, False: 6]
  ------------------
  110|       |		/* copy this through for further processing */
  111|      0|		argv[newac++] = *av;
  112|      0|		processing = FALSE;
  113|      0|	    }
  114|      6|	    else if(!strcmp(*av, "--save")) {
  ------------------
  |  Branch (114:14): [True: 0, False: 6]
  ------------------
  115|      0|		Rp->SaveAction = SA_SAVE;
  116|      0|	    }
  117|      6|	    else if(!strcmp(*av, "--no-save")) {
  ------------------
  |  Branch (117:14): [True: 0, False: 6]
  ------------------
  118|      0|		Rp->SaveAction = SA_NOSAVE;
  119|      0|	    }
  120|      6|	    else if(!strcmp(*av, "--restore")) {
  ------------------
  |  Branch (120:14): [True: 0, False: 6]
  ------------------
  121|      0|		Rp->RestoreAction = SA_RESTORE;
  122|      0|	    }
  123|      6|	    else if(!strcmp(*av, "--no-restore")) {
  ------------------
  |  Branch (123:14): [True: 2, False: 4]
  ------------------
  124|      2|		Rp->RestoreAction = SA_NORESTORE;
  125|      2|		R_RestoreHistory = 0;
  126|      2|	    }
  127|      4|	    else if(!strcmp(*av, "--no-restore-data")) {
  ------------------
  |  Branch (127:14): [True: 0, False: 4]
  ------------------
  128|      0|		Rp->RestoreAction = SA_NORESTORE;
  129|      0|	    }
  130|      4|	    else if(!strcmp(*av, "--no-restore-history")) {
  ------------------
  |  Branch (130:14): [True: 0, False: 4]
  ------------------
  131|      0|		R_RestoreHistory = 0;
  132|      0|	    }
  133|      4|	    else if (!strcmp(*av, "--silent") ||
  ------------------
  |  Branch (133:15): [True: 0, False: 4]
  ------------------
  134|      4|		     !strcmp(*av, "--quiet") ||
  ------------------
  |  Branch (134:8): [True: 0, False: 4]
  ------------------
  135|      4|		     !strcmp(*av, "-q")) {
  ------------------
  |  Branch (135:8): [True: 0, False: 4]
  ------------------
  136|      0|		Rp->R_Quiet = TRUE;
  137|      0|	    }
  138|      4|	    else if (!strcmp(*av, "--vanilla")) {
  ------------------
  |  Branch (138:15): [True: 2, False: 2]
  ------------------
  139|      2|		Rp->SaveAction = SA_NOSAVE; /* --no-save */
  140|      2|		Rp->RestoreAction = SA_NORESTORE; /* --no-restore */
  141|      2|		R_RestoreHistory = 0;     // --no-restore-history (= part of --no-restore)
  142|      2|		Rp->LoadSiteFile = FALSE; /* --no-site-file */
  143|      2|		Rp->LoadInitFile = FALSE; /* --no-init-file */
  144|      2|		Rp->NoRenviron = TRUE;    // --no-environ
  145|       |#ifdef Win32
  146|       |		R_LoadRconsole = FALSE;
  147|       |#endif
  148|      2|	    }
  149|      2|	    else if (!strcmp(*av, "--no-environ")) {
  ------------------
  |  Branch (149:15): [True: 0, False: 2]
  ------------------
  150|      0|		Rp->NoRenviron = TRUE;
  151|      0|	    }
  152|      2|	    else if (!strcmp(*av, "--verbose")) {
  ------------------
  |  Branch (152:15): [True: 0, False: 2]
  ------------------
  153|      0|		Rp->R_Verbose = TRUE;
  154|      0|	    }
  155|      2|	    else if (!strcmp(*av, "--no-echo") ||
  ------------------
  |  Branch (155:15): [True: 2, False: 0]
  ------------------
  156|      0|		     !strcmp(*av, "--slave") || // "deprecated" from R 4.0.0 (spring 2020)
  ------------------
  |  Branch (156:8): [True: 0, False: 0]
  ------------------
  157|      2|		     !strcmp(*av, "-s")) {
  ------------------
  |  Branch (157:8): [True: 0, False: 0]
  ------------------
  158|      2|		Rp->R_Quiet = TRUE;
  159|      2|		Rp->R_NoEcho = TRUE;
  160|      2|		Rp->SaveAction = SA_NOSAVE;
  161|      2|	    }
  162|      0|	    else if (!strcmp(*av, "--no-site-file")) {
  ------------------
  |  Branch (162:15): [True: 0, False: 0]
  ------------------
  163|      0|		Rp->LoadSiteFile = FALSE;
  164|      0|	    }
  165|      0|	    else if (!strcmp(*av, "--no-init-file")) {
  ------------------
  |  Branch (165:15): [True: 0, False: 0]
  ------------------
  166|      0|		Rp->LoadInitFile = FALSE;
  167|      0|	    }
  168|       |	    /* Undocumented and unused.
  169|       |	     else if (!strcmp(*av, "--debug-init")) {
  170|       |	    	Rp->DebugInitFile = TRUE;
  171|       |	     */
  172|      0|	    else if (!strncmp(*av, "--encoding", 10)) {
  ------------------
  |  Branch (172:15): [True: 0, False: 0]
  ------------------
  173|      0|		if(strlen(*av) < 12) {
  ------------------
  |  Branch (173:6): [True: 0, False: 0]
  ------------------
  174|      0|		    if(ac > 1) {ac--; av++; p = *av;} else p = NULL;
  ------------------
  |  Branch (174:10): [True: 0, False: 0]
  ------------------
  175|      0|		} else p = &(*av)[11];
  176|      0|		if (p == NULL) {
  ------------------
  |  Branch (176:7): [True: 0, False: 0]
  ------------------
  177|      0|		    R_ShowMessage(_("WARNING: no value given for --encoding"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  178|      0|		} else {
  179|      0|		    strncpy(R_StdinEnc, p, 30);
  180|      0|		    R_StdinEnc[30] = '\0';
  181|      0|		}
  182|      0|	    }
  183|       |#ifdef Win32
  184|       |	    else if (!strcmp(*av, "--no-Rconsole")) {
  185|       |		R_LoadRconsole = 0;
  186|       |	    }
  187|       |#endif
  188|      0|	    else if (!strcmp(*av, "-save") ||
  ------------------
  |  Branch (188:15): [True: 0, False: 0]
  ------------------
  189|      0|		     !strcmp(*av, "-nosave") ||
  ------------------
  |  Branch (189:8): [True: 0, False: 0]
  ------------------
  190|      0|		     !strcmp(*av, "-restore") ||
  ------------------
  |  Branch (190:8): [True: 0, False: 0]
  ------------------
  191|      0|		     !strcmp(*av, "-norestore") ||
  ------------------
  |  Branch (191:8): [True: 0, False: 0]
  ------------------
  192|      0|		     !strcmp(*av, "-noreadline") ||
  ------------------
  |  Branch (192:8): [True: 0, False: 0]
  ------------------
  193|      0|		     !strcmp(*av, "-quiet") ||
  ------------------
  |  Branch (193:8): [True: 0, False: 0]
  ------------------
  194|      0|		     !strcmp(*av, "-nsize") ||
  ------------------
  |  Branch (194:8): [True: 0, False: 0]
  ------------------
  195|      0|		     !strcmp(*av, "-vsize") ||
  ------------------
  |  Branch (195:8): [True: 0, False: 0]
  ------------------
  196|      0|		     !strncmp(*av, "--max-nsize", 11) ||
  ------------------
  |  Branch (196:8): [True: 0, False: 0]
  ------------------
  197|      0|		     !strncmp(*av, "--max-vsize", 11) ||
  ------------------
  |  Branch (197:8): [True: 0, False: 0]
  ------------------
  198|      0|		     !strcmp(*av, "-V") ||
  ------------------
  |  Branch (198:8): [True: 0, False: 0]
  ------------------
  199|      0|		     !strcmp(*av, "-n") ||
  ------------------
  |  Branch (199:8): [True: 0, False: 0]
  ------------------
  200|      0|		     !strcmp(*av, "-v")) {
  ------------------
  |  Branch (200:8): [True: 0, False: 0]
  ------------------
  201|      0|		snprintf(msg, 1024,
  202|      0|			 _("WARNING: option '%s' no longer supported"), *av);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  203|      0|		R_ShowMessage(msg);
  204|      0|	    }
  205|       |	    /* mop up --min-[nv]size */
  206|      0|	    else if( !strncmp(*av, "--min-nsize", 11) ||
  ------------------
  |  Branch (206:15): [True: 0, False: 0]
  ------------------
  207|      0|		     !strncmp(*av, "--min-vsize", 11) ) {
  ------------------
  |  Branch (207:8): [True: 0, False: 0]
  ------------------
  208|      0|		if(strlen(*av) < 13) {
  ------------------
  |  Branch (208:6): [True: 0, False: 0]
  ------------------
  209|      0|		    if(ac > 1) {ac--; av++; p = *av;} else p = NULL;
  ------------------
  |  Branch (209:10): [True: 0, False: 0]
  ------------------
  210|      0|		} else p = &(*av)[12];
  211|      0|		if (p == NULL) {
  ------------------
  |  Branch (211:7): [True: 0, False: 0]
  ------------------
  212|      0|		    snprintf(msg, 1024,
  213|      0|			     _("WARNING: no value given for '%s'"), *av);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  214|      0|		    R_ShowMessage(msg);
  215|      0|		    break;
  216|      0|		}
  217|      0|		int ierr;
  218|      0|		R_size_t value;
  219|      0|		value = R_Decode2Long(p, &ierr);
  220|      0|		if(ierr) {
  ------------------
  |  Branch (220:6): [True: 0, False: 0]
  ------------------
  221|      0|		    if(ierr < 0)
  ------------------
  |  Branch (221:10): [True: 0, False: 0]
  ------------------
  222|      0|			snprintf(msg, 1024,
  223|      0|				 _("WARNING: '%s' value is invalid: ignored"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  224|      0|				 *av);
  225|      0|		    else
  226|      0|			snprintf(msg, 1024,
  227|      0|				 _("WARNING: %s: too large and ignored"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  228|      0|				 *av);
  229|      0|		    R_ShowMessage(msg);
  230|       |
  231|      0|		} else {
  232|      0|		    if(!strncmp(*av, "--min-nsize", 11)) Rp->nsize = value;
  ------------------
  |  Branch (232:10): [True: 0, False: 0]
  ------------------
  233|      0|		    if(!strncmp(*av, "--min-vsize", 11)) Rp->vsize = value;
  ------------------
  |  Branch (233:10): [True: 0, False: 0]
  ------------------
  234|      0|		}
  235|      0|	    }
  236|      0|	    else if(strncmp(*av, "--max-ppsize", 12) == 0) {
  ------------------
  |  Branch (236:14): [True: 0, False: 0]
  ------------------
  237|      0|		if(strlen(*av) < 14) {
  ------------------
  |  Branch (237:6): [True: 0, False: 0]
  ------------------
  238|      0|		    if(ac > 1) {ac--; av++; p = *av;} else p = NULL;
  ------------------
  |  Branch (238:10): [True: 0, False: 0]
  ------------------
  239|      0|		} else p = &(*av)[13];
  240|      0|		if (p == NULL) {
  ------------------
  |  Branch (240:7): [True: 0, False: 0]
  ------------------
  241|      0|		    R_ShowMessage(_("WARNING: no value given for '--max-ppsize'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  242|      0|		    break;
  243|      0|		}
  244|      0|		lval = strtol(p, &p, 10);
  245|      0|		if (lval < 0)
  ------------------
  |  Branch (245:7): [True: 0, False: 0]
  ------------------
  246|      0|		    R_ShowMessage(_("WARNING: '--max-ppsize' value is negative: ignored"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  247|      0|		else if (lval < 10000)
  ------------------
  |  Branch (247:12): [True: 0, False: 0]
  ------------------
  248|      0|		    R_ShowMessage(_("WARNING: '--max-ppsize' value is too small: ignored"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  249|      0|		else if (lval > 500000)
  ------------------
  |  Branch (249:12): [True: 0, False: 0]
  ------------------
  250|      0|		    R_ShowMessage(_("WARNING: '--max-ppsize' value is too large: ignored"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  251|      0|		else Rp->ppsize = (size_t) lval;
  252|      0|	    }
  253|      0|	    else if(strncmp(*av, "--max-connections", 17) == 0) {
  ------------------
  |  Branch (253:14): [True: 0, False: 0]
  ------------------
  254|      0|		if(strlen(*av) < 19) {
  ------------------
  |  Branch (254:6): [True: 0, False: 0]
  ------------------
  255|      0|		    if(ac > 1) {ac--; av++; p = *av;} else p = NULL;
  ------------------
  |  Branch (255:10): [True: 0, False: 0]
  ------------------
  256|      0|		} else p = &(*av)[18];
  257|      0|		if (p == NULL) {
  ------------------
  |  Branch (257:7): [True: 0, False: 0]
  ------------------
  258|      0|		    R_ShowMessage(_("WARNING: no value given for '--max-connections'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  259|      0|		    break;
  260|      0|		}
  261|      0|		lval = strtol(p, &p, 10);
  262|      0|		if (lval < 0)
  ------------------
  |  Branch (262:7): [True: 0, False: 0]
  ------------------
  263|      0|		    R_ShowMessage(_("WARNING: '--max-connections' value is negative: ignored"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  264|      0|		else if (lval < 128)
  ------------------
  |  Branch (264:12): [True: 0, False: 0]
  ------------------
  265|      0|		    R_ShowMessage(_("WARNING: '--max-connections' value is too small: ignored"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  266|      0|		else if (lval > 4096)
  ------------------
  |  Branch (266:12): [True: 0, False: 0]
  ------------------
  267|      0|		    R_ShowMessage(_("WARNING: '--max-connections' value is too large: ignored"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  268|      0|		else Rp->nconnections = (int) lval;
  269|      0|	    }
  270|      0|	    else { /* unknown -option */
  271|      0|		argv[newac++] = *av;
  272|      0|	    }
  273|      6|	}
  274|      0|	else {
  275|      0|	    argv[newac++] = *av;
  276|      0|	}
  277|      6|    }
  278|      2|    *pac = newac;
  279|      2|    return;
  280|      2|}

InitDynload:
  148|      2|{
  149|      2|    initLoadedDLL();
  150|      2|    int which = addDLL(Rstrdup("base"), "base", NULL);
  151|      2|    DllInfo *dll = LoadedDLL[which];
  152|      2|    R_init_base(dll);
  153|      2|    InitFunctionHashing();
  ------------------
  |  | 1913|      2|# define InitFunctionHashing	Rf_InitFunctionHashing
  ------------------
  154|      2|}
R_useDynamicSymbols:
  283|     12|{
  284|     12|    Rboolean old;
  285|     12|    old = info->useDynamicLookup;
  286|     12|    info->useDynamicLookup = value;
  287|     12|    return old;
  288|     12|}
R_forceSymbols:
  292|     12|{
  293|     12|    Rboolean old;
  294|     12|    old = info->forceSymbols;
  295|     12|    info->forceSymbols = value;
  296|     12|    return old;
  297|     12|}
R_registerRoutines:
  358|     12|{
  359|     12|    int i, num;
  360|       |
  361|     12|    if(info == NULL)
  ------------------
  |  Branch (361:8): [True: 0, False: 12]
  ------------------
  362|      0|	error(_("R_RegisterRoutines called with invalid DllInfo object."));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("R_RegisterRoutines called with invalid DllInfo object."));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  363|       |
  364|       |    /* Default is to look in registered and then dynamic (unless
  365|       |       the is no handle such as in "base" or "embedded")
  366|       |       Potentially change in the future to be only registered
  367|       |       if there are any registered values.
  368|       |    */
  369|     12|    info->useDynamicLookup = (info->handle) ? TRUE : FALSE;
  ------------------
  |  Branch (369:30): [True: 10, False: 2]
  ------------------
  370|     12|    info->forceSymbols = FALSE;
  371|       |
  372|     12|    if(croutines) {
  ------------------
  |  Branch (372:8): [True: 2, False: 10]
  ------------------
  373|     24|	for(num = 0; croutines[num].name != NULL; num++) {;}
  ------------------
  |  Branch (373:15): [True: 22, False: 2]
  ------------------
  374|      2|	info->CSymbols = (Rf_DotCSymbol*)calloc((size_t) num,
  375|      2|						sizeof(Rf_DotCSymbol));
  376|      2|	if (!info->CSymbols)
  ------------------
  |  Branch (376:6): [True: 0, False: 2]
  ------------------
  377|      0|	    error("allocation failure in R_registerRoutines");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  378|      2|	info->numCSymbols = num;
  379|     24|	for(i = 0; i < num; i++) {
  ------------------
  |  Branch (379:13): [True: 22, False: 2]
  ------------------
  380|     22|	    R_addCRoutine(info, croutines+i, info->CSymbols + i);
  381|     22|	}
  382|      2|    }
  383|       |
  384|     12|    if(fortranRoutines) {
  ------------------
  |  Branch (384:8): [True: 4, False: 8]
  ------------------
  385|     46|	for(num = 0; fortranRoutines[num].name != NULL; num++) {;}
  ------------------
  |  Branch (385:15): [True: 42, False: 4]
  ------------------
  386|      4|	info->FortranSymbols =
  387|      4|	    (Rf_DotFortranSymbol*)calloc((size_t) num,
  388|      4|					 sizeof(Rf_DotFortranSymbol));
  389|      4|	if (!info->FortranSymbols) {
  ------------------
  |  Branch (389:6): [True: 0, False: 4]
  ------------------
  390|      0|	    free(info->CSymbols);
  391|      0|	    error("allocation failure in R_registerRoutines");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  392|      0|	}
  393|      4|	info->numFortranSymbols = num;
  394|     46|	for(i = 0; i < num; i++)
  ------------------
  |  Branch (394:13): [True: 42, False: 4]
  ------------------
  395|     42|	    R_addFortranRoutine(info, fortranRoutines+i,
  396|     42|				info->FortranSymbols + i);
  397|      4|    }
  398|       |
  399|     12|    if(callRoutines) {
  ------------------
  |  Branch (399:8): [True: 12, False: 0]
  ------------------
  400|    516|	for(num = 0; callRoutines[num].name != NULL; num++) {;}
  ------------------
  |  Branch (400:15): [True: 504, False: 12]
  ------------------
  401|     12|	info->CallSymbols =
  402|     12|	    (Rf_DotCallSymbol*)calloc((size_t) num, sizeof(Rf_DotCallSymbol));
  403|     12|	if (!info->CallSymbols) {
  ------------------
  |  Branch (403:6): [True: 0, False: 12]
  ------------------
  404|      0|	    free(info->CSymbols);
  405|      0|	    free(info->FortranSymbols);
  406|      0|	    error("allocation failure in R_registerRoutines");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  407|      0|	}
  408|     12|	info->numCallSymbols = num;
  409|    516|	for(i = 0; i < num; i++)
  ------------------
  |  Branch (409:13): [True: 504, False: 12]
  ------------------
  410|    504|	    R_addCallRoutine(info, callRoutines+i, info->CallSymbols + i);
  411|     12|    }
  412|       |
  413|     12|    if(externalRoutines) {
  ------------------
  |  Branch (413:8): [True: 8, False: 4]
  ------------------
  414|    218|	for(num = 0; externalRoutines[num].name != NULL; num++) {;}
  ------------------
  |  Branch (414:15): [True: 210, False: 8]
  ------------------
  415|      8|	info->ExternalSymbols =
  416|      8|	    (Rf_DotExternalSymbol*)calloc((size_t) num,
  417|      8|					  sizeof(Rf_DotExternalSymbol));
  418|      8|	if (!info->ExternalSymbols) {
  ------------------
  |  Branch (418:6): [True: 0, False: 8]
  ------------------
  419|      0|	    free(info->CSymbols);
  420|      0|	    free(info->FortranSymbols);
  421|      0|	    free(info->CallSymbols);
  422|      0|	    error("allocation failure in R_registerRoutines");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  423|      0|	}
  424|      8|	info->numExternalSymbols = num;
  425|       |
  426|    218|	for(i = 0; i < num; i++)
  ------------------
  |  Branch (426:13): [True: 210, False: 8]
  ------------------
  427|    210|	    R_addExternalRoutine(info, externalRoutines+i,
  428|    210|				 info->ExternalSymbols + i);
  429|      8|    }
  430|       |
  431|     12|    return(1);
  432|     12|}
R_dlsym:
 1112|     74|{
 1113|     74|    size_t len = strlen(name) + 4;
 1114|     74|    char buf[len]; /* up to 3 additional underscores */
 1115|     74|    DL_FUNC f;
 1116|       |
 1117|     74|    f = R_getDLLRegisteredSymbol(info, name, symbol);
 1118|     74|    if(f) return(f);
  ------------------
  |  Branch (1118:8): [True: 74, False: 0]
  ------------------
 1119|       |
 1120|       |
 1121|      0|    if(info->useDynamicLookup == FALSE) return(NULL);
  ------------------
  |  Branch (1121:8): [True: 0, False: 0]
  ------------------
 1122|       |
 1123|      0|#ifdef HAVE_NO_SYMBOL_UNDERSCORE
 1124|      0|    snprintf(buf, len, "%s", name);
 1125|       |#else
 1126|       |    snprintf(buf, len, "_%s", name);
 1127|       |#endif
 1128|       |
 1129|       |/* HAVE_F77_EXTRA_UNDERSCORE is only use here and not in F77_NAME etc.
 1130|       |   It seems of only historical interest */
 1131|      0|#ifdef HAVE_F77_UNDERSCORE
 1132|      0|    if(symbol && symbol->type == R_FORTRAN_SYM) {
  ------------------
  |  Branch (1132:8): [True: 0, False: 0]
  |  Branch (1132:18): [True: 0, False: 0]
  ------------------
 1133|      0|	strcat(buf, "_");
 1134|       |# ifdef HAVE_F77_EXTRA_UNDERSCORE
 1135|       |	if(strchr(name, '_')) strcat(buf, "_");
 1136|       |# endif
 1137|      0|    }
 1138|      0|#endif
 1139|       |
 1140|      0|    f = (DL_FUNC) R_osDynSymbol->dlsym(info, buf);
 1141|      0|#ifdef HAVE_F77_UNDERSCORE
 1142|      0|    if (!f && symbol && symbol->type == R_ANY_SYM) {
  ------------------
  |  Branch (1142:9): [True: 0, False: 0]
  |  Branch (1142:15): [True: 0, False: 0]
  |  Branch (1142:25): [True: 0, False: 0]
  ------------------
 1143|      0|	strcat(buf, "_");
 1144|       |# ifdef HAVE_F77_EXTRA_UNDERSCORE
 1145|       |	if(strchr(name, '_')) strcat(buf, "_");
 1146|       |# endif
 1147|      0|	f = (DL_FUNC) R_osDynSymbol->dlsym(info, buf);
 1148|      0|    }
 1149|      0|#endif
 1150|       |
 1151|      0|    if (f && symbol)
  ------------------
  |  Branch (1151:9): [True: 0, False: 0]
  |  Branch (1151:14): [True: 0, False: 0]
  ------------------
 1152|      0|	symbol->dll = info;
 1153|      0|    return f;
 1154|      0|}
do_dynload:
 1238|     10|{
 1239|     10|    char buf[2 * R_PATH_MAX];
 1240|     10|    DllInfo *info;
 1241|       |
 1242|     10|    checkArity(op,args);
  ------------------
  |  | 1788|     10|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1243|     10|    if (!isString(CAR(args)) || LENGTH(CAR(args)) != 1)
  ------------------
  |  |  966|     10|#define isString		Rf_isString
  ------------------
  |  Branch (1243:9): [True: 0, False: 10]
  |  Branch (1243:33): [True: 0, False: 10]
  ------------------
 1244|      0|	error(_("character argument expected"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("character argument expected"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1245|     10|    GetFullDLLPath(call, buf, sizeof(buf),
 1246|     10|                   translateCharFP(STRING_ELT(CAR(args), 0)));
  ------------------
  |  | 1998|     10|# define translateCharFP	Rf_translateCharFP
  ------------------
 1247|       |    /* AddDLL does this DeleteDLL(buf); */
 1248|     10|    info = AddDLL(buf, LOGICAL(CADR(args))[0], LOGICAL(CADDR(args))[0],
 1249|     10|		  translateCharFP(STRING_ELT(CADDDR(args), 0)));
  ------------------
  |  | 1998|     10|# define translateCharFP	Rf_translateCharFP
  ------------------
 1250|     10|    if(!info)
  ------------------
  |  Branch (1250:8): [True: 0, False: 10]
  ------------------
 1251|      0|	error(_("unable to load shared object '%s':\n  %s"), buf, DLLerror);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("unable to load shared object '%s':\n  %s"), buf, DLLerror);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1252|     10|    return(Rf_MakeDLLInfo(info));
 1253|     10|}
R_getSymbolInfo:
 1460|     74|{
 1461|     74|    const void *vmax = vmaxget();
 1462|     74|    const char *package, *name;
 1463|     74|    R_RegisteredNativeSymbol symbol = {R_ANY_SYM, {NULL}, NULL};
 1464|     74|    SEXP sym = R_NilValue;
 1465|     74|    DL_FUNC f = NULL;
 1466|       |
 1467|     74|    package = "";
 1468|       |
 1469|     74|    if (!isString(sname) || LENGTH(sname) != 1)
  ------------------
  |  |  966|     74|#define isString		Rf_isString
  ------------------
  |  Branch (1469:9): [True: 0, False: 74]
  |  Branch (1469:29): [True: 0, False: 74]
  ------------------
 1470|      0|	error(_("invalid '%s' argument"), "name");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "name");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1471|     74|    name = translateCharFP(STRING_ELT(sname, 0));
  ------------------
  |  | 1998|     74|# define translateCharFP	Rf_translateCharFP
  ------------------
 1472|       |
 1473|     74|    if(length(spackage)) {
  ------------------
  |  |  987|     74|#define length(x)		Rf_length(x)
  |  |  ------------------
  |  |  |  Branch (987:20): [True: 74, False: 0]
  |  |  ------------------
  ------------------
 1474|     74|	if(TYPEOF(spackage) == STRSXP)
  ------------------
  |  |  126|     74|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1474:5): [True: 0, False: 74]
  ------------------
 1475|      0|	    package = translateCharFP(STRING_ELT(spackage, 0));
  ------------------
  |  | 1998|      0|# define translateCharFP	Rf_translateCharFP
  ------------------
 1476|     74|	else if(TYPEOF(spackage) == EXTPTRSXP &&
  ------------------
  |  |  134|    148|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (1476:10): [True: 74, False: 0]
  ------------------
 1477|     74|		R_ExternalPtrTag(spackage) == install("DLLInfo")) {
  ------------------
  |  |  934|     74|#define install			Rf_install
  ------------------
  |  Branch (1477:3): [True: 74, False: 0]
  ------------------
 1478|     74|	    DllInfo *dll = (DllInfo *) R_ExternalPtrAddr(spackage);
 1479|     74|	    if (!dll)
  ------------------
  |  Branch (1479:10): [True: 0, False: 74]
  ------------------
 1480|      0|		error(_("NULL value passed for DllInfo"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("NULL value passed for DllInfo"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1481|     74|	    f = R_dlsym(dll, name, &symbol);
 1482|     74|	    package = NULL;
 1483|     74|	} else
 1484|      0|	    error(_("must pass package name or DllInfo reference"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("must pass package name or DllInfo reference"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1485|     74|    }
 1486|       |
 1487|     74|    if(package)
  ------------------
  |  Branch (1487:8): [True: 0, False: 74]
  ------------------
 1488|      0|	f = R_FindSymbol(name, package, &symbol);
 1489|       |
 1490|     74|    if(f)
  ------------------
  |  Branch (1490:8): [True: 74, False: 0]
  ------------------
 1491|     74|	sym = createRSymbolObject(sname, f, &symbol,
 1492|     74|				  asBool2(withRegistrationInfo, R_NilValue));
  ------------------
  |  | 1860|     74|# define asBool2	       	Rf_asBool2
  ------------------
 1493|       |
 1494|     74|    vmaxset(vmax);
 1495|     74|    return sym;
 1496|     74|}
R_getDllTable:
 1500|      2|{
 1501|      2|    int i;
 1502|      2|    SEXP ans, nm;
 1503|       |
 1504|      2| again:
 1505|      2|    PROTECT(ans = allocVector(VECSXP, CountDLL));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1506|      4|    for(i = 0; i < CountDLL; i++)
  ------------------
  |  Branch (1506:16): [True: 2, False: 2]
  ------------------
 1507|      2|	SET_VECTOR_ELT(ans, i, Rf_MakeDLLInfo(LoadedDLL[i]));
 1508|       |    
 1509|      2|    setAttrib(ans, R_ClassSymbol, mkString("DLLInfoList"));
  ------------------
  |  | 1027|      2|#define setAttrib		Rf_setAttrib
  ------------------
                  setAttrib(ans, R_ClassSymbol, mkString("DLLInfoList"));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
 1510|      2|    UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1511|       |
 1512|       |    /* There is a problem here: The allocations can cause gc, and gc
 1513|       |       may result in no longer referenced DLLs being unloaded.  So
 1514|       |       CountDLL can be reduced during this loop.  A simple work-around
 1515|       |       is to just try again until CountDLL at the end is the same as
 1516|       |       it was at the beginning.  LT */
 1517|      2|    if (CountDLL != LENGTH(ans))
  ------------------
  |  Branch (1517:9): [True: 0, False: 2]
  ------------------
 1518|      0|	goto again;
 1519|       |
 1520|      2|    PROTECT(ans);
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1521|      2|    PROTECT(nm = allocVector(STRSXP, CountDLL));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1522|      2|    setAttrib(ans, R_NamesSymbol, nm);
  ------------------
  |  | 1027|      2|#define setAttrib		Rf_setAttrib
  ------------------
 1523|      4|    for(int i = 0; i < CountDLL; i++)
  ------------------
  |  Branch (1523:20): [True: 2, False: 2]
  ------------------
 1524|      2|	SET_STRING_ELT(nm, i,
 1525|       |	               /* ->name from DllInfo */
 1526|      2|		       STRING_ELT(VECTOR_ELT(VECTOR_ELT(ans, i), 0), 0));
 1527|      2|    UNPROTECT(2);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1528|      2|    return(ans);
 1529|      2|}
R_getRegisteredRoutines:
 1668|     10|{
 1669|     10|    DllInfo *info;
 1670|     10|    SEXP ans, snames;
 1671|     10|    int i;
 1672|     10|    const char * const names[] = {".C", ".Call", ".Fortran", ".External"};
 1673|       |
 1674|     10|    if(TYPEOF(dll) != EXTPTRSXP &&
  ------------------
  |  |  134|     20|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (1674:8): [True: 0, False: 10]
  ------------------
 1675|      0|       R_ExternalPtrTag(dll) != install("DLLInfo"))
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
  |  Branch (1675:8): [True: 0, False: 0]
  ------------------
 1676|      0|	error(_("R_getRegisteredRoutines() expects a DllInfo reference"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("R_getRegisteredRoutines() expects a DllInfo reference"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1677|       |
 1678|     10|    info = (DllInfo *) R_ExternalPtrAddr(dll);
 1679|     10|    if(!info) error(_("NULL value passed for DllInfo"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if(!info) error(_("NULL value passed for DllInfo"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (1679:8): [True: 0, False: 10]
  ------------------
 1680|       |
 1681|       |
 1682|     10|    PROTECT(ans = allocVector(VECSXP, 4));
  ------------------
  |  |  357|     10|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1683|       |
 1684|     10|    SET_VECTOR_ELT(ans, 0, R_getRoutineSymbols(R_C_SYM, info));
 1685|     10|    SET_VECTOR_ELT(ans, 1, R_getRoutineSymbols(R_CALL_SYM, info));
 1686|     10|    SET_VECTOR_ELT(ans, 2, R_getRoutineSymbols(R_FORTRAN_SYM, info));
 1687|     10|    SET_VECTOR_ELT(ans, 3, R_getRoutineSymbols(R_EXTERNAL_SYM, info));
 1688|       |
 1689|     10|    PROTECT(snames = allocVector(STRSXP, 4));
  ------------------
  |  |  357|     10|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1690|     50|    for(i = 0; i < 4; i++)
  ------------------
  |  Branch (1690:16): [True: 40, False: 10]
  ------------------
 1691|     40|	SET_STRING_ELT(snames, i, mkChar(names[i]));
  ------------------
  |  |  998|     40|#define mkChar			Rf_mkChar
  ------------------
 1692|     10|    setAttrib(ans, R_NamesSymbol, snames);
  ------------------
  |  | 1027|     10|#define setAttrib		Rf_setAttrib
  ------------------
 1693|     10|    UNPROTECT(2);
  ------------------
  |  |  358|     10|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1694|     10|    return(ans);
 1695|     10|}
do_getSymbolInfo:
 1699|     74|{
 1700|     74|    checkArity(op, args);
  ------------------
  |  | 1788|     74|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1701|     74|    return R_getSymbolInfo(CAR(args), CADR(args), CADDR(args));
 1702|     74|}
do_getDllTable:
 1707|      2|{
 1708|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1709|      2|    return R_getDllTable();
 1710|      2|}
do_getRegisteredRoutines:
 1714|     10|{
 1715|     10|    checkArity(op, args);
  ------------------
  |  | 1788|     10|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1716|     10|    return R_getRegisteredRoutines(CAR(args));
 1717|     10|}
R_RegisterCCallable:
 1749|     12|{
 1750|     12|    SEXP penv = get_package_CEntry_table(package);
 1751|     12|    PROTECT(penv);
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1752|     12|    SEXP eptr = R_MakeExternalPtrFn(fptr, R_NilValue, R_NilValue);
 1753|     12|    PROTECT(eptr);
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1754|     12|    defineVar(install(name), eptr, penv);
  ------------------
  |  |  905|     12|#define defineVar		Rf_defineVar
  ------------------
                  defineVar(install(name), eptr, penv);
  ------------------
  |  |  934|     12|#define install			Rf_install
  ------------------
 1755|     12|    UNPROTECT(2);
  ------------------
  |  |  358|     12|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1756|     12|}
Rdynload.c:initLoadedDLL:
  159|      2|{
  160|      2|    if (CountDLL != 0 || LoadedDLL != NULL)
  ------------------
  |  Branch (160:9): [True: 0, False: 2]
  |  Branch (160:26): [True: 0, False: 2]
  ------------------
  161|      0|	R_Suicide("DLL table corruption detected"); /* not translated */
  162|       |
  163|       |    /* Note that it is likely that dlopen will use up at least one file
  164|       |       descriptor for each DLL loaded (it may load further dynamically
  165|       |       linked libraries), so we do not want to get close to the fd limit
  166|       |       (which may be as low as 256).
  167|       |
  168|       |       When R_MAX_NUM_DLLS environment variable is set and is in range
  169|       |       [100,1000] and the fd limit is sufficient or can be increased,
  170|       |       this becomes the maximum number of DLLs. Otherwise, R fails to start.
  171|       |
  172|       |       When R_MAX_NUM_DLLS is not set, R uses a reasonable default value
  173|       |       that matches the fd limit. R attempts to increase the limit if it
  174|       |       is too small. The goal for maximum number of DLLs is currently 614.
  175|       |
  176|       |       The limit receives increased attention with 'workflow'
  177|       |       documents which load increasingly more packages, hitting the
  178|       |       default fd limit of 256 on macOS systems.
  179|       |    */
  180|       |
  181|      2|    char *req = getenv("R_MAX_NUM_DLLS");
  182|      2|    if (req != NULL) {
  ------------------
  |  Branch (182:9): [True: 0, False: 2]
  ------------------
  183|       |	/* set exactly the requested limit, or fail */
  184|      0|	int reqlimit = atoi(req);
  185|      0|	if (reqlimit < 100) {
  ------------------
  |  Branch (185:6): [True: 0, False: 0]
  ------------------
  186|      0|	    char msg[128];
  187|      0|	    snprintf(msg, 128,
  188|      0|	      _("R_MAX_NUM_DLLS must be at least %d"), 100);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  189|      0|	    R_Suicide(msg);
  190|      0|	}
  191|      0|	if (reqlimit > 1000) {
  ------------------
  |  Branch (191:6): [True: 0, False: 0]
  ------------------
  192|      0|	    char msg[128];
  193|      0|	    snprintf(msg, 128,
  194|      0|	      _("R_MAX_NUM_DLLS cannot be bigger than %d"), 1000);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  195|      0|	    R_Suicide(msg);
  196|      0|	}
  197|      0|	int needed_fds = (int)ceil(reqlimit / 0.6);
  198|      0|	int fdlimit = R_EnsureFDLimit(needed_fds);
  199|      0|	if (fdlimit < 0 && reqlimit > 100) {
  ------------------
  |  Branch (199:6): [True: 0, False: 0]
  |  Branch (199:21): [True: 0, False: 0]
  ------------------
  200|       |	    /* this is very unlikely */
  201|      0|	    char msg[128];
  202|      0|	    snprintf(msg, 128,
  203|      0|	      _("R_MAX_NUM_DLLS cannot be bigger than %d when fd limit is not known"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  204|      0|	      100);
  205|      0|	    R_Suicide(msg);
  206|      0|	} else if (fdlimit >= 0 && fdlimit < needed_fds) {
  ------------------
  |  Branch (206:13): [True: 0, False: 0]
  |  Branch (206:29): [True: 0, False: 0]
  ------------------
  207|      0|	    int maxdlllimit = (int) (0.6 * fdlimit);
  208|      0|	    if (maxdlllimit < 100)
  ------------------
  |  Branch (208:10): [True: 0, False: 0]
  ------------------
  209|      0|		R_Suicide(_("the limit on the number of open files is too low"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  210|      0|	    char msg[128];
  211|      0|	    snprintf(msg, 128,
  212|      0|	      _("R_MAX_NUM_DLLS bigger than %d may exhaust open files limit"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  213|      0|	      maxdlllimit);
  214|      0|	    R_Suicide(msg);
  215|      0|	}
  216|       |	/* when fdlimit == -1 (not known), currently only reqlimit of 100 is
  217|       |	   allowed */
  218|      0|	MaxNumDLLs = reqlimit;
  219|      2|    } else {
  220|       |	/* set a reasonable default limit */
  221|      2|	int needed_fds = 1024;
  222|      2|	int fdlimit = R_EnsureFDLimit(needed_fds);
  223|      2|	if (fdlimit < 0)
  ------------------
  |  Branch (223:6): [True: 0, False: 2]
  ------------------
  224|      0|	    MaxNumDLLs = 100;
  225|      2|	else {
  226|      2|	    MaxNumDLLs = (int) (0.6 * fdlimit);
  227|      2|	    if (MaxNumDLLs < 100)
  ------------------
  |  Branch (227:10): [True: 0, False: 2]
  ------------------
  228|      0|		R_Suicide(_("the limit on the number of open files is too low"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  229|      2|	}
  230|      2|    }
  231|       |
  232|       |    /* memory is set to zero */
  233|      2|    LoadedDLL = (DllInfo **) calloc(MaxNumDLLs, sizeof(DllInfo*));
  234|      2|    if (LoadedDLL == NULL)
  ------------------
  |  Branch (234:9): [True: 0, False: 2]
  ------------------
  235|      0|	R_Suicide(_("could not allocate space for DLL table"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  236|      2|    DLLInfoEptrs = allocVector(VECSXP, MaxNumDLLs);
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
                  DLLInfoEptrs = allocVector(VECSXP, MaxNumDLLs);
  ------------------
  |  |  131|      2|#define VECSXP	    19	  /* generic vectors */
  ------------------
  237|      2|    R_PreserveObject(DLLInfoEptrs);
  238|      2|    SymbolEptrs = CONS(R_NilValue, R_NilValue);
  ------------------
  |  |  309|      2|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  239|      2|    R_PreserveObject(SymbolEptrs);
  240|      2|}
Rdynload.c:R_addFortranRoutine:
  597|     42|{
  598|     42|    sym->name = Rstrdup(croutine->name);
  599|     42|    sym->fun = croutine->fun;
  600|     42|    sym->numArgs = croutine->numArgs > -1 ? croutine->numArgs : -1;
  ------------------
  |  Branch (600:20): [True: 42, False: 0]
  ------------------
  601|     42|    if(croutine->types)
  ------------------
  |  Branch (601:8): [True: 4, False: 38]
  ------------------
  602|      4|	R_setPrimitiveArgTypes(croutine, sym);
  603|     42|}
Rdynload.c:R_setPrimitiveArgTypes:
  582|      4|{
  583|      4|    sym->types = (R_NativePrimitiveArgType *)
  584|      4|	malloc(sizeof(R_NativePrimitiveArgType) * (size_t) croutine->numArgs);
  585|      4|    if(!sym->types)
  ------------------
  |  Branch (585:8): [True: 0, False: 4]
  ------------------
  586|      0|	error("allocation failure in R_setPrimitiveArgTypes");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  587|      4|    if(sym->types)
  ------------------
  |  Branch (587:8): [True: 4, False: 0]
  ------------------
  588|      4|	memcpy(sym->types, croutine->types,
  589|      4|	       sizeof(R_NativePrimitiveArgType) * (size_t) croutine->numArgs);
  590|       |
  591|      4|}
Rdynload.c:R_addExternalRoutine:
  609|    210|{
  610|    210|    sym->name = Rstrdup(croutine->name);
  611|    210|    sym->fun = croutine->fun;
  612|    210|    sym->numArgs = croutine->numArgs > -1 ? croutine->numArgs : -1;
  ------------------
  |  Branch (612:20): [True: 152, False: 58]
  ------------------
  613|    210|}
Rdynload.c:R_addCRoutine:
  618|     22|{
  619|     22|    sym->name = Rstrdup(croutine->name);
  620|     22|    sym->fun = croutine->fun;
  621|     22|    sym->numArgs = croutine->numArgs > -1 ? croutine->numArgs : -1;
  ------------------
  |  Branch (621:20): [True: 22, False: 0]
  ------------------
  622|     22|    if(croutine->types)
  ------------------
  |  Branch (622:8): [True: 0, False: 22]
  ------------------
  623|      0|	R_setPrimitiveArgTypes(croutine, sym);
  624|     22|}
Rdynload.c:R_addCallRoutine:
  629|    504|{
  630|    504|    sym->name = Rstrdup(croutine->name);
  631|    504|    sym->fun = croutine->fun;
  632|    504|    sym->numArgs = croutine->numArgs > -1 ? croutine->numArgs : -1;
  ------------------
  |  Branch (632:20): [True: 504, False: 0]
  ------------------
  633|    504|}
Rdynload.c:addDLL:
  957|     12|{
  958|     12|    int ans = CountDLL;
  959|     12|    char *name = (char *) malloc(strlen(DLLname)+1);
  960|     12|    if(name == NULL) {
  ------------------
  |  Branch (960:8): [True: 0, False: 12]
  ------------------
  961|      0|	strcpy(DLLerror, _("could not allocate space for 'name'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  962|      0|	if(handle)
  ------------------
  |  Branch (962:5): [True: 0, False: 0]
  ------------------
  963|      0|	    R_osDynSymbol->closeLibrary(handle);
  964|      0|	free(dpath);
  965|      0|	return 0;
  966|      0|    }
  967|     12|    strcpy(name, DLLname);
  968|       |
  969|     12|    DllInfo *info = (DllInfo *) malloc(sizeof(DllInfo));
  970|     12|    if(info == NULL) {
  ------------------
  |  Branch (970:8): [True: 0, False: 12]
  ------------------
  971|      0|	strcpy(DLLerror, _("could not allocate space for 'DllInfo'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  972|      0|	if(handle)
  ------------------
  |  Branch (972:5): [True: 0, False: 0]
  ------------------
  973|      0|	    R_osDynSymbol->closeLibrary(handle);
  974|      0|	free(name);
  975|      0|	free(dpath);
  976|      0|	return 0;
  977|      0|    }
  978|       |
  979|     12|    info->path = dpath;
  980|     12|    info->name = name;
  981|     12|    info->handle = handle;
  982|       |
  983|     12|    info->numCSymbols = 0;
  984|     12|    info->numCallSymbols = 0;
  985|     12|    info->numFortranSymbols = 0;
  986|     12|    info->numExternalSymbols = 0;
  987|     12|    info->CSymbols = NULL;
  988|     12|    info->CallSymbols = NULL;
  989|     12|    info->FortranSymbols = NULL;
  990|     12|    info->ExternalSymbols = NULL;
  991|     12|    LoadedDLL[CountDLL] = info;
  992|     12|    SET_VECTOR_ELT(DLLInfoEptrs, CountDLL, R_NilValue);
  993|     12|    CountDLL++;
  994|       |
  995|     12|    return(ans);
  996|     12|}
Rdynload.c:R_getDLLRegisteredSymbol:
 1043|     74|{
 1044|     74|    NativeSymbolType purpose = R_ANY_SYM;
 1045|       |
 1046|     74|    if(symbol)
  ------------------
  |  Branch (1046:8): [True: 74, False: 0]
  ------------------
 1047|     74|	purpose = symbol->type;
 1048|       |
 1049|     74|    if((purpose == R_ANY_SYM || purpose == R_C_SYM) &&
  ------------------
  |  Branch (1049:9): [True: 74, False: 0]
  |  Branch (1049:33): [True: 0, False: 0]
  ------------------
 1050|     74|       info->numCSymbols > 0) {
  ------------------
  |  Branch (1050:8): [True: 0, False: 74]
  ------------------
 1051|      0|	Rf_DotCSymbol *sym;
 1052|      0|	sym = Rf_lookupRegisteredCSymbol(info, name);
 1053|      0|	if(sym) {
  ------------------
  |  Branch (1053:5): [True: 0, False: 0]
  ------------------
 1054|      0|	    if(symbol) {
  ------------------
  |  Branch (1054:9): [True: 0, False: 0]
  ------------------
 1055|      0|		symbol->type = R_C_SYM;
 1056|      0|		symbol->symbol.c = sym;
 1057|      0|		symbol->dll = info;
 1058|      0|	    }
 1059|       |
 1060|      0|	    return((DL_FUNC) sym->fun);
 1061|      0|	}
 1062|      0|    }
 1063|       |
 1064|     74|    if((purpose == R_ANY_SYM || purpose == R_CALL_SYM) &&
  ------------------
  |  Branch (1064:9): [True: 74, False: 0]
  |  Branch (1064:33): [True: 0, False: 0]
  ------------------
 1065|     74|       info->numCallSymbols > 0) {
  ------------------
  |  Branch (1065:8): [True: 74, False: 0]
  ------------------
 1066|     74|	Rf_DotCallSymbol *sym;
 1067|     74|	sym = Rf_lookupRegisteredCallSymbol(info, name);
 1068|     74|	if(sym) {
  ------------------
  |  Branch (1068:5): [True: 8, False: 66]
  ------------------
 1069|      8|	    if(symbol) {
  ------------------
  |  Branch (1069:9): [True: 8, False: 0]
  ------------------
 1070|      8|		symbol->type = R_CALL_SYM;
 1071|      8|		symbol->symbol.call = sym;
 1072|      8|		symbol->dll = info;
 1073|      8|	    }
 1074|      8|	    return((DL_FUNC) sym->fun);
 1075|      8|	}
 1076|     74|    }
 1077|       |
 1078|     66|    if((purpose == R_ANY_SYM || purpose == R_FORTRAN_SYM) &&
  ------------------
  |  Branch (1078:9): [True: 66, False: 0]
  |  Branch (1078:33): [True: 0, False: 0]
  ------------------
 1079|     66|       info->numFortranSymbols > 0) {
  ------------------
  |  Branch (1079:8): [True: 0, False: 66]
  ------------------
 1080|      0|	Rf_DotFortranSymbol *sym;
 1081|      0|	sym = Rf_lookupRegisteredFortranSymbol(info, name);
 1082|      0|	if(sym) {
  ------------------
  |  Branch (1082:5): [True: 0, False: 0]
  ------------------
 1083|      0|	    if(symbol) {
  ------------------
  |  Branch (1083:9): [True: 0, False: 0]
  ------------------
 1084|      0|		symbol->type = R_FORTRAN_SYM;
 1085|      0|		symbol->symbol.fortran = sym;
 1086|      0|		symbol->dll = info;
 1087|      0|	    }
 1088|      0|	    return((DL_FUNC) sym->fun);
 1089|      0|	}
 1090|      0|    }
 1091|       |
 1092|     66|    if((purpose == R_ANY_SYM || purpose == R_EXTERNAL_SYM) &&
  ------------------
  |  Branch (1092:9): [True: 66, False: 0]
  |  Branch (1092:33): [True: 0, False: 0]
  ------------------
 1093|     66|       info->numExternalSymbols > 0) {
  ------------------
  |  Branch (1093:8): [True: 66, False: 0]
  ------------------
 1094|     66|	Rf_DotExternalSymbol *sym;
 1095|     66|	sym = Rf_lookupRegisteredExternalSymbol(info, name);
 1096|     66|	if(sym) {
  ------------------
  |  Branch (1096:5): [True: 66, False: 0]
  ------------------
 1097|     66|	    if(symbol) {
  ------------------
  |  Branch (1097:9): [True: 66, False: 0]
  ------------------
 1098|     66|		symbol->type = R_EXTERNAL_SYM;
 1099|     66|		symbol->symbol.external = sym;
 1100|     66|		symbol->dll = info;
 1101|     66|	    }
 1102|     66|	    return((DL_FUNC) sym->fun);
 1103|     66|	}
 1104|     66|    }
 1105|       |
 1106|      0|    return((DL_FUNC) NULL);
 1107|     66|}
Rdynload.c:Rf_lookupRegisteredCallSymbol:
 1021|     74|{
 1022|       |
 1023|    350|    for(int i = 0; i < info->numCallSymbols; i++) {
  ------------------
  |  Branch (1023:20): [True: 284, False: 66]
  ------------------
 1024|    284|	if(strcmp(name, info->CallSymbols[i].name) == 0)
  ------------------
  |  Branch (1024:5): [True: 8, False: 276]
  ------------------
 1025|      8|	    return(&(info->CallSymbols[i]));
 1026|    284|    }
 1027|     66|    return (Rf_DotCallSymbol*) NULL;
 1028|     74|}
Rdynload.c:Rf_lookupRegisteredExternalSymbol:
 1032|     66|{
 1033|  1.12k|    for(int i = 0; i < info->numExternalSymbols; i++) {
  ------------------
  |  Branch (1033:20): [True: 1.12k, False: 0]
  ------------------
 1034|  1.12k|	if(strcmp(name, info->ExternalSymbols[i].name) == 0)
  ------------------
  |  Branch (1034:5): [True: 66, False: 1.05k]
  ------------------
 1035|     66|	    return(&(info->ExternalSymbols[i]));
 1036|  1.12k|    }
 1037|      0|    return (Rf_DotExternalSymbol*) NULL;
 1038|     66|}
Rdynload.c:GetFullDLLPath:
 1213|     10|{
 1214|     10|    size_t res = R_osDynSymbol->getFullDLLPath(call, buf, bufsize, path);
 1215|     10|    if (res >= bufsize)
  ------------------
  |  Branch (1215:9): [True: 0, False: 10]
  ------------------
 1216|      0|	error(_("path too long")); 
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("path too long")); 
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1217|     10|}
Rdynload.c:AddDLL:
  830|     10|{
  831|     10|    HINSTANCE handle;
  832|     10|    DllInfo *info = NULL;
  833|       |
  834|     10|    int i, loc;
  835|       |
  836|     10|    loc = -1;
  837|     40|    for (i = 0; i < CountDLL; i++)
  ------------------
  |  Branch (837:17): [True: 30, False: 10]
  ------------------
  838|     30|	if (!strcmp(path, LoadedDLL[i]->path)) {
  ------------------
  |  Branch (838:6): [True: 0, False: 30]
  ------------------
  839|      0|	    loc = i;
  840|      0|	    break;
  841|      0|	}
  842|       |
  843|     10|    if (loc >= 0) {
  ------------------
  |  Branch (843:9): [True: 0, False: 10]
  ------------------
  844|       |	/* The DLL is already loaded, so move it to the head of the list
  845|       |	   and exit. We assume that the same path means the DLL file is
  846|       |	   also the same: the user should always unload a DLL file before
  847|       |	   modifying it (on Windows, it is locked, on Unix, modifying while
  848|       |	   loaded may cause a crash on function call or even dlsym()). */
  849|       |
  850|       |	/* FIXME: it might make sense to implement a reference count of how
  851|       |	   many times a DLL has been loaded, and only delete it when the count
  852|       |	   reaches zero, but that would break code relying on the existing
  853|       |	   behavior */
  854|       |
  855|      0|	DllInfo *info = LoadedDLL[loc];
  856|      0|	SEXP eptrs = PROTECT(VECTOR_ELT(DLLInfoEptrs, loc));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  857|       |
  858|      0|	for(i = loc + 1 ; i < CountDLL ; i++) {
  ------------------
  |  Branch (858:20): [True: 0, False: 0]
  ------------------
  859|      0|	    LoadedDLL[i - 1] = LoadedDLL[i];
  860|      0|	    SET_VECTOR_ELT(DLLInfoEptrs, i - 1, VECTOR_ELT(DLLInfoEptrs, i));
  861|      0|	}
  862|       |
  863|      0|	LoadedDLL[CountDLL - 1] = info;
  864|      0|	SET_VECTOR_ELT(DLLInfoEptrs, CountDLL - 1, eptrs);
  865|      0|	UNPROTECT(1); /* eptrs */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  866|      0|	return info;
  867|      0|    }
  868|       |
  869|     10|    if(CountDLL == MaxNumDLLs) {
  ------------------
  |  Branch (869:8): [True: 0, False: 10]
  ------------------
  870|      0|	strcpy(DLLerror, _("`maximal number of DLLs reached..."));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  871|      0|	return NULL;
  872|      0|    }
  873|       |
  874|     10|    handle = R_osDynSymbol->loadLibrary(path, asLocal, now, DLLsearchpath);
  875|       |
  876|     10|    if(handle == NULL) {
  ------------------
  |  Branch (876:8): [True: 0, False: 10]
  ------------------
  877|      0|	R_osDynSymbol->getError(DLLerror, DLLerrBUFSIZE);
  ------------------
  |  |  815|      0|#define DLLerrBUFSIZE 1000
  ------------------
  878|      0|	return NULL;
  879|      0|    }
  880|       |
  881|     10|    info = R_RegisterDLL(handle, path);
  882|       |
  883|       |    /* Now look for an initializing routine named R_init_<object name>.
  884|       |       If it is present, we call it. It should take a reference to the
  885|       |       DllInfo object currently being initialized.
  886|       |    */
  887|     10|    if(info) {
  ------------------
  |  Branch (887:8): [True: 10, False: 0]
  ------------------
  888|     10|	const char *nm = info->name;
  889|     10|	size_t len = strlen(nm) + 9;
  890|     10|	char tmp[len]; // R_init_ + underscore + null
  891|     10|	DllInfoInitCall f;
  892|     10|#ifdef HAVE_NO_SYMBOL_UNDERSCORE
  893|     10|	snprintf(tmp, len,  "%s%s","R_init_", info->name);
  894|       |#else
  895|       |	snprintf(tmp, len, "_%s%s","R_init_", info->name);
  896|       |#endif
  897|     10|	f = (DllInfoInitCall) R_osDynSymbol->dlsym(info, tmp);
  898|       |	/* If that failed, might have used the package name with
  899|       |	   . replaced by _ (as . it not valid in symbol names). */
  900|     10|	if(!f) {
  ------------------
  |  Branch (900:5): [True: 0, False: 10]
  ------------------
  901|       |	    /* This is potentially unsafe in MBCSs, as '.' might be
  902|       |	       part of a character: but is not in UTF-8 */
  903|      0|	    for(char *p = tmp; *p; p++) if(*p == '.') *p = '_';
  ------------------
  |  Branch (903:25): [True: 0, False: 0]
  |  Branch (903:37): [True: 0, False: 0]
  ------------------
  904|      0|	    f = (DllInfoInitCall) R_osDynSymbol->dlsym(info, tmp);
  905|      0|	}
  906|     10|	if(f) f(info);
  ------------------
  |  Branch (906:5): [True: 10, False: 0]
  ------------------
  907|     10|    }
  908|       |
  909|     10|    return info;
  910|     10|}
Rdynload.c:R_RegisterDLL:
  914|     10|{
  915|     10|    char *dpath,  DLLname[R_PATH_MAX], *p;
  916|     10|    DllInfo *info;
  917|       |
  918|     10|    dpath = (char *) malloc(strlen(path)+1);
  919|     10|    if(dpath == NULL) {
  ------------------
  |  Branch (919:8): [True: 0, False: 10]
  ------------------
  920|      0|	strcpy(DLLerror, _("could not allocate space for 'path'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  921|      0|	R_osDynSymbol->closeLibrary(handle);
  922|      0|	return 0;
  923|      0|    }
  924|     10|    strcpy(dpath, path);
  925|       |
  926|     10|    if(R_osDynSymbol->fixPath) R_osDynSymbol->fixPath(dpath);
  ------------------
  |  Branch (926:8): [True: 0, False: 10]
  ------------------
  927|       |
  928|       |    /* keep only basename from path */
  929|     10|    p = Rf_strrchr(dpath, FILESEP[0]);
  ------------------
  |  |  993|     10|# define FILESEP     "/"
  ------------------
  930|     10|    if(!p) p = dpath; else p++;
  ------------------
  |  Branch (930:8): [True: 0, False: 10]
  ------------------
  931|     10|    if(strlen(p) < R_PATH_MAX) strcpy(DLLname, p);
  ------------------
  |  | 1150|     10|# define R_PATH_MAX PATH_MAX
  ------------------
  |  Branch (931:8): [True: 10, False: 0]
  ------------------
  932|      0|    else error(_("DLLname '%s' is too long"), p);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  else error(_("DLLname '%s' is too long"), p);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  933|       |
  934|       |    /* remove SHLIB_EXT if present */
  935|     10|    p = DLLname + strlen(DLLname) - strlen(SHLIB_EXT);
  ------------------
  |  | 1116|     10|#define SHLIB_EXT ".so"
  ------------------
  936|       |#ifdef Win32  /* case-insensitive file system */
  937|       |    if(p > DLLname && stricmp(p, SHLIB_EXT) == 0) *p = '\0';
  938|       |#else
  939|     10|    if(p > DLLname && strcmp(p, SHLIB_EXT) == 0) *p = '\0';
  ------------------
  |  | 1116|     10|#define SHLIB_EXT ".so"
  ------------------
  |  Branch (939:8): [True: 10, False: 0]
  |  Branch (939:23): [True: 10, False: 0]
  ------------------
  940|     10|#endif
  941|       |
  942|     10|    if (addDLL(dpath, DLLname, handle)) {
  ------------------
  |  Branch (942:9): [True: 10, False: 0]
  ------------------
  943|     10|	info = LoadedDLL[CountDLL-1];
  944|       |	/* default is to use old-style dynamic lookup.  The object's
  945|       |	   initialization routine can limit access by setting this to FALSE.
  946|       |	*/
  947|     10|	info->useDynamicLookup = TRUE;
  948|     10|	info->forceSymbols = FALSE;
  949|     10|	return info;
  950|     10|    } else
  951|       |	/* dpath freed in addDLL */
  952|      0|	return NULL;
  953|     10|}
Rdynload.c:Rf_MakeDLLInfo:
 1408|    790|{
 1409|    790|    SEXP ref, elNames, tmp;
 1410|    790|    int i, n;
 1411|    790|    const char *const names[] = {"name", "path", "dynamicLookup",
 1412|    790|				 "handle", "info", "forceSymbols"};
 1413|       |
 1414|    790|    n = sizeof(names)/sizeof(names[0]);
 1415|       |
 1416|    790|    PROTECT(ref = allocVector(VECSXP, n));
  ------------------
  |  |  357|    790|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1417|    790|    SET_VECTOR_ELT(ref, 0, tmp = allocVector(STRSXP, 1));
  ------------------
  |  |  875|    790|#define allocVector		Rf_allocVector
  ------------------
                  SET_VECTOR_ELT(ref, 0, tmp = allocVector(STRSXP, 1));
  ------------------
  |  |  126|    790|#define STRSXP	    16	  /* string vectors */
  ------------------
 1418|    790|    if(info->name)
  ------------------
  |  Branch (1418:8): [True: 790, False: 0]
  ------------------
 1419|    790|	SET_STRING_ELT(tmp, 0, mkChar(info->name));
  ------------------
  |  |  998|    790|#define mkChar			Rf_mkChar
  ------------------
 1420|    790|    SET_VECTOR_ELT(ref, 1, tmp = allocVector(STRSXP, 1));
  ------------------
  |  |  875|    790|#define allocVector		Rf_allocVector
  ------------------
                  SET_VECTOR_ELT(ref, 1, tmp = allocVector(STRSXP, 1));
  ------------------
  |  |  126|    790|#define STRSXP	    16	  /* string vectors */
  ------------------
 1421|    790|    if(info->path)
  ------------------
  |  Branch (1421:8): [True: 790, False: 0]
  ------------------
 1422|    790|	SET_STRING_ELT(tmp, 0, mkChar(info->path));
  ------------------
  |  |  998|    790|#define mkChar			Rf_mkChar
  ------------------
 1423|    790|    SET_VECTOR_ELT(ref, 2, ScalarLogical(info->useDynamicLookup));
  ------------------
  |  | 1023|    790|#define ScalarLogical		Rf_ScalarLogical
  ------------------
 1424|       |
 1425|    790|    SEXP ehandle = Rf_makeDllObject(info->handle);
 1426|    790|    SET_VECTOR_ELT(ref, 3, ehandle);
 1427|    790|    SEXP einfo = Rf_makeDllInfoReference(info);
 1428|    790|    SET_VECTOR_ELT(ref, 4, einfo);
 1429|    790|    R_registerSymbolEptr(ehandle, einfo);
 1430|    790|    SET_VECTOR_ELT(ref, 5, ScalarLogical(info->forceSymbols));
  ------------------
  |  | 1023|    790|#define ScalarLogical		Rf_ScalarLogical
  ------------------
 1431|       |
 1432|    790|    PROTECT(elNames = allocVector(STRSXP, n));
  ------------------
  |  |  357|    790|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1433|  5.53k|    for(i = 0; i < n; i++)
  ------------------
  |  Branch (1433:16): [True: 4.74k, False: 790]
  ------------------
 1434|  4.74k|	SET_STRING_ELT(elNames, i, mkChar(names[i]));
  ------------------
  |  |  998|  4.74k|#define mkChar			Rf_mkChar
  ------------------
 1435|    790|    setAttrib(ref, R_NamesSymbol, elNames);
  ------------------
  |  | 1027|    790|#define setAttrib		Rf_setAttrib
  ------------------
 1436|       |
 1437|    790|    setAttrib(ref, R_ClassSymbol, mkString("DLLInfo"));
  ------------------
  |  | 1027|    790|#define setAttrib		Rf_setAttrib
  ------------------
                  setAttrib(ref, R_ClassSymbol, mkString("DLLInfo"));
  ------------------
  |  | 1003|    790|#define mkString		Rf_mkString
  ------------------
 1438|       |
 1439|    790|    UNPROTECT(2);
  ------------------
  |  |  358|    790|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1440|       |
 1441|    790|    return(ref);
 1442|    790|}
Rdynload.c:Rf_makeDllObject:
 1366|    790|{
 1367|    790|    SEXP ans;
 1368|       |
 1369|    790|    PROTECT(ans = R_MakeExternalPtr(inst, install("DLLHandle"),
  ------------------
  |  |  357|    790|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1370|    790|				    R_NilValue));
 1371|    790|    setAttrib(ans, R_ClassSymbol, mkString("DLLHandle"));
  ------------------
  |  | 1027|    790|#define setAttrib		Rf_setAttrib
  ------------------
                  setAttrib(ans, R_ClassSymbol, mkString("DLLHandle"));
  ------------------
  |  | 1003|    790|#define mkString		Rf_mkString
  ------------------
 1372|    790|    UNPROTECT(1);
  ------------------
  |  |  358|    790|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1373|       |
 1374|    790|    return(ans);
 1375|    790|}
Rdynload.c:Rf_makeDllInfoReference:
 1379|    790|{
 1380|    790|    SEXP ans;
 1381|       |
 1382|    790|    int i = R_getDllIndex(info);
 1383|    790|    if (i >= 0) {
  ------------------
  |  Branch (1383:9): [True: 790, False: 0]
  ------------------
 1384|    790|	ans = VECTOR_ELT(DLLInfoEptrs, i);
 1385|    790|	if (!isNull(ans))
  ------------------
  |  |  956|    790|#define isNull			Rf_isNull
  ------------------
  |  Branch (1385:6): [True: 778, False: 12]
  ------------------
 1386|    778|	    return ans;
 1387|    790|    }
 1388|       |
 1389|     12|    PROTECT(ans = R_MakeExternalPtr((HINSTANCE) info, install("DLLInfo"),
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1390|     12|				    R_NilValue));
 1391|     12|    setAttrib(ans, R_ClassSymbol, mkString("DLLInfoReference"));
  ------------------
  |  | 1027|     12|#define setAttrib		Rf_setAttrib
  ------------------
                  setAttrib(ans, R_ClassSymbol, mkString("DLLInfoReference"));
  ------------------
  |  | 1003|     12|#define mkString		Rf_mkString
  ------------------
 1392|     12|    if (i >= 0)
  ------------------
  |  Branch (1392:9): [True: 12, False: 0]
  ------------------
 1393|     12|	SET_VECTOR_ELT(DLLInfoEptrs, i, ans);
 1394|     12|    UNPROTECT(1);
  ------------------
  |  |  358|     12|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1395|       |
 1396|     12|    return(ans);
 1397|    790|}
Rdynload.c:R_getDllIndex:
  338|    790|{
  339|    790|    int i;
  340|  3.88k|    for(i = 0; i < CountDLL; i++) {
  ------------------
  |  Branch (340:16): [True: 3.88k, False: 0]
  ------------------
  341|  3.88k|	if(LoadedDLL[i] == info) return i;
  ------------------
  |  Branch (341:5): [True: 790, False: 3.09k]
  ------------------
  342|  3.88k|    }
  343|      0|    return -1;
  344|    790|}
Rdynload.c:R_registerSymbolEptr:
  245|  1.56k|{
  246|  1.56k|    static int cleancount = MAXCOUNT;
  ------------------
  |  |  242|  1.56k|#define MAXCOUNT 10
  ------------------
  247|       |
  248|       |    /* remove unneeded entries from the list */
  249|  1.56k|    if(--cleancount <= 0) {
  ------------------
  |  Branch (249:8): [True: 156, False: 1.41k]
  ------------------
  250|    156|	cleancount = MAXCOUNT;
  ------------------
  |  |  242|    156|#define MAXCOUNT 10
  ------------------
  251|    156|	for (SEXP last = SymbolEptrs, next = CDR(SymbolEptrs);
  252|  61.4k|	     next != R_NilValue;
  ------------------
  |  Branch (252:7): [True: 61.3k, False: 156]
  ------------------
  253|  61.3k|	     next = CDR(next))
  254|  61.3k|	    if (R_WeakRefKey(CAR(next)) == R_NilValue)
  ------------------
  |  Branch (254:10): [True: 2, False: 61.3k]
  ------------------
  255|      2|		SETCDR(last, CDR(next));
  256|  61.3k|	    else
  257|  61.3k|		last = next;
  258|    156|    }
  259|       |
  260|       |    /* Add eptr to the head of the list, with weakref value identifying the
  261|       |       DllInfo. The identification is needed when deleting the DLL. */
  262|  1.56k|    SETCDR(SymbolEptrs,
  263|  1.56k|           CONS(R_MakeWeakRef(eptr, einfo, R_NilValue, FALSE),
  ------------------
  |  |  309|  1.56k|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  264|  1.56k|                CDR(SymbolEptrs)));
  265|  1.56k|}
Rdynload.c:createRSymbolObject:
 1534|    778|{
 1535|    778|    SEXP tmp, klass, sym, names;
 1536|    778|    int n = (symbol->type != R_ANY_SYM) ? 4 : 3;
  ------------------
  |  Branch (1536:13): [True: 778, False: 0]
  ------------------
 1537|    778|    int numProtects = 0;
 1538|       |
 1539|    778|    PROTECT(sym = allocVector(VECSXP, n));    numProtects++;
  ------------------
  |  |  357|    778|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1540|    778|    PROTECT(names = allocVector(STRSXP, n));    numProtects++;
  ------------------
  |  |  357|    778|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1541|       |
 1542|    778|    if(!sname || sname == R_NilValue) {
  ------------------
  |  Branch (1542:8): [True: 704, False: 74]
  |  Branch (1542:18): [True: 0, False: 74]
  ------------------
 1543|    704|	PROTECT(sname = mkString(symbol->symbol.call->name));
  ------------------
  |  |  357|    704|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1544|    704|	numProtects++;
 1545|    704|    }
 1546|       |
 1547|    778|    SET_VECTOR_ELT(sym, 0, sname);
 1548|    778|    SET_STRING_ELT(names, 0, mkChar("name"));
  ------------------
  |  |  998|    778|#define mkChar			Rf_mkChar
  ------------------
 1549|       |
 1550|    778|    SEXP eaddress =
 1551|    778|	withRegistrationInfo && symbol && symbol->symbol.c && symbol->dll
  ------------------
  |  Branch (1551:2): [True: 778, False: 0]
  |  Branch (1551:26): [True: 778, False: 0]
  |  Branch (1551:36): [True: 778, False: 0]
  |  Branch (1551:56): [True: 778, False: 0]
  ------------------
 1552|    778|		   ? Rf_MakeRegisteredNativeSymbol(symbol)
 1553|    778|		   : Rf_MakeNativeSymbolRef(f);
 1554|    778|    SET_VECTOR_ELT(sym, 1, eaddress);
 1555|    778|    SET_STRING_ELT(names, 1, mkChar("address"));
  ------------------
  |  |  998|    778|#define mkChar			Rf_mkChar
  ------------------
 1556|    778|    if(symbol->dll) { /* now always */
  ------------------
  |  Branch (1556:8): [True: 778, False: 0]
  ------------------
 1557|    778|	SEXP rinfo = Rf_MakeDLLInfo(symbol->dll);
 1558|    778|	SET_VECTOR_ELT(sym, 2, rinfo);
 1559|    778|	SEXP einfo = VECTOR_ELT(rinfo, 4 /* info */);
 1560|    778|	R_registerSymbolEptr(eaddress, einfo);
 1561|    778|    }
 1562|    778|    SET_STRING_ELT(names, 2, mkChar("dll"));
  ------------------
  |  |  998|    778|#define mkChar			Rf_mkChar
  ------------------
 1563|       |
 1564|       |
 1565|    778|    PROTECT(klass = allocVector(STRSXP, (symbol->type != R_ANY_SYM ? 2 : 1)));
  ------------------
  |  |  357|  1.55k|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  |  Branch (357:31): [True: 778, False: 0]
  |  |  ------------------
  ------------------
 1566|    778|    numProtects++;
 1567|    778|    SET_STRING_ELT(klass, LENGTH(klass) - 1, mkChar("NativeSymbolInfo"));
  ------------------
  |  |  998|    778|#define mkChar			Rf_mkChar
  ------------------
 1568|       |
 1569|    778|    if(n > 3) {
  ------------------
  |  Branch (1569:8): [True: 778, False: 0]
  ------------------
 1570|       |	/* Add the registration information:
 1571|       |	   the number of arguments and the classname.
 1572|       |	*/
 1573|    778|	int nargs = -1;
 1574|    778|	char *className = "";
 1575|    778|	switch(symbol->type) {
 1576|     22|	case R_C_SYM:
  ------------------
  |  Branch (1576:2): [True: 22, False: 756]
  ------------------
 1577|     22|	    nargs = symbol->symbol.c->numArgs;
 1578|     22|	    className = "CRoutine";
 1579|     22|	    break;
 1580|    504|	case R_CALL_SYM:
  ------------------
  |  Branch (1580:2): [True: 504, False: 274]
  ------------------
 1581|    504|	    nargs = symbol->symbol.call->numArgs;
 1582|    504|	    className = "CallRoutine";
 1583|    504|	    break;
 1584|     42|	case R_FORTRAN_SYM:
  ------------------
  |  Branch (1584:2): [True: 42, False: 736]
  ------------------
 1585|     42|	    nargs = symbol->symbol.fortran->numArgs;
 1586|     42|	    className = "FortranRoutine";
 1587|     42|	    break;
 1588|    210|	case R_EXTERNAL_SYM:
  ------------------
  |  Branch (1588:2): [True: 210, False: 568]
  ------------------
 1589|    210|	    nargs = symbol->symbol.external->numArgs;
 1590|    210|	    className = "ExternalRoutine";
 1591|    210|	    break;
 1592|      0|	default:
  ------------------
  |  Branch (1592:2): [True: 0, False: 778]
  ------------------
 1593|       |	    /* Something unintended has happened if we get here. */
 1594|      0|	    error(_("unimplemented type %d in 'createRSymbolObject'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("unimplemented type %d in 'createRSymbolObject'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1595|      0|		  symbol->type);
 1596|      0|	    break;
 1597|    778|	}
 1598|    778|	SET_VECTOR_ELT(sym, 3, tmp = ScalarInteger(nargs));
  ------------------
  |  | 1022|    778|#define ScalarInteger		Rf_ScalarInteger
  ------------------
 1599|    778|	SET_STRING_ELT(klass, 0, mkChar(className));
  ------------------
  |  |  998|    778|#define mkChar			Rf_mkChar
  ------------------
 1600|    778|	SET_STRING_ELT(names, 3, mkChar("numParameters"));
  ------------------
  |  |  998|    778|#define mkChar			Rf_mkChar
  ------------------
 1601|    778|    }
 1602|       |
 1603|    778|    setAttrib(sym, R_ClassSymbol, klass);
  ------------------
  |  | 1027|    778|#define setAttrib		Rf_setAttrib
  ------------------
 1604|    778|    setAttrib(sym, R_NamesSymbol, names);
  ------------------
  |  | 1027|    778|#define setAttrib		Rf_setAttrib
  ------------------
 1605|       |
 1606|    778|    UNPROTECT(numProtects);
  ------------------
  |  |  358|    778|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1607|    778|    return(sym);
 1608|    778|}
Rdynload.c:Rf_MakeRegisteredNativeSymbol:
 1339|    778|{
 1340|    778|    SEXP ref, klass;
 1341|    778|    R_RegisteredNativeSymbol *copy;
 1342|    778|    copy = (R_RegisteredNativeSymbol *) malloc(1 * sizeof(R_RegisteredNativeSymbol));
 1343|    778|    if(!copy) {
  ------------------
  |  Branch (1343:8): [True: 0, False: 778]
  ------------------
 1344|      0|	error(ngettext("cannot allocate memory for registered native symbol (%d byte)",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 1345|      0|		       "cannot allocate memory for registered native symbol (%d bytes)",
 1346|      0|		      (int) sizeof(R_RegisteredNativeSymbol)),
 1347|      0|		      (int) sizeof(R_RegisteredNativeSymbol));
 1348|      0|    }
 1349|    778|    *copy = *symbol;
 1350|       |
 1351|    778|    PROTECT(ref = R_MakeExternalPtr(copy,
  ------------------
  |  |  357|    778|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1352|    778|				    install("registered native symbol"),
 1353|    778|				    R_NilValue));
 1354|    778|    R_RegisterCFinalizer(ref, freeRegisteredNativeSymbolCopy);
 1355|       |
 1356|    778|    PROTECT(klass = mkString("RegisteredNativeSymbol"));
  ------------------
  |  |  357|    778|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1357|    778|    setAttrib(ref, R_ClassSymbol, klass);
  ------------------
  |  | 1027|    778|#define setAttrib		Rf_setAttrib
  ------------------
 1358|       |
 1359|    778|    UNPROTECT(2);
  ------------------
  |  |  358|    778|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1360|    778|    return(ref);
 1361|    778|}
Rdynload.c:R_getRoutineSymbols:
 1612|     40|{
 1613|     40|    SEXP ans;
 1614|     40|    int i, num;
 1615|     40|    R_RegisteredNativeSymbol  sym;
 1616|     40|    DL_FUNC address = NULL;
 1617|       |
 1618|     40|    sym.dll = info;
 1619|     40|    sym.type =type;
 1620|       |
 1621|     40|    switch(type) {
 1622|     10|    case R_CALL_SYM: num = info->numCallSymbols;
  ------------------
  |  Branch (1622:5): [True: 10, False: 30]
  ------------------
 1623|     10|	break;
 1624|     10|    case R_C_SYM: num = info->numCSymbols;
  ------------------
  |  Branch (1624:5): [True: 10, False: 30]
  ------------------
 1625|     10|	break;
 1626|     10|    case R_FORTRAN_SYM: num = info->numFortranSymbols;
  ------------------
  |  Branch (1626:5): [True: 10, False: 30]
  ------------------
 1627|     10|	break;
 1628|     10|    case R_EXTERNAL_SYM: num = info->numExternalSymbols;
  ------------------
  |  Branch (1628:5): [True: 10, False: 30]
  ------------------
 1629|     10|	break;
 1630|      0|    default:
  ------------------
  |  Branch (1630:5): [True: 0, False: 40]
  ------------------
 1631|      0|	num = 0;
 1632|     40|    }
 1633|       |
 1634|     40|    PROTECT(ans = allocVector(VECSXP, num));
  ------------------
  |  |  357|     40|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1635|       |
 1636|    744|    for(i = 0; i < num ; i++) {
  ------------------
  |  Branch (1636:16): [True: 704, False: 40]
  ------------------
 1637|    704|	switch(type) {
 1638|    496|	case R_CALL_SYM:
  ------------------
  |  Branch (1638:2): [True: 496, False: 208]
  ------------------
 1639|    496|	    sym.symbol.call = &info->CallSymbols[i];
 1640|    496|	    address = sym.symbol.call->fun;
 1641|    496|	    break;
 1642|     22|	case R_C_SYM:
  ------------------
  |  Branch (1642:2): [True: 22, False: 682]
  ------------------
 1643|     22|	    sym.symbol.c = &info->CSymbols[i];
 1644|     22|	    address = sym.symbol.c->fun;
 1645|     22|	    break;
 1646|     42|	case R_FORTRAN_SYM:
  ------------------
  |  Branch (1646:2): [True: 42, False: 662]
  ------------------
 1647|     42|	    sym.symbol.fortran = &info->FortranSymbols[i];
 1648|     42|	    address = sym.symbol.fortran->fun;
 1649|     42|	    break;
 1650|    144|	case R_EXTERNAL_SYM:
  ------------------
  |  Branch (1650:2): [True: 144, False: 560]
  ------------------
 1651|    144|	    sym.symbol.external = &info->ExternalSymbols[i];
 1652|    144|	    address = sym.symbol.external->fun;
 1653|    144|	    break;
 1654|      0|	default:
  ------------------
  |  Branch (1654:2): [True: 0, False: 704]
  ------------------
 1655|      0|	    continue;
 1656|    704|	}
 1657|    704|	SET_VECTOR_ELT(ans, i, createRSymbolObject(NULL,  address, &sym, TRUE));/* XXX */
 1658|    704|    }
 1659|       |
 1660|     40|    setAttrib(ans, R_ClassSymbol, mkString("NativeRoutineList"));
  ------------------
  |  | 1027|     40|#define setAttrib		Rf_setAttrib
  ------------------
                  setAttrib(ans, R_ClassSymbol, mkString("NativeRoutineList"));
  ------------------
  |  | 1003|     40|#define mkString		Rf_mkString
  ------------------
 1661|     40|    UNPROTECT(1);
  ------------------
  |  |  358|     40|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1662|     40|    return(ans);
 1663|     40|}
Rdynload.c:get_package_CEntry_table:
 1730|     12|{
 1731|     12|    SEXP penv, pname;
 1732|       |
 1733|     12|    if (CEntryTable == NULL) {
  ------------------
  |  Branch (1733:9): [True: 2, False: 10]
  ------------------
 1734|      2|	CEntryTable = R_NewHashedEnv(R_NilValue, 0);
 1735|      2|	R_PreserveObject(CEntryTable);
 1736|      2|    }
 1737|     12|    pname = install(package);
  ------------------
  |  |  934|     12|#define install			Rf_install
  ------------------
 1738|     12|    penv = R_findVarInFrame(CEntryTable, pname);
 1739|     12|    if (penv == R_UnboundValue) {
  ------------------
  |  Branch (1739:9): [True: 2, False: 10]
  ------------------
 1740|      2|	penv = R_NewHashedEnv(R_NilValue, 0);
 1741|      2|	defineVar(pname, penv, CEntryTable);
  ------------------
  |  |  905|      2|#define defineVar		Rf_defineVar
  ------------------
 1742|      2|    }
 1743|     12|    return penv;
 1744|     12|}

process_system_Renviron:
  354|      2|{
  355|      2|    char *buf;
  356|      2|    int res;
  357|      2|    size_t needed =  strlen(R_Home) + strlen("/etc/Renviron") + 1;
  358|       |
  359|      2|#ifdef R_ARCH
  360|      2|    needed += strlen(R_ARCH) + 1;
  ------------------
  |  | 1085|      2|#define R_ARCH ""
  ------------------
  361|      2|#endif
  362|       |
  363|      2|#ifdef Unix
  364|      2|    if(needed > R_PATH_MAX) {
  ------------------
  |  | 1150|      2|# define R_PATH_MAX PATH_MAX
  ------------------
  |  Branch (364:8): [True: 0, False: 2]
  ------------------
  365|      0|	Renviron_warning("path to system Renviron is too long: skipping");
  366|      0|	return;
  367|      0|    }
  368|      2|#endif
  369|      2|    buf = (char *) Renviron_malloc(needed);
  370|       |
  371|      2|#ifdef R_ARCH
  372|      2|    strcpy(buf, R_Home);
  373|      2|    strcat(buf, "/etc/");
  374|      2|    strcat(buf, R_ARCH);
  ------------------
  |  | 1085|      2|#define R_ARCH ""
  ------------------
  375|      2|    strcat(buf, "/Renviron");
  376|       |#else
  377|       |    strcpy(buf, R_Home);
  378|       |    strcat(buf, "/etc/Renviron");
  379|       |#endif
  380|      2|    res = process_Renviron(buf);
  381|      2|    free(buf);
  382|      2|    if (!res)
  ------------------
  |  Branch (382:9): [True: 0, False: 2]
  ------------------
  383|      0|	Renviron_warning("cannot find system Renviron");
  384|      2|}
Renviron.c:Renviron_malloc:
  104|     42|{
  105|     42|    void *buf = malloc(size);
  106|     42|    if(!buf) Renviron_error("allocation failure in reading Renviron");
  ------------------
  |  Branch (106:8): [True: 0, False: 42]
  ------------------
  107|     42|    return buf;
  108|     42|}
Renviron.c:process_Renviron:
  273|      2|{
  274|      2|    FILE *fp;
  275|       |
  276|      2|    if (!filename) return 0;
  ------------------
  |  Branch (276:9): [True: 0, False: 2]
  ------------------
  277|       |#ifdef RENVIRON_WIN32_STANDALONE
  278|       |    fp = fopen(filename, "rt");
  279|       |#else
  280|      2|    fp = R_fopen(filename, "r");
  281|      2|#endif
  282|      2|    if (!fp) return 0;
  ------------------
  |  Branch (282:9): [True: 0, False: 2]
  ------------------
  283|       |
  284|      2|    char sm[BUF_SIZE], msg[MSG_SIZE];
  285|      2|    const char *line_prefix = "\n      ";
  286|      2|    const char *ignored_msg = "\n   They were ignored\n";
  287|      2|    const char *truncated_msg = "[... truncated]";
  288|      2|    const char *too_long = " (too long)";
  289|      2|    int errs = 0;
  290|       |
  291|    110|    while(fgets(sm, BUF_SIZE, fp)) {
  ------------------
  |  |  173|    110|#define BUF_SIZE 100000
  ------------------
  |  Branch (291:11): [True: 108, False: 2]
  ------------------
  292|    108|	sm[BUF_SIZE-1] = '\0'; /* should not be needed */
  ------------------
  |  |  173|    108|#define BUF_SIZE 100000
  ------------------
  293|       |	/* embedded nulls are not supported */
  294|    108|	int complete_line = feof(fp) || Renviron_strchr(sm, '\n');
  ------------------
  |  |   82|    108|# define Renviron_strchr Rf_strchr
  ------------------
  |  Branch (294:22): [True: 0, False: 108]
  |  Branch (294:34): [True: 108, False: 0]
  ------------------
  295|    108|	char *s = rmspace(sm), *p;
  296|    108|	if(strlen(s) == 0 || s[0] == '#') continue;
  ------------------
  |  Branch (296:5): [True: 10, False: 98]
  |  Branch (296:23): [True: 54, False: 44]
  ------------------
  297|     44|	if(!(p = Renviron_strchr(s, '=')) || !complete_line) {
  ------------------
  |  |   82|     44|# define Renviron_strchr Rf_strchr
  ------------------
  |  Branch (297:5): [True: 0, False: 44]
  |  Branch (297:39): [True: 0, False: 44]
  ------------------
  298|      0|	    if(!errs) {
  ------------------
  |  Branch (298:9): [True: 0, False: 0]
  ------------------
  299|      0|		errs = 1;
  300|      0|		Renviron_snprintf(msg, MSG_SIZE,
  ------------------
  |  |   83|      0|# define Renviron_snprintf Rsnprintf_mbcs
  ------------------
              		Renviron_snprintf(msg, MSG_SIZE,
  ------------------
  |  |  266|      0|#define MSG_SIZE 2048
  ------------------
  301|      0|			       "\n   File %s contains invalid line(s)",
  302|      0|		               filename);
  303|      0|	    }
  304|      0|	    if (strlen(msg) + strlen(line_prefix) + strlen(s) +
  ------------------
  |  Branch (304:10): [True: 0, False: 0]
  ------------------
  305|      0|	        strlen(ignored_msg) < MSG_SIZE) {
  ------------------
  |  |  266|      0|#define MSG_SIZE 2048
  ------------------
  306|       |
  307|      0|		strcat(msg, line_prefix);
  308|      0|		strcat(msg, s);
  309|      0|	    } else if (strlen(msg) + strlen(line_prefix) +
  ------------------
  |  Branch (309:17): [True: 0, False: 0]
  ------------------
  310|      0|		                45 + strlen(truncated_msg) +
  311|      0|                                     strlen(ignored_msg) < MSG_SIZE) {
  ------------------
  |  |  266|      0|#define MSG_SIZE 2048
  ------------------
  312|      0|		strcat(msg, line_prefix);
  313|      0|		strncat(msg, s, 45);
  314|      0|#ifndef RENVIRON_WIN32_STANDALONE
  315|      0|		mbcsTruncateToValid(msg);
  316|      0|#endif
  317|      0|		strcat(msg, truncated_msg);
  318|      0|	    }
  319|      0|	    if (!complete_line) {
  ------------------
  |  Branch (319:10): [True: 0, False: 0]
  ------------------
  320|      0|		if (strlen(msg) + strlen(too_long) +
  ------------------
  |  Branch (320:7): [True: 0, False: 0]
  ------------------
  321|      0|		    strlen(ignored_msg) < MSG_SIZE) {
  ------------------
  |  |  266|      0|#define MSG_SIZE 2048
  ------------------
  322|       |
  323|      0|		    strcat(msg, too_long);
  324|      0|		}
  325|       |		/* skip the rest of the line */
  326|      0|		while(!complete_line && fgets(sm, BUF_SIZE, fp)) {
  ------------------
  |  |  173|      0|#define BUF_SIZE 100000
  ------------------
  |  Branch (326:9): [True: 0, False: 0]
  |  Branch (326:27): [True: 0, False: 0]
  ------------------
  327|      0|		    sm[BUF_SIZE-1] = '\0'; /* should not be needed */
  ------------------
  |  |  173|      0|#define BUF_SIZE 100000
  ------------------
  328|      0|		    complete_line = feof(fp) || Renviron_strchr(sm, '\n');
  ------------------
  |  |   82|      0|# define Renviron_strchr Rf_strchr
  ------------------
  |  Branch (328:23): [True: 0, False: 0]
  |  Branch (328:35): [True: 0, False: 0]
  ------------------
  329|      0|		}
  330|      0|		if (!complete_line)
  ------------------
  |  Branch (330:7): [True: 0, False: 0]
  ------------------
  331|      0|		    break; /* error or EOF at line start */
  332|      0|	    }
  333|      0|	    continue;
  334|      0|	}
  335|     44|	*p = '\0';
  336|     44|	char* lhs = rmspace(s),
  337|     44|	    * rhs = findterm(rmspace(p+1));
  338|       |	/* set lhs = rhs */
  339|     44|	if(strlen(lhs) && strlen(rhs)) Putenv(lhs, rhs);
  ------------------
  |  Branch (339:5): [True: 44, False: 0]
  |  Branch (339:20): [True: 40, False: 4]
  ------------------
  340|     44|    }
  341|      2|    fclose(fp);
  342|      2|    if (errs) {
  ------------------
  |  Branch (342:9): [True: 0, False: 2]
  ------------------
  343|      0|	if (strlen(msg) + strlen(ignored_msg) < MSG_SIZE)
  ------------------
  |  |  266|      0|#define MSG_SIZE 2048
  ------------------
  |  Branch (343:6): [True: 0, False: 0]
  ------------------
  344|      0|	   strcat(msg, ignored_msg);
  345|      0|	Renviron_warning(msg);
  346|      0|    }
  347|      2|    return 1;
  348|      2|}
Renviron.c:rmspace:
  113|    240|{
  114|    240|    ssize_t i; // to be safe
  115|       |
  116|    348|    for (i = strlen(s) - 1; i >= 0 && isspace((int)s[i]); i--) s[i] = '\0';
  ------------------
  |  Branch (116:29): [True: 338, False: 10]
  |  Branch (116:39): [True: 108, False: 230]
  ------------------
  117|    240|    for (i = 0; isspace((int)s[i]); i++);
  ------------------
  |  Branch (117:17): [True: 0, False: 240]
  ------------------
  118|    240|    return s + i;
  119|    240|}
Renviron.c:findterm:
  175|     44|{
  176|     44|    char *p, *q, *r2, *ss=s;
  177|     44|    static char ans[BUF_SIZE];
  178|       |
  179|     44|    if(!strlen(s)) return "";
  ------------------
  |  Branch (179:8): [True: 0, False: 44]
  ------------------
  180|     44|    ans[0] = '\0';
  181|     86|    while(1) {
  ------------------
  |  Branch (181:11): [True: 86, Folded]
  ------------------
  182|       |	/* Look for ${...}, taking care to look for inner matches */
  183|     86|	p = Renviron_strchr(s, '$');
  ------------------
  |  |   82|     86|# define Renviron_strchr Rf_strchr
  ------------------
  184|     86|	if(!p || p[1] != '{') break;
  ------------------
  |  Branch (184:5): [True: 44, False: 42]
  |  Branch (184:11): [True: 0, False: 42]
  ------------------
  185|     42|	q = findRbrace(p+2);
  186|     42|	if(!q) break;
  ------------------
  |  Branch (186:5): [True: 0, False: 42]
  ------------------
  187|       |	/* copy over leading part */
  188|     42|	size_t nans = strlen(ans);
  189|     42|	strncat(ans, s, (size_t) (p - s)); ans[nans + p - s] = '\0';
  190|     42|	char r[q - p + 2];
  191|     42|	strncpy(r, p, (size_t) (q - p + 1));
  192|     42|	r[q - p + 1] = '\0';
  193|     42|	r2 = subterm(r);
  194|     42|	if(strlen(ans) + strlen(r2) < BUF_SIZE) strcat(ans, r2); else return ss;
  ------------------
  |  |  173|     42|#define BUF_SIZE 100000
  ------------------
  |  Branch (194:5): [True: 42, False: 0]
  ------------------
  195|       |	/* now repeat on the tail */
  196|     42|	s = q+1;
  197|     42|    }
  198|     44|    if(strlen(ans) + strlen(s) < BUF_SIZE) strcat(ans, s); else return ss;
  ------------------
  |  |  173|     44|#define BUF_SIZE 100000
  ------------------
  |  Branch (198:8): [True: 44, False: 0]
  ------------------
  199|     44|    return ans;
  200|     44|}
Renviron.c:findRbrace:
  156|     42|{
  157|     42|    char *p = s, *pl, *pr;
  158|     42|    int nl = 0, nr = 0;
  159|       |
  160|     92|    while(nr <= nl) {
  ------------------
  |  Branch (160:11): [True: 50, False: 42]
  ------------------
  161|     50|	pl = Renviron_strchr(p, '{');
  ------------------
  |  |   82|     50|# define Renviron_strchr Rf_strchr
  ------------------
  162|     50|	pr = Renviron_strchr(p, '}');
  ------------------
  |  |   82|     50|# define Renviron_strchr Rf_strchr
  ------------------
  163|     50|	if(!pr) return NULL;
  ------------------
  |  Branch (163:5): [True: 0, False: 50]
  ------------------
  164|     50|	if(!pl || pr < pl) {
  ------------------
  |  Branch (164:5): [True: 46, False: 4]
  |  Branch (164:12): [True: 0, False: 4]
  ------------------
  165|     46|	    p = pr+1; nr++;
  166|     46|	} else {
  167|      4|	    p = pl+1; nl++;
  168|      4|	}
  169|     50|    }
  170|     42|    return pr;
  171|     42|}
Renviron.c:subterm:
  126|     64|{
  127|     64|    char *p, *q;
  128|     64|    int colon = 0;
  129|       |
  130|     64|    if(strncmp(s, "${", 2)) return s;
  ------------------
  |  Branch (130:8): [True: 20, False: 44]
  ------------------
  131|     44|    if(s[strlen(s) - 1] != '}') return s;
  ------------------
  |  Branch (131:8): [True: 0, False: 44]
  ------------------
  132|       |    /*  remove leading ${ and final } */
  133|     44|    s[strlen(s) - 1] = '\0';
  134|     44|    s += 2;
  135|     44|    s = rmspace(s);
  136|     44|    if(!strlen(s)) return "";
  ------------------
  |  Branch (136:8): [True: 0, False: 44]
  ------------------
  137|     44|    p = Renviron_strchr(s, '-');
  ------------------
  |  |   82|     44|# define Renviron_strchr Rf_strchr
  ------------------
  138|     44|    if(p) {
  ------------------
  |  Branch (138:8): [True: 42, False: 2]
  ------------------
  139|     42|	q = p + 1; /* start of value */
  140|     42|	if(p - s > 1 && *(p-1) == ':') {
  ------------------
  |  Branch (140:5): [True: 42, False: 0]
  |  Branch (140:18): [True: 4, False: 38]
  ------------------
  141|      4|	    colon = 1;
  142|      4|	    *(p-1) = '\0';
  143|     38|	} else *p = '\0';
  144|     42|    } else q = NULL;
  145|     44|    p = getenv(s);
  146|     44|    if(colon) {
  ------------------
  |  Branch (146:8): [True: 4, False: 40]
  ------------------
  147|      4|	if(p && strlen(p)) return p; /* variable was set and non-empty */
  ------------------
  |  Branch (147:5): [True: 2, False: 2]
  |  Branch (147:10): [True: 2, False: 0]
  ------------------
  148|     40|    } else {
  149|     40|	if(p) return p; /* variable was set */
  ------------------
  |  Branch (149:5): [True: 19, False: 21]
  ------------------
  150|     40|    }
  151|     23|    return q ? subterm(q) : (char *) "";
  ------------------
  |  Branch (151:12): [True: 22, False: 1]
  ------------------
  152|     44|}
Renviron.c:Putenv:
  203|     40|{
  204|     40|    char *buf, *value, *p, *q, quote='\0';
  205|     40|    int inquote = 0;
  206|     40|    int failed = 0;
  207|       |
  208|     40|#ifdef HAVE_SETENV
  209|     40|    buf = (char *) Renviron_malloc((strlen(b) + 1) * sizeof(char));
  210|     40|    value = buf;
  211|       |#else
  212|       |    buf = (char *) Renviron_malloc((strlen(a) + strlen(b) + 2) * sizeof(char));
  213|       |    strcpy(buf, a); strcat(buf, "=");
  214|       |    value = buf+strlen(buf);
  215|       |#endif
  216|       |
  217|       |    /* now process the value */
  218|    602|    for(p = b, q = value; *p; p++) {
  ------------------
  |  Branch (218:27): [True: 562, False: 40]
  ------------------
  219|       |	/* remove quotes around sections, preserve \ inside quotes */
  220|    562|	if(!inquote && (*p == '"' || *p == '\'') &&
  ------------------
  |  Branch (220:5): [True: 331, False: 231]
  |  Branch (220:18): [True: 0, False: 331]
  |  Branch (220:31): [True: 21, False: 310]
  ------------------
  221|     21|	   (p == b || *(p-1) != '\\')) {
  ------------------
  |  Branch (221:6): [True: 21, False: 0]
  |  Branch (221:16): [True: 0, False: 0]
  ------------------
  222|       |
  223|     21|	    inquote = 1;
  224|     21|	    quote = *p;
  225|     21|	    continue;
  226|     21|	}
  227|    541|	if(inquote && *p == quote && *(p-1) != '\\') {
  ------------------
  |  Branch (227:5): [True: 231, False: 310]
  |  Branch (227:16): [True: 21, False: 210]
  |  Branch (227:31): [True: 21, False: 0]
  ------------------
  228|     21|	    inquote = 0;
  229|     21|	    continue;
  230|     21|	}
  231|    520|	if(!inquote && *p == '\\') {
  ------------------
  |  Branch (231:5): [True: 310, False: 210]
  |  Branch (231:17): [True: 0, False: 310]
  ------------------
  232|      0|	    if(*(p+1) == '\n') p++;
  ------------------
  |  Branch (232:9): [True: 0, False: 0]
  ------------------
  233|      0|	    else if(*(p+1) == '\\') *q++ = *p;
  ------------------
  |  Branch (233:14): [True: 0, False: 0]
  ------------------
  234|      0|	    continue;
  235|      0|	}
  236|    520|	if(inquote && *p == '\\' && *(p+1) == quote) continue;
  ------------------
  |  Branch (236:5): [True: 210, False: 310]
  |  Branch (236:16): [True: 0, False: 210]
  |  Branch (236:30): [True: 0, False: 0]
  ------------------
  237|    520|	*q++ = *p;
  238|    520|    }
  239|     40|    *q = '\0';
  240|     40|#ifdef HAVE_SETENV
  241|     40|    if(setenv(a, buf, 1))
  ------------------
  |  Branch (241:8): [True: 0, False: 40]
  ------------------
  242|      0|	failed = 1;
  243|     40|    free(buf);
  244|       |#elif defined(HAVE_PUTENV)
  245|       |    if(putenv(buf))
  246|       |	failed = 1;
  247|       |    /* no free here: storage remains in use */
  248|       |#else
  249|       |    /* pretty pointless, and was not tested prior to 2.3.0 */
  250|       |    free(buf);
  251|       |#endif
  252|     40|    if (failed) {
  ------------------
  |  Branch (252:9): [True: 0, False: 40]
  ------------------
  253|      0|	char buf[1024];
  254|      0|	Renviron_snprintf(buf, 1024,
  ------------------
  |  |   83|      0|# define Renviron_snprintf Rsnprintf_mbcs
  ------------------
  255|       |#ifdef RENVIRON_WIN32_STANDALONE
  256|       |	                  "Problem in setting variable '%s' in Renviron",
  257|       |#else
  258|       |	                  _("problem in setting variable '%s' in Renviron"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  259|      0|#endif
  260|      0|	                  a);
  261|      0|	Renviron_warning(buf);
  262|      0|    }
  263|     40|}

R_compact_intrange:
  596|    252|{
  597|    252|    R_xlen_t n = n1 <= n2 ? n2 - n1 + 1 : n1 - n2 + 1;
  ------------------
  |  Branch (597:18): [True: 252, False: 0]
  ------------------
  598|       |
  599|    252|    if (n >= R_XLEN_T_MAX)
  ------------------
  |  |   76|    252|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (599:9): [True: 0, False: 252]
  ------------------
  600|      0|	error("result would be too long a vector");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  601|       |
  602|    252|    if (n1 <= INT_MIN || n1 > INT_MAX || n2 <= INT_MIN || n2 > INT_MAX)
  ------------------
  |  Branch (602:9): [True: 0, False: 252]
  |  Branch (602:26): [True: 0, False: 252]
  |  Branch (602:42): [True: 0, False: 252]
  |  Branch (602:59): [True: 0, False: 252]
  ------------------
  603|      0|	return new_compact_realseq(n, n1, n1 <= n2 ? 1 : -1);
  ------------------
  |  Branch (603:36): [True: 0, False: 0]
  ------------------
  604|    252|    else
  605|    252|	return new_compact_intseq(n, (int) n1, n1 <= n2 ? 1 : -1);
  ------------------
  |  Branch (605:41): [True: 252, False: 0]
  ------------------
  606|    252|}
R_deferred_coerceToString:
  900|     13|{
  901|     13|    SEXP ans = R_NilValue;
  902|     13|    switch (TYPEOF(v)) {
  903|      2|    case INTSXP:
  ------------------
  |  |  123|      2|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (903:5): [True: 2, False: 11]
  ------------------
  904|     13|    case REALSXP:
  ------------------
  |  |  124|     13|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (904:5): [True: 11, False: 2]
  ------------------
  905|     13|	PROTECT(v); /* may not be needed, but to be safe ... */
  ------------------
  |  |  357|     13|#define PROTECT(s)	Rf_protect(s)
  ------------------
  906|     13|	if (info == NULL) {
  ------------------
  |  Branch (906:6): [True: 13, False: 0]
  ------------------
  907|     13|	    PrintDefaults(); /* to set R_print from options */
  ------------------
  |  | 1970|     13|# define PrintDefaults		Rf_PrintDefaults
  ------------------
  908|     13|	    info = ScalarInteger(R_print.scipen);
  ------------------
  |  | 1022|     13|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  909|     13|	    if (strcmp(OutDec, ".")) {
  ------------------
  |  Branch (909:10): [True: 0, False: 13]
  ------------------
  910|       |		/* non-default OutDec setting -- attach as an attribute */
  911|      0|		PROTECT(info);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  912|      0|		if (R_OutDecSym == NULL)
  ------------------
  |  Branch (912:7): [True: 0, False: 0]
  ------------------
  913|      0|		    R_OutDecSym = install("OutDec");
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
  914|      0|		setAttrib(info, R_OutDecSym, GetOption1(R_OutDecSym));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              		setAttrib(info, R_OutDecSym, GetOption1(R_OutDecSym));
  ------------------
  |  |  928|      0|#define GetOption1		Rf_GetOption1
  ------------------
  915|      0|		UNPROTECT(1); /* info */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  916|      0|	    }
  917|     13|	}
  918|     13|	MARK_NOT_MUTABLE(v); /* make sure it can't change once captured */
  919|     13|	ans = PROTECT(MAKE_DEFERRED_STRING_STATE(v, info));
  ------------------
  |  |  357|     13|#define PROTECT(s)	Rf_protect(s)
  ------------------
  920|     13|	ans = R_new_altrep(R_deferred_string_class, ans, R_NilValue);
  921|     13|	UNPROTECT(2); /* ans, v */
  ------------------
  |  |  358|     13|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  922|     13|	break;
  923|      0|    default:
  ------------------
  |  Branch (923:5): [True: 0, False: 13]
  ------------------
  924|      0|	error("unsupported type for deferred string coercion");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  925|     13|    }
  926|     13|    return ans;
  927|     13|}
R_tryWrap:
 2101|      8|{
 2102|      8|    return wrap_meta(x, UNKNOWN_SORTEDNESS, FALSE);
 2103|      8|}
R_tryUnwrap:
 2125|      8|{
 2126|      8|    if (! MAYBE_SHARED(x) && is_wrapper(x) &&
  ------------------
  |  Branch (2126:9): [True: 8, False: 0]
  |  Branch (2126:30): [True: 8, False: 0]
  ------------------
 2127|      8|	WRAPPER_SORTED(x) == UNKNOWN_SORTEDNESS && ! WRAPPER_NO_NA(x)) {
  ------------------
  |  | 1470|      8|#define WRAPPER_SORTED(x) INTEGER(WRAPPER_METADATA(x))[0]
  |  |  ------------------
  |  |  |  | 1468|      8|#define WRAPPER_METADATA(x) R_altrep_data2(x)
  |  |  ------------------
  ------------------
              	WRAPPER_SORTED(x) == UNKNOWN_SORTEDNESS && ! WRAPPER_NO_NA(x)) {
  ------------------
  |  | 1471|      8|#define WRAPPER_NO_NA(x) INTEGER(WRAPPER_METADATA(x))[1]
  |  |  ------------------
  |  |  |  | 1468|      8|#define WRAPPER_METADATA(x) R_altrep_data2(x)
  |  |  ------------------
  ------------------
  |  Branch (2127:2): [True: 8, False: 0]
  |  Branch (2127:45): [True: 8, False: 0]
  ------------------
 2128|      8|	SEXP data = WRAPPER_WRAPPED(x);
  ------------------
  |  | 1466|      8|#define WRAPPER_WRAPPED(x) R_altrep_data1(x)
  ------------------
 2129|      8|	if (! MAYBE_SHARED(data)) {
  ------------------
  |  Branch (2129:6): [True: 8, False: 0]
  ------------------
 2130|      8|	    SET_ATTRIB(data, ATTRIB(x));
 2131|      8|	    SET_OBJECT(data, OBJECT(x));
 2132|      8|	    IS_S4_OBJECT(x) ? SET_S4_OBJECT(data) : UNSET_S4_OBJECT(data);
  ------------------
  |  Branch (2132:6): [True: 0, False: 8]
  ------------------
 2133|       |
 2134|       |	    /* Clear the fields to drop reference counts and set the
 2135|       |	       type to LISTSXP to limit errors in case the object is
 2136|       |	       still live. */
 2137|      8|	    void ALTREP_SET_TYPEOF(SEXP, int); /* in memory.c */
 2138|      8|	    ALTREP_SET_TYPEOF(x, LISTSXP);
  ------------------
  |  |  113|      8|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
 2139|      8|	    SETALTREP(x, 0);
 2140|      8|	    SET_ATTRIB(x, R_NilValue);
 2141|      8|	    SETCAR(x, R_NilValue);
 2142|      8|	    SETCDR(x, R_NilValue);
 2143|      8|	    SET_TAG(x, R_NilValue);
 2144|      8|	    SET_OBJECT(x, 0);
 2145|      8|	    UNSET_S4_OBJECT(x);
 2146|       |	    /* NAMED should be zero */
 2147|       |
 2148|      8|	    return data;
 2149|      8|	}
 2150|      8|    }
 2151|      0|    return x;
 2152|      8|}
R_init_altrep:
 2160|      2|{
 2161|      2|    InitCompactIntegerClass();
 2162|      2|    InitCompactRealClass();
 2163|      2|    InitDefferredStringClass();
 2164|      2|    InitMmapIntegerClass(NULL);
 2165|      2|    InitMmapRealClass(NULL);
 2166|      2|    InitWrapIntegerClass(NULL);
 2167|      2|    InitWrapLogicalClass(NULL);
 2168|      2|    InitWrapRealClass(NULL);
 2169|      2|    InitWrapComplexClass(NULL);
 2170|      2|    InitWrapRawClass(NULL);
 2171|      2|    InitWrapStringClass(NULL);
 2172|       |    InitWrapListClass(NULL);
 2173|      2|}
altclasses.c:new_compact_intseq:
  330|    260|{
  331|    260|    if (n == 1) return ScalarInteger(n1);
  ------------------
  |  | 1022|     34|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  |  Branch (331:9): [True: 34, False: 226]
  ------------------
  332|       |
  333|    226|    if (inc != 1 && inc != -1)
  ------------------
  |  Branch (333:9): [True: 0, False: 226]
  |  Branch (333:21): [True: 0, False: 0]
  ------------------
  334|      0|	error("compact sequences with increment %d not supported yet", inc);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  335|       |
  336|       |    /* info used REALSXP to allow for long vectors */
  337|    226|    SEXP info = allocVector(REALSXP, 3);
  ------------------
  |  |  875|    226|#define allocVector		Rf_allocVector
  ------------------
                  SEXP info = allocVector(REALSXP, 3);
  ------------------
  |  |  124|    226|#define REALSXP	    14	  /* real variables */
  ------------------
  338|    226|    REAL0(info)[0] = (double) n;
  339|    226|    REAL0(info)[1] = (double) n1;
  340|    226|    REAL0(info)[2] = (double) inc;
  341|       |
  342|    226|    SEXP ans = R_new_altrep(R_compact_intseq_class, info, R_NilValue);
  343|    226|#ifndef COMPACT_INTSEQ_MUTABLE
  344|    226|    MARK_NOT_MUTABLE(ans); /* force duplicate on modify */
  345|    226|#endif
  346|       |
  347|    226|    return ans;
  348|    260|}
altclasses.c:wrap_meta:
 2051|      8|{
 2052|      8|    switch(TYPEOF(x)) {
 2053|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2053:5): [True: 0, False: 8]
  ------------------
 2054|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (2054:5): [True: 0, False: 8]
  ------------------
 2055|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2055:5): [True: 0, False: 8]
  ------------------
 2056|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (2056:5): [True: 0, False: 8]
  ------------------
 2057|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (2057:5): [True: 0, False: 8]
  ------------------
 2058|      8|    case STRSXP:
  ------------------
  |  |  126|      8|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2058:5): [True: 8, False: 0]
  ------------------
 2059|      8|    case VECSXP: break;
  ------------------
  |  |  131|      8|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2059:5): [True: 0, False: 8]
  ------------------
 2060|      0|    default: return x;
  ------------------
  |  Branch (2060:5): [True: 0, False: 8]
  ------------------
 2061|      8|    }
 2062|       |
 2063|       |    /* avoid wrappers of wrappers, at least in some cases */
 2064|      8|    if (is_wrapper(x) && srt == UNKNOWN_SORTEDNESS && no_na == FALSE)
  ------------------
  |  Branch (2064:9): [True: 0, False: 8]
  |  Branch (2064:26): [True: 0, False: 0]
  |  Branch (2064:55): [True: 0, False: 0]
  ------------------
 2065|      0|	return shallow_duplicate(x);
  ------------------
  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 2066|       |
 2067|       |#ifndef WRAPATTRIB
 2068|       |    if (ATTRIB(x) != R_NilValue)
 2069|       |	/* For objects without references we could move the attributes
 2070|       |	   to the wrapper. For objects with references the attributes
 2071|       |	   would have to be shallow duplicated at least. The object/S4
 2072|       |	   bits would need to be moved as well.	*/
 2073|       |	/* For now, just return the original object. */
 2074|       |	return x;
 2075|       |#endif
 2076|       |
 2077|      8|    if (!KNOWN_SORTED(srt) && srt != KNOWN_UNSORTED &&
  ------------------
  |  | 1162|     16|#define KNOWN_SORTED(sorted) (sorted == SORTED_DECR ||			\
  |  |  ------------------
  |  |  |  Branch (1162:31): [True: 0, False: 8]
  |  |  ------------------
  |  | 1163|      8|			      sorted == SORTED_INCR ||			\
  |  |  ------------------
  |  |  |  Branch (1163:10): [True: 0, False: 8]
  |  |  ------------------
  |  | 1164|      8|			      sorted == SORTED_DECR_NA_1ST ||		\
  |  |  ------------------
  |  |  |  Branch (1164:10): [True: 0, False: 8]
  |  |  ------------------
  |  | 1165|     16|			      sorted == SORTED_INCR_NA_1ST)
  |  |  ------------------
  |  |  |  Branch (1165:10): [True: 0, False: 8]
  |  |  ------------------
  ------------------
  |  Branch (2077:31): [True: 8, False: 0]
  ------------------
 2078|      8|	srt != UNKNOWN_SORTEDNESS)
  ------------------
  |  Branch (2078:2): [True: 0, False: 8]
  ------------------
 2079|      0|	error("srt must be -2, -1, 0, or +1, +2, or NA");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 2080|       |    
 2081|      8|    if (no_na < 0 || no_na > 1)
  ------------------
  |  Branch (2081:9): [True: 0, False: 8]
  |  Branch (2081:22): [True: 0, False: 8]
  ------------------
 2082|      0|	error("no_na must be 0 or +1");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 2083|       |
 2084|      8|    SEXP meta = allocVector(INTSXP, NMETA);
  ------------------
  |  |  875|      8|#define allocVector		Rf_allocVector
  ------------------
                  SEXP meta = allocVector(INTSXP, NMETA);
  ------------------
  |  |  123|      8|#define INTSXP	    13	  /* integer vectors */
  ------------------
                  SEXP meta = allocVector(INTSXP, NMETA);
  ------------------
  |  | 1453|      8|#define NMETA 2
  ------------------
 2085|      8|    INTEGER(meta)[0] = srt;
 2086|      8|    INTEGER(meta)[1] = no_na;
 2087|       |
 2088|      8|    return make_wrapper(x, meta);
 2089|      8|}
altclasses.c:make_wrapper:
 1996|      8|{
 1997|       |    /* If x is itself a wrapper it might be a good idea to fuse */
 1998|      8|    R_altrep_class_t cls;
 1999|      8|    switch(TYPEOF(x)) {
 2000|      0|    case INTSXP: cls = wrap_integer_class; break;
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2000:5): [True: 0, False: 8]
  ------------------
 2001|      0|    case LGLSXP: cls = wrap_logical_class; break;
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2001:5): [True: 0, False: 8]
  ------------------
 2002|      0|    case REALSXP: cls = wrap_real_class; break;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (2002:5): [True: 0, False: 8]
  ------------------
 2003|      0|    case CPLXSXP: cls = wrap_complex_class; break;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (2003:5): [True: 0, False: 8]
  ------------------
 2004|      0|    case RAWSXP: cls = wrap_raw_class; break;
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (2004:5): [True: 0, False: 8]
  ------------------
 2005|      8|    case STRSXP: cls = wrap_string_class; break;
  ------------------
  |  |  126|      8|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2005:5): [True: 8, False: 0]
  ------------------
 2006|      0|    case VECSXP: cls = wrap_list_class; break;
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2006:5): [True: 0, False: 8]
  ------------------
 2007|      0|    default: error("unsupported type");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (2007:5): [True: 0, False: 8]
  ------------------
 2008|      8|    }
 2009|       |
 2010|      8|    SEXP ans = R_new_altrep(cls, x, meta);
 2011|       |
 2012|      8|#define WRAPATTRIB
 2013|      8|#ifdef WRAPATTRIB
 2014|      8|    if (ATTRIB(x) != R_NilValue) {
  ------------------
  |  Branch (2014:9): [True: 8, False: 0]
  ------------------
 2015|       |	/* could just move attributes if there are no references to x */
 2016|      8|	PROTECT(ans);
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2017|      8|	SET_ATTRIB(ans, shallow_duplicate(ATTRIB(x)));
  ------------------
  |  | 1030|      8|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 2018|      8|	SET_OBJECT(ans, OBJECT(x));
 2019|      8|	IS_S4_OBJECT(x) ? SET_S4_OBJECT(ans) : UNSET_S4_OBJECT(ans);
  ------------------
  |  Branch (2019:2): [True: 0, False: 8]
  ------------------
 2020|      8|	UNPROTECT(1); /* ans */
  ------------------
  |  |  358|      8|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2021|      8|    }
 2022|      8|#endif
 2023|       |
 2024|       |#ifndef SWITCH_TO_REFCNT
 2025|       |    if (MAYBE_REFERENCED(x))
 2026|       |	/* make sure no mutation can happen through another reference */
 2027|       |	MARK_NOT_MUTABLE(x);
 2028|       |#endif
 2029|       |
 2030|      8|    WRAPPER_UNLOCK_DATA(ans);
  ------------------
  |  | 1490|      8|#define WRAPPER_UNLOCK_DATA(x) WRAPPER_SET_DATA_LOCK(x, 0)
  |  |  ------------------
  |  |  |  | 1487|      8|#define WRAPPER_SET_DATA_LOCK(x, v) SET_PRSEEN(WRAPPER_METADATA(x), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1468|      8|#define WRAPPER_METADATA(x) R_altrep_data2(x)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2031|      8|    return ans;
 2032|      8|}
altclasses.c:is_wrapper:
 2035|     16|{
 2036|     16|    if (ALTREP(x))
  ------------------
  |  Branch (2036:9): [True: 8, False: 8]
  ------------------
 2037|      8|	switch(TYPEOF(x)) {
 2038|      0|	case INTSXP: return R_altrep_inherits(x, wrap_integer_class);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2038:2): [True: 0, False: 8]
  ------------------
 2039|      0|	case LGLSXP: return R_altrep_inherits(x, wrap_logical_class);
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2039:2): [True: 0, False: 8]
  ------------------
 2040|      0|	case REALSXP: return R_altrep_inherits(x, wrap_real_class);
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (2040:2): [True: 0, False: 8]
  ------------------
 2041|      0|	case CPLXSXP: return R_altrep_inherits(x, wrap_complex_class);
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (2041:2): [True: 0, False: 8]
  ------------------
 2042|      0|	case RAWSXP: return R_altrep_inherits(x, wrap_raw_class);
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (2042:2): [True: 0, False: 8]
  ------------------
 2043|      8|	case STRSXP: return R_altrep_inherits(x, wrap_string_class);
  ------------------
  |  |  126|      8|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2043:2): [True: 8, False: 0]
  ------------------
 2044|      0|	case VECSXP: return R_altrep_inherits(x, wrap_list_class);
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2044:2): [True: 0, False: 8]
  ------------------
 2045|      0|	default: return FALSE;
  ------------------
  |  Branch (2045:2): [True: 0, False: 8]
  ------------------
 2046|      8|	}
 2047|      8|    else return FALSE;
 2048|     16|}
altclasses.c:InitCompactIntegerClass:
  299|      2|{
  300|      2|    R_altrep_class_t cls = R_make_altinteger_class("compact_intseq", "base",
  301|      2|						   NULL);
  302|      2|    R_compact_intseq_class = cls;
  303|       |
  304|       |    /* override ALTREP methods */
  305|      2|    R_set_altrep_Unserialize_method(cls, compact_intseq_Unserialize);
  306|      2|    R_set_altrep_Serialized_state_method(cls, compact_intseq_Serialized_state);
  307|      2|    R_set_altrep_Duplicate_method(cls, compact_intseq_Duplicate);
  308|      2|    R_set_altrep_Coerce_method(cls, compact_intseq_Coerce);
  309|      2|    R_set_altrep_Inspect_method(cls, compact_intseq_Inspect);
  310|      2|    R_set_altrep_Length_method(cls, compact_intseq_Length);
  311|       |
  312|       |    /* override ALTVEC methods */
  313|      2|    R_set_altvec_Dataptr_method(cls, compact_intseq_Dataptr);
  314|      2|    R_set_altvec_Dataptr_or_null_method(cls, compact_intseq_Dataptr_or_null);
  315|       |
  316|       |    /* override ALTINTEGER methods */
  317|      2|    R_set_altinteger_Elt_method(cls, compact_intseq_Elt);
  318|      2|    R_set_altinteger_Get_region_method(cls, compact_intseq_Get_region);
  319|      2|    R_set_altinteger_Is_sorted_method(cls, compact_intseq_Is_sorted);
  320|      2|    R_set_altinteger_No_NA_method(cls, compact_intseq_No_NA);
  321|      2|    R_set_altinteger_Sum_method(cls, compact_intseq_Sum);
  322|      2|}
altclasses.c:compact_intseq_Unserialize:
   88|      8|{
   89|       |    /* state is the serialized info vector (see compact_intseq_Serialized_state):
   90|       |       a numeric vector of length 3.  A crafted serialized stream can supply
   91|       |       any object here, so reject a malformed state with a clean error rather
   92|       |       than reading REAL0/INTEGER0 off the end of a short or wrong-typed
   93|       |       (or non-vector) object. */
   94|      8|    if ((TYPEOF(state) != REALSXP && TYPEOF(state) != INTSXP) ||
  ------------------
  |  |  124|     16|#define REALSXP	    14	  /* real variables */
  ------------------
                  if ((TYPEOF(state) != REALSXP && TYPEOF(state) != INTSXP) ||
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (94:10): [True: 0, False: 8]
  |  Branch (94:38): [True: 0, False: 0]
  ------------------
   95|      8|	XLENGTH(state) < 3)
  ------------------
  |  Branch (95:2): [True: 0, False: 8]
  ------------------
   96|      0|	error("invalid compact_intseq serialized state");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
   97|       |
   98|      8|    R_xlen_t n = COMPACT_INTSEQ_SERIALIZED_STATE_LENGTH(state);
  ------------------
  |  |   53|      8|    (TYPEOF(info) == INTSXP ? INTEGER0(info)[0] : (R_xlen_t) REAL0(info)[0])
  |  |  ------------------
  |  |  |  |  123|      8|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (53:6): [True: 0, False: 8]
  |  |  ------------------
  ------------------
   99|      8|    int n1 = COMPACT_INTSEQ_SERIALIZED_STATE_FIRST(state);
  ------------------
  |  |   55|      8|    (TYPEOF(info) == INTSXP ? INTEGER0(info)[1] : (int) REAL0(info)[1])
  |  |  ------------------
  |  |  |  |  123|      8|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (55:6): [True: 0, False: 8]
  |  |  ------------------
  ------------------
  100|      8|    int inc = COMPACT_INTSEQ_SERIALIZED_STATE_INCR(state);
  ------------------
  |  |   57|      8|    (TYPEOF(info) == INTSXP ? INTEGER0(info)[2] : (int) REAL0(info)[2])
  |  |  ------------------
  |  |  |  |  123|      8|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (57:6): [True: 0, False: 8]
  |  |  ------------------
  ------------------
  101|       |
  102|      8|    if (inc == 1)
  ------------------
  |  Branch (102:9): [True: 8, False: 0]
  ------------------
  103|      8|	return new_compact_intseq(n, n1,  1);
  104|      0|    else if (inc == -1)
  ------------------
  |  Branch (104:14): [True: 0, False: 0]
  ------------------
  105|      0|	return new_compact_intseq(n, n1,  -1);
  106|      0|    else
  107|      0|	error("compact sequences with increment %d not supported yet", inc);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  108|      8|}
altclasses.c:compact_intseq_Length:
  162|  1.75k|{
  163|  1.75k|    SEXP info = COMPACT_SEQ_INFO(x);
  ------------------
  |  |   47|  1.75k|#define COMPACT_SEQ_INFO(x) R_altrep_data1(x)
  ------------------
  164|  1.75k|    return COMPACT_INTSEQ_INFO_LENGTH(info);
  ------------------
  |  |   60|  1.75k|#define COMPACT_INTSEQ_INFO_LENGTH(info) ((R_xlen_t) REAL0(info)[0])
  ------------------
  165|  1.75k|}
altclasses.c:compact_intseq_Dataptr:
  168|    852|{
  169|    852|    if (COMPACT_SEQ_EXPANDED(x) == R_NilValue) {
  ------------------
  |  |   48|    852|#define COMPACT_SEQ_EXPANDED(x) R_altrep_data2(x)
  ------------------
  |  Branch (169:9): [True: 188, False: 664]
  ------------------
  170|       |	/* no need to re-run if expanded data exists */
  171|    188|	PROTECT(x);
  ------------------
  |  |  357|    188|#define PROTECT(s)	Rf_protect(s)
  ------------------
  172|    188|	SEXP info = COMPACT_SEQ_INFO(x);
  ------------------
  |  |   47|    188|#define COMPACT_SEQ_INFO(x) R_altrep_data1(x)
  ------------------
  173|    188|	R_xlen_t n = COMPACT_INTSEQ_INFO_LENGTH(info);
  ------------------
  |  |   60|    188|#define COMPACT_INTSEQ_INFO_LENGTH(info) ((R_xlen_t) REAL0(info)[0])
  ------------------
  174|    188|	int n1 = COMPACT_INTSEQ_INFO_FIRST(info);
  ------------------
  |  |   61|    188|#define COMPACT_INTSEQ_INFO_FIRST(info) ((int) REAL0(info)[1])
  ------------------
  175|    188|	int inc = COMPACT_INTSEQ_INFO_INCR(info);
  ------------------
  |  |   62|    188|#define COMPACT_INTSEQ_INFO_INCR(info) ((int) REAL0(info)[2])
  ------------------
  176|    188|	SEXP val = allocVector(INTSXP, n);
  ------------------
  |  |  875|    188|#define allocVector		Rf_allocVector
  ------------------
              	SEXP val = allocVector(INTSXP, n);
  ------------------
  |  |  123|    188|#define INTSXP	    13	  /* integer vectors */
  ------------------
  177|    188|	int *data = INTEGER(val);
  178|       |
  179|    188|	if (inc == 1) {
  ------------------
  |  Branch (179:6): [True: 188, False: 0]
  ------------------
  180|       |	    /* compact sequences n1 : n2 with n1 <= n2 */
  181|  1.13k|	    for (R_xlen_t i = 0; i < n; i++)
  ------------------
  |  Branch (181:27): [True: 947, False: 188]
  ------------------
  182|    947|		data[i] = (int) (n1 + i);
  183|    188|	}
  184|      0|	else if (inc == -1) {
  ------------------
  |  Branch (184:11): [True: 0, False: 0]
  ------------------
  185|       |	    /* compact sequences n1 : n2 with n1 > n2 */
  186|      0|	    for (R_xlen_t i = 0; i < n; i++)
  ------------------
  |  Branch (186:27): [True: 0, False: 0]
  ------------------
  187|      0|		data[i] = (int) (n1 - i);
  188|      0|	}
  189|      0|	else
  190|      0|	    error("compact sequences with increment %d not supported yet", inc);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  191|       |
  192|    188|	SET_COMPACT_SEQ_EXPANDED(x, val);
  ------------------
  |  |   49|    188|#define SET_COMPACT_SEQ_EXPANDED(x, v) R_set_altrep_data2(x, v)
  ------------------
  193|    188|	UNPROTECT(1);
  ------------------
  |  |  358|    188|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  194|    188|    }
  195|    852|    return DATAPTR_RW(COMPACT_SEQ_EXPANDED(x));
  ------------------
  |  |   48|    852|#define COMPACT_SEQ_EXPANDED(x) R_altrep_data2(x)
  ------------------
  196|    852|}
altclasses.c:compact_intseq_Elt:
  205|    337|{
  206|    337|    SEXP ex = COMPACT_SEQ_EXPANDED(x);
  ------------------
  |  |   48|    337|#define COMPACT_SEQ_EXPANDED(x) R_altrep_data2(x)
  ------------------
  207|    337|    if (ex != R_NilValue)
  ------------------
  |  Branch (207:9): [True: 189, False: 148]
  ------------------
  208|    189|	return INTEGER0(ex)[i];
  209|    148|    else {
  210|    148|	SEXP info = COMPACT_SEQ_INFO(x);
  ------------------
  |  |   47|    148|#define COMPACT_SEQ_INFO(x) R_altrep_data1(x)
  ------------------
  211|    148|	int n1 = COMPACT_INTSEQ_INFO_FIRST(info);
  ------------------
  |  |   61|    148|#define COMPACT_INTSEQ_INFO_FIRST(info) ((int) REAL0(info)[1])
  ------------------
  212|    148|	int inc = COMPACT_INTSEQ_INFO_INCR(info);
  ------------------
  |  |   62|    148|#define COMPACT_INTSEQ_INFO_INCR(info) ((int) REAL0(info)[2])
  ------------------
  213|    148|	return (int) (n1 + inc * i);
  214|    148|    }
  215|    337|}
altclasses.c:InitCompactRealClass:
  543|      2|{
  544|      2|    R_altrep_class_t cls = R_make_altreal_class("compact_realseq", "base",
  545|      2|						NULL);
  546|      2|    R_compact_realseq_class = cls;
  547|       |
  548|       |    /* override ALTREP methods */
  549|      2|    R_set_altrep_Unserialize_method(cls, compact_realseq_Unserialize);
  550|      2|    R_set_altrep_Serialized_state_method(cls, compact_realseq_Serialized_state);
  551|      2|    R_set_altrep_Duplicate_method(cls, compact_realseq_Duplicate);
  552|      2|    R_set_altrep_Inspect_method(cls, compact_realseq_Inspect);
  553|      2|    R_set_altrep_Length_method(cls, compact_realseq_Length);
  554|       |
  555|       |    /* override ALTVEC methods */
  556|      2|    R_set_altvec_Dataptr_method(cls, compact_realseq_Dataptr);
  557|      2|    R_set_altvec_Dataptr_or_null_method(cls, compact_realseq_Dataptr_or_null);
  558|       |
  559|       |    /* override ALTREAL methods */
  560|      2|    R_set_altreal_Elt_method(cls, compact_realseq_Elt);
  561|      2|    R_set_altreal_Get_region_method(cls, compact_realseq_Get_region);
  562|      2|    R_set_altreal_Is_sorted_method(cls, compact_realseq_Is_sorted);
  563|      2|    R_set_altreal_No_NA_method(cls, compact_realseq_No_NA);
  564|      2|    R_set_altreal_Sum_method(cls, compact_realseq_Sum);
  565|      2|}
altclasses.c:InitDefferredStringClass:
  871|      2|{
  872|      2|    R_altrep_class_t cls = R_make_altstring_class("deferred_string", "base",
  873|      2|						  NULL);
  874|      2|    R_deferred_string_class = cls;
  875|       |
  876|       |    /* override ALTREP methods */
  877|      2|    R_set_altrep_Unserialize_method(cls, deferred_string_Unserialize);
  878|      2|    R_set_altrep_Serialized_state_method(cls, deferred_string_Serialized_state);
  879|      2|    R_set_altrep_Inspect_method(cls, deferred_string_Inspect);
  880|      2|    R_set_altrep_Length_method(cls, deferred_string_Length);
  881|       |
  882|       |    /* override ALTVEC methods */
  883|      2|    R_set_altvec_Dataptr_method(cls, deferred_string_Dataptr);
  884|      2|    R_set_altvec_Dataptr_or_null_method(cls, deferred_string_Dataptr_or_null);
  885|      2|    R_set_altvec_Extract_subset_method(cls, deferred_string_Extract_subset);
  886|       |
  887|       |    /* override ALTSTRING methods */
  888|      2|    R_set_altstring_Elt_method(cls, deferred_string_Elt);
  889|      2|    R_set_altstring_Set_elt_method(cls, deferred_string_Set_elt);
  890|      2|    R_set_altstring_Is_sorted_method(cls, deferred_string_Is_sorted);
  891|      2|    R_set_altstring_No_NA_method(cls, deferred_string_No_NA);
  892|      2|}
altclasses.c:deferred_string_Length:
  706|    108|{
  707|    108|    SEXP state = DEFERRED_STRING_STATE(x);
  ------------------
  |  |  617|    108|#define DEFERRED_STRING_STATE(x) R_altrep_data1(x)
  ------------------
  708|    108|    return state == R_NilValue ?
  ------------------
  |  Branch (708:12): [True: 0, False: 108]
  ------------------
  709|      0|	XLENGTH(DEFERRED_STRING_EXPANDED(x)) :
  ------------------
  |  |  619|      0|#define DEFERRED_STRING_EXPANDED(x) R_altrep_data2(x)
  ------------------
  710|    108|	XLENGTH(DEFERRED_STRING_STATE_ARG(state));
  ------------------
  |  |  623|    108|#define DEFERRED_STRING_STATE_ARG(s) CAR(s)
  ------------------
  711|    108|}
altclasses.c:ExpandDeferredStringElt:
  714|     41|{
  715|       |    /* make sure the STRSXP for the expanded string is allocated */
  716|       |    /* not yet expanded strings are NULL in the STRSXP */
  717|     41|    SEXP val = DEFERRED_STRING_EXPANDED(x);
  ------------------
  |  |  619|     41|#define DEFERRED_STRING_EXPANDED(x) R_altrep_data2(x)
  ------------------
  718|     41|    if (val == R_NilValue) {
  ------------------
  |  Branch (718:9): [True: 13, False: 28]
  ------------------
  719|     13|	R_xlen_t n = XLENGTH(x);
  720|     13|	val = allocVector(STRSXP, n);
  ------------------
  |  |  875|     13|#define allocVector		Rf_allocVector
  ------------------
              	val = allocVector(STRSXP, n);
  ------------------
  |  |  126|     13|#define STRSXP	    16	  /* string vectors */
  ------------------
  721|     13|	if (n)
  ------------------
  |  Branch (721:6): [True: 13, False: 0]
  ------------------
  722|     13|	    memset(STDVEC_DATAPTR(val), 0, n * sizeof(SEXP));
  723|     13|	SET_DEFERRED_STRING_EXPANDED(x, val);
  ------------------
  |  |  620|     13|#define SET_DEFERRED_STRING_EXPANDED(x, v) R_set_altrep_data2(x, v)
  ------------------
  724|     13|    }
  725|       |
  726|     41|    SEXP elt = STRING_ELT(val, i);
  727|     41|    if (elt == NULL) {
  ------------------
  |  |  911|     41|#define elt			Rf_elt
  ------------------
  |  Branch (727:9): [True: 15, False: 26]
  ------------------
  728|     15|	int warn; /* not used by the coercion functions */
  729|     15|	int savedigits, savescipen;
  730|     15|	SEXP data = DEFERRED_STRING_ARG(x);
  ------------------
  |  |  627|     15|    DEFERRED_STRING_STATE_ARG(DEFERRED_STRING_STATE(x))
  |  |  ------------------
  |  |  |  |  623|     15|#define DEFERRED_STRING_STATE_ARG(s) CAR(s)
  |  |  ------------------
  ------------------
  731|     15|	switch(TYPEOF(data)) {
  732|      4|	case INTSXP:
  ------------------
  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (732:2): [True: 4, False: 11]
  ------------------
  733|      4|	    elt = StringFromInteger(INTEGER_ELT(data, i), &warn);
  ------------------
  |  |  911|      4|#define elt			Rf_elt
  ------------------
              	    elt = StringFromInteger(INTEGER_ELT(data, i), &warn);
  ------------------
  |  | 1990|      4|# define StringFromInteger	Rf_StringFromInteger
  ------------------
  734|      4|	    break;
  735|     11|	case REALSXP:
  ------------------
  |  |  124|     11|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (735:2): [True: 11, False: 4]
  ------------------
  736|     11|	    savedigits = R_print.digits;
  737|     11|	    savescipen = R_print.scipen;
  738|     11|	    R_print.digits = DBL_DIG;/* MAX precision */
  739|     11|	    R_print.scipen = DEFERRED_STRING_SCIPEN(x);
  ------------------
  |  |  631|     11|    INTEGER0(DEFERRED_STRING_STATE_INFO(DEFERRED_STRING_STATE(x)))[0]
  |  |  ------------------
  |  |  |  |  624|     11|#define DEFERRED_STRING_STATE_INFO(s) CDR(s)
  |  |  ------------------
  ------------------
  740|     11|	    const char *myoutdec = DEFERRED_STRING_OUTDEC(x);
  741|     11|	    if (strcmp(OutDec, myoutdec)) {
  ------------------
  |  Branch (741:10): [True: 0, False: 11]
  ------------------
  742|       |		/* The current and saved OutDec values differ. The
  743|       |		   value to use is put in a static buffer and OutDec
  744|       |		   temporarily points to this buffer while
  745|       |		   StringFromReal is called and then reset. The buffer
  746|       |		   originally pointed to by OutDec cannot be used as
  747|       |		   it wil not be writable if the default "." has not
  748|       |		   been changed. */
  749|      0|		static char buf[10];
  750|      0|		strncpy(buf, myoutdec, sizeof buf);
  751|      0|		buf[sizeof(buf) - 1] = '\0';
  752|      0|		char *savedOutDec = OutDec;
  753|      0|		OutDec = buf;
  754|      0|		elt = StringFromReal(REAL_ELT(data, i), &warn);
  ------------------
  |  |  911|      0|#define elt			Rf_elt
  ------------------
              		elt = StringFromReal(REAL_ELT(data, i), &warn);
  ------------------
  |  | 1992|      0|# define StringFromReal		Rf_StringFromReal
  ------------------
  755|      0|		OutDec = savedOutDec;
  756|      0|	    }
  757|     11|	    else
  758|     11|		elt = StringFromReal(REAL_ELT(data, i), &warn);
  ------------------
  |  |  911|     11|#define elt			Rf_elt
  ------------------
              		elt = StringFromReal(REAL_ELT(data, i), &warn);
  ------------------
  |  | 1992|     11|# define StringFromReal		Rf_StringFromReal
  ------------------
  759|     11|	    R_print.digits = savedigits;
  760|     11|	    R_print.scipen = savescipen;
  761|     11|	    break;
  762|      0|	default:
  ------------------
  |  Branch (762:2): [True: 0, False: 15]
  ------------------
  763|      0|	    error("unsupported type for deferred string coercion");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  764|     15|	}
  765|     15|	SET_STRING_ELT(val, i, elt);
  ------------------
  |  |  911|     15|#define elt			Rf_elt
  ------------------
  766|     15|    }
  767|     41|    return elt;
  ------------------
  |  |  911|     41|#define elt			Rf_elt
  ------------------
  768|     41|}
altclasses.c:DEFERRED_STRING_OUTDEC:
  645|     11|{
  646|       |    /* The default value of OutDec at startup is ".". If it is
  647|       |       something different at the time the deferred string conversion
  648|       |       is created then the current value is stored as an attribute. */
  649|     11|    if (R_OutDecSym == NULL)
  ------------------
  |  Branch (649:9): [True: 2, False: 9]
  ------------------
  650|      2|	R_OutDecSym = install("OutDec");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  651|     11|    SEXP info = DEFERRED_STRING_INFO(x);
  ------------------
  |  |  629|     11|    DEFERRED_STRING_STATE_INFO(DEFERRED_STRING_STATE(x))
  |  |  ------------------
  |  |  |  |  624|     11|#define DEFERRED_STRING_STATE_INFO(s) CDR(s)
  |  |  ------------------
  ------------------
  652|     11|    if (ATTRIB(info) != R_NilValue) {
  ------------------
  |  Branch (652:9): [True: 0, False: 11]
  ------------------
  653|      0|	SEXP outdecattr = getAttrib(info, R_OutDecSym);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  654|      0|	if (TYPEOF(outdecattr) == STRSXP && XLENGTH(outdecattr) == 1)
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (654:6): [True: 0, False: 0]
  |  Branch (654:38): [True: 0, False: 0]
  ------------------
  655|      0|	    return CHAR(STRING_ELT(outdecattr, 0));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  656|      0|    }
  657|     11|    return ".";
  658|     11|}
altclasses.c:deferred_string_Elt:
  800|     41|{
  801|     41|    SEXP state = DEFERRED_STRING_STATE(x);
  ------------------
  |  |  617|     41|#define DEFERRED_STRING_STATE(x) R_altrep_data1(x)
  ------------------
  802|     41|    if (state == R_NilValue)
  ------------------
  |  Branch (802:9): [True: 0, False: 41]
  ------------------
  803|       |	/* string is fully expanded */
  804|      0|	return STRING_ELT(DEFERRED_STRING_EXPANDED(x), i);
  ------------------
  |  |  619|      0|#define DEFERRED_STRING_EXPANDED(x) R_altrep_data2(x)
  ------------------
  805|     41|    else {
  806|       |	/* expand only the requested element */
  807|     41|	PROTECT(x);
  ------------------
  |  |  357|     41|#define PROTECT(s)	Rf_protect(s)
  ------------------
  808|     41|	SEXP elt = ExpandDeferredStringElt(x, i);
  809|     41|	UNPROTECT(1);
  ------------------
  |  |  358|     41|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  810|     41|	return elt;
  ------------------
  |  |  911|     41|#define elt			Rf_elt
  ------------------
  811|     41|    }
  812|     41|}
altclasses.c:InitMmapIntegerClass:
 1257|      2|{
 1258|      2|    R_altrep_class_t cls =
 1259|      2|	R_make_altinteger_class("mmap_integer", MMAPPKG, dll);
  ------------------
  |  | 1253|      2|# define MMAPPKG "base"
  ------------------
 1260|      2|    mmap_integer_class = cls;
 1261|       | 
 1262|       |    /* override ALTREP methods */
 1263|      2|    R_set_altrep_Unserialize_method(cls, mmap_Unserialize);
 1264|      2|    R_set_altrep_Serialized_state_method(cls, mmap_Serialized_state);
 1265|      2|    R_set_altrep_Inspect_method(cls, mmap_Inspect);
 1266|      2|    R_set_altrep_Length_method(cls, mmap_Length);
 1267|       |
 1268|       |    /* override ALTVEC methods */
 1269|      2|    R_set_altvec_Dataptr_method(cls, mmap_Dataptr);
 1270|      2|    R_set_altvec_Dataptr_or_null_method(cls, mmap_Dataptr_or_null);
 1271|       |
 1272|       |    /* override ALTINTEGER methods */
 1273|      2|    R_set_altinteger_Elt_method(cls, mmap_integer_Elt);
 1274|      2|    R_set_altinteger_Get_region_method(cls, mmap_integer_Get_region);
 1275|      2|}
altclasses.c:InitMmapRealClass:
 1278|      2|{
 1279|      2|    R_altrep_class_t cls =
 1280|      2|	R_make_altreal_class("mmap_real", MMAPPKG, dll);
  ------------------
  |  | 1253|      2|# define MMAPPKG "base"
  ------------------
 1281|      2|    mmap_real_class = cls;
 1282|       |
 1283|       |    /* override ALTREP methods */
 1284|      2|    R_set_altrep_Unserialize_method(cls, mmap_Unserialize);
 1285|      2|    R_set_altrep_Serialized_state_method(cls, mmap_Serialized_state);
 1286|      2|    R_set_altrep_Inspect_method(cls, mmap_Inspect);
 1287|      2|    R_set_altrep_Length_method(cls, mmap_Length);
 1288|       |
 1289|       |    /* override ALTVEC methods */
 1290|      2|    R_set_altvec_Dataptr_method(cls, mmap_Dataptr);
 1291|      2|    R_set_altvec_Dataptr_or_null_method(cls, mmap_Dataptr_or_null);
 1292|       |
 1293|       |    /* override ALTREAL methods */
 1294|      2|    R_set_altreal_Elt_method(cls, mmap_real_Elt);
 1295|      2|    R_set_altreal_Get_region_method(cls, mmap_real_Get_region);
 1296|      2|}
altclasses.c:InitWrapIntegerClass:
 1822|      2|{
 1823|      2|    R_altrep_class_t cls =
 1824|      2|	R_make_altinteger_class("wrap_integer", WRAPPKG, dll);
  ------------------
  |  | 1819|      2|#define WRAPPKG "base"
  ------------------
 1825|      2|    wrap_integer_class = cls;
 1826|       | 
 1827|       |    /* override ALTREP methods */
 1828|      2|    R_set_altrep_Unserialize_method(cls, wrapper_Unserialize);
 1829|      2|    R_set_altrep_Serialized_state_method(cls, wrapper_Serialized_state);
 1830|      2|    R_set_altrep_Duplicate_method(cls, wrapper_Duplicate);
 1831|      2|    R_set_altrep_Inspect_method(cls, wrapper_Inspect);
 1832|      2|    R_set_altrep_Length_method(cls, wrapper_Length);
 1833|       |
 1834|       |    /* override ALTVEC methods */
 1835|      2|    R_set_altvec_Dataptr_method(cls, wrapper_Dataptr);
 1836|      2|    R_set_altvec_Dataptr_or_null_method(cls, wrapper_Dataptr_or_null);
 1837|      2|    R_set_altvec_Extract_subset_method(cls, wrapper_Extract_subset);
 1838|       |
 1839|       |    /* override ALTINTEGER methods */
 1840|      2|    R_set_altinteger_Elt_method(cls, wrapper_integer_Elt);
 1841|      2|    R_set_altinteger_Get_region_method(cls, wrapper_integer_Get_region);
 1842|      2|    R_set_altinteger_Is_sorted_method(cls, wrapper_integer_Is_sorted);
 1843|      2|    R_set_altinteger_No_NA_method(cls, wrapper_integer_no_NA);
 1844|      2|}
altclasses.c:wrapper_Length:
 1600|  1.31k|{
 1601|  1.31k|    return XLENGTH(WRAPPER_WRAPPED(x));
  ------------------
  |  | 1466|  1.31k|#define WRAPPER_WRAPPED(x) R_altrep_data1(x)
  ------------------
 1602|  1.31k|}
altclasses.c:WRAPPER_WRAPPED_RW:
 1494|  1.30k|{
 1495|  1.30k|    SEXP data = WRAPPER_WRAPPED(x);
  ------------------
  |  | 1466|  1.30k|#define WRAPPER_WRAPPED(x) R_altrep_data1(x)
  ------------------
 1496|  1.30k|    if (WRAPPER_DATA_IS_LOCKED(x)) {
  ------------------
  |  | 1488|  1.30k|#define WRAPPER_DATA_IS_LOCKED(x) (WRAPPER_DATA_LOCK(x) > 0)
  |  |  ------------------
  |  |  |  | 1486|  1.30k|#define WRAPPER_DATA_LOCK(x) PRSEEN(WRAPPER_METADATA(x))
  |  |  |  |  ------------------
  |  |  |  |  |  | 1468|  1.30k|#define WRAPPER_METADATA(x) R_altrep_data2(x)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1488:35): [True: 1.29k, False: 8]
  |  |  ------------------
  ------------------
 1497|       |	/* Once data is locked it's reference count should remain at one. */
 1498|       |	/* Unless duplicate() doesn't produce a zero reference count object */ 
 1499|  1.29k|	if (MAYBE_SHARED(data) && WRAPPER_DATA_LOCK(x) == 1)
  ------------------
  |  | 1486|      0|#define WRAPPER_DATA_LOCK(x) PRSEEN(WRAPPER_METADATA(x))
  |  |  ------------------
  |  |  |  | 1468|      0|#define WRAPPER_METADATA(x) R_altrep_data2(x)
  |  |  ------------------
  ------------------
  |  Branch (1499:6): [True: 0, False: 1.29k]
  |  Branch (1499:28): [True: 0, False: 0]
  ------------------
 1500|      0|	    error("REFCNT on locked WRAPPER data increased to %d",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 1501|      0|		  REFCNT(data));
 1502|  1.29k|    }
 1503|      8|    else {
 1504|       |	/* If the data might be shared and is accessed for possible
 1505|       |	   modification, then it needs to be duplicated now. */
 1506|      8|	if (MAYBE_SHARED(data)) {
  ------------------
  |  Branch (1506:6): [True: 8, False: 0]
  ------------------
 1507|      8|	    PROTECT(x);
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1508|      8|	    WRAPPER_SET_WRAPPED(x, shallow_duplicate(data));
  ------------------
  |  | 1467|      8|#define WRAPPER_SET_WRAPPED(x, v) R_set_altrep_data1(x, v)
  ------------------
 1509|      8|	    UNPROTECT(1);
  ------------------
  |  |  358|      8|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1510|      8|	    if (REFCNT(WRAPPER_WRAPPED(x)) == 1)
  ------------------
  |  | 1466|      8|#define WRAPPER_WRAPPED(x) R_altrep_data1(x)
  ------------------
  |  Branch (1510:10): [True: 8, False: 0]
  ------------------
 1511|      8|		WRAPPER_LOCK_DATA(x);
  ------------------
  |  | 1489|      8|#define WRAPPER_LOCK_DATA(x) WRAPPER_SET_DATA_LOCK(x, 1)
  |  |  ------------------
  |  |  |  | 1487|      8|#define WRAPPER_SET_DATA_LOCK(x, v) SET_PRSEEN(WRAPPER_METADATA(x), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1468|      8|#define WRAPPER_METADATA(x) R_altrep_data2(x)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1512|      0|	    else
 1513|      0|		WRAPPER_SET_DATA_LOCK(x, 2);
  ------------------
  |  | 1487|      0|#define WRAPPER_SET_DATA_LOCK(x, v) SET_PRSEEN(WRAPPER_METADATA(x), v)
  |  |  ------------------
  |  |  |  | 1468|      0|#define WRAPPER_METADATA(x) R_altrep_data2(x)
  |  |  ------------------
  ------------------
 1514|      8|	}
 1515|      8|	else WRAPPER_LOCK_DATA(x);
  ------------------
  |  | 1489|      0|#define WRAPPER_LOCK_DATA(x) WRAPPER_SET_DATA_LOCK(x, 1)
  |  |  ------------------
  |  |  |  | 1487|      0|#define WRAPPER_SET_DATA_LOCK(x, v) SET_PRSEEN(WRAPPER_METADATA(x), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1468|      0|#define WRAPPER_METADATA(x) R_altrep_data2(x)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1516|      8|    }
 1517|       |
 1518|       |    /* The meta data also needs to be cleared as it may no longer be
 1519|       |       valid after a write. */
 1520|  1.30k|    SEXP meta = WRAPPER_METADATA(x);
  ------------------
  |  | 1468|  1.30k|#define WRAPPER_METADATA(x) R_altrep_data2(x)
  ------------------
 1521|  1.30k|    INTEGER(meta)[0] = UNKNOWN_SORTEDNESS;
 1522|  2.61k|    for (int i = 1; i < NMETA; i++)
  ------------------
  |  | 1453|  2.61k|#define NMETA 2
  ------------------
  |  Branch (1522:21): [True: 1.30k, False: 1.30k]
  ------------------
 1523|  1.30k|	INTEGER(meta)[i] = 0;
 1524|       |
 1525|  1.30k|    return WRAPPER_WRAPPED(x);
  ------------------
  |  | 1466|  1.30k|#define WRAPPER_WRAPPED(x) R_altrep_data1(x)
  ------------------
 1526|  1.30k|}
altclasses.c:InitWrapLogicalClass:
 1847|      2|{
 1848|      2|    R_altrep_class_t cls =
 1849|      2|	R_make_altlogical_class("wrap_logical", WRAPPKG, dll);
  ------------------
  |  | 1819|      2|#define WRAPPKG "base"
  ------------------
 1850|      2|    wrap_logical_class = cls;
 1851|       | 
 1852|       |    /* override ALTREP methods */
 1853|      2|    R_set_altrep_Unserialize_method(cls, wrapper_Unserialize);
 1854|      2|    R_set_altrep_Serialized_state_method(cls, wrapper_Serialized_state);
 1855|      2|    R_set_altrep_Duplicate_method(cls, wrapper_Duplicate);
 1856|      2|    R_set_altrep_Inspect_method(cls, wrapper_Inspect);
 1857|      2|    R_set_altrep_Length_method(cls, wrapper_Length);
 1858|       |
 1859|       |    /* override ALTVEC methods */
 1860|      2|    R_set_altvec_Dataptr_method(cls, wrapper_Dataptr);
 1861|      2|    R_set_altvec_Dataptr_or_null_method(cls, wrapper_Dataptr_or_null);
 1862|      2|    R_set_altvec_Extract_subset_method(cls, wrapper_Extract_subset);
 1863|       |
 1864|       |    /* override ALTLOGICAL methods */
 1865|      2|    R_set_altlogical_Elt_method(cls, wrapper_logical_Elt);
 1866|      2|    R_set_altlogical_Get_region_method(cls, wrapper_logical_Get_region);
 1867|      2|    R_set_altlogical_Is_sorted_method(cls, wrapper_logical_Is_sorted);
 1868|      2|    R_set_altlogical_No_NA_method(cls, wrapper_logical_no_NA);
 1869|      2|}
altclasses.c:InitWrapRealClass:
 1872|      2|{
 1873|      2|    R_altrep_class_t cls =
 1874|      2|	R_make_altreal_class("wrap_real", WRAPPKG, dll);
  ------------------
  |  | 1819|      2|#define WRAPPKG "base"
  ------------------
 1875|      2|    wrap_real_class = cls;
 1876|       | 
 1877|       |    /* override ALTREP methods */
 1878|      2|    R_set_altrep_Unserialize_method(cls, wrapper_Unserialize);
 1879|      2|    R_set_altrep_Serialized_state_method(cls, wrapper_Serialized_state);
 1880|      2|    R_set_altrep_Duplicate_method(cls, wrapper_Duplicate);
 1881|      2|    R_set_altrep_Inspect_method(cls, wrapper_Inspect);
 1882|      2|    R_set_altrep_Length_method(cls, wrapper_Length);
 1883|       |
 1884|       |    /* override ALTVEC methods */
 1885|      2|    R_set_altvec_Dataptr_method(cls, wrapper_Dataptr);
 1886|      2|    R_set_altvec_Dataptr_or_null_method(cls, wrapper_Dataptr_or_null);
 1887|      2|    R_set_altvec_Extract_subset_method(cls, wrapper_Extract_subset);
 1888|       |
 1889|       |    /* override ALTREAL methods */
 1890|      2|    R_set_altreal_Elt_method(cls, wrapper_real_Elt);
 1891|      2|    R_set_altreal_Get_region_method(cls, wrapper_real_Get_region);
 1892|      2|    R_set_altreal_Is_sorted_method(cls, wrapper_real_Is_sorted);
 1893|      2|    R_set_altreal_No_NA_method(cls, wrapper_real_no_NA);
 1894|      2|}
altclasses.c:InitWrapComplexClass:
 1897|      2|{
 1898|      2|    R_altrep_class_t cls =
 1899|      2|	R_make_altcomplex_class("wrap_complex", WRAPPKG, dll);
  ------------------
  |  | 1819|      2|#define WRAPPKG "base"
  ------------------
 1900|      2|    wrap_complex_class = cls;
 1901|       | 
 1902|       |    /* override ALTREP methods */
 1903|      2|    R_set_altrep_Unserialize_method(cls, wrapper_Unserialize);
 1904|      2|    R_set_altrep_Serialized_state_method(cls, wrapper_Serialized_state);
 1905|      2|    R_set_altrep_Duplicate_method(cls, wrapper_Duplicate);
 1906|      2|    R_set_altrep_Inspect_method(cls, wrapper_Inspect);
 1907|      2|    R_set_altrep_Length_method(cls, wrapper_Length);
 1908|       |
 1909|       |    /* override ALTVEC methods */
 1910|      2|    R_set_altvec_Dataptr_method(cls, wrapper_Dataptr);
 1911|      2|    R_set_altvec_Dataptr_or_null_method(cls, wrapper_Dataptr_or_null);
 1912|      2|    R_set_altvec_Extract_subset_method(cls, wrapper_Extract_subset);
 1913|       |
 1914|       |    /* override ALTCOMPLEX methods */
 1915|      2|    R_set_altcomplex_Elt_method(cls, wrapper_complex_Elt);
 1916|      2|    R_set_altcomplex_Get_region_method(cls, wrapper_complex_Get_region);
 1917|      2|}
altclasses.c:InitWrapRawClass:
 1920|      2|{
 1921|      2|    R_altrep_class_t cls =
 1922|      2|	R_make_altraw_class("wrap_raw", WRAPPKG, dll);
  ------------------
  |  | 1819|      2|#define WRAPPKG "base"
  ------------------
 1923|      2|    wrap_raw_class = cls;
 1924|       | 
 1925|       |    /* override ALTREP methods */
 1926|      2|    R_set_altrep_Unserialize_method(cls, wrapper_Unserialize);
 1927|      2|    R_set_altrep_Serialized_state_method(cls, wrapper_Serialized_state);
 1928|      2|    R_set_altrep_Duplicate_method(cls, wrapper_Duplicate);
 1929|      2|    R_set_altrep_Inspect_method(cls, wrapper_Inspect);
 1930|      2|    R_set_altrep_Length_method(cls, wrapper_Length);
 1931|       |
 1932|       |    /* override ALTVEC methods */
 1933|      2|    R_set_altvec_Dataptr_method(cls, wrapper_Dataptr);
 1934|      2|    R_set_altvec_Dataptr_or_null_method(cls, wrapper_Dataptr_or_null);
 1935|      2|    R_set_altvec_Extract_subset_method(cls, wrapper_Extract_subset);
 1936|       |
 1937|       |    /* override ALTRAW methods */
 1938|      2|    R_set_altraw_Elt_method(cls, wrapper_raw_Elt);
 1939|      2|    R_set_altraw_Get_region_method(cls, wrapper_raw_Get_region);
 1940|      2|}
altclasses.c:InitWrapStringClass:
 1943|      2|{
 1944|      2|    R_altrep_class_t cls =
 1945|      2|	R_make_altstring_class("wrap_string", WRAPPKG, dll);
  ------------------
  |  | 1819|      2|#define WRAPPKG "base"
  ------------------
 1946|      2|    wrap_string_class = cls;
 1947|       | 
 1948|       |    /* override ALTREP methods */
 1949|      2|    R_set_altrep_Unserialize_method(cls, wrapper_Unserialize);
 1950|      2|    R_set_altrep_Serialized_state_method(cls, wrapper_Serialized_state);
 1951|      2|    R_set_altrep_Duplicate_method(cls, wrapper_Duplicate);
 1952|      2|    R_set_altrep_Inspect_method(cls, wrapper_Inspect);
 1953|      2|    R_set_altrep_Length_method(cls, wrapper_Length);
 1954|       |
 1955|       |    /* override ALTVEC methods */
 1956|      2|    R_set_altvec_Dataptr_method(cls, wrapper_Dataptr);
 1957|      2|    R_set_altvec_Dataptr_or_null_method(cls, wrapper_Dataptr_or_null);
 1958|      2|    R_set_altvec_Extract_subset_method(cls, wrapper_Extract_subset);
 1959|       |
 1960|       |    /* override ALTSTRING methods */
 1961|      2|    R_set_altstring_Elt_method(cls, wrapper_string_Elt);
 1962|      2|    R_set_altstring_Set_elt_method(cls, wrapper_string_Set_elt);
 1963|      2|    R_set_altstring_Is_sorted_method(cls, wrapper_string_Is_sorted);
 1964|      2|    R_set_altstring_No_NA_method(cls, wrapper_string_no_NA);
 1965|      2|}
altclasses.c:wrapper_string_Set_elt:
 1778|  1.30k|{
 1779|  1.30k|    SET_STRING_ELT(WRAPPER_WRAPPED_RW(x), i, v);
 1780|  1.30k|}
altclasses.c:InitWrapListClass:
 1968|      2|{
 1969|      2|    R_altrep_class_t cls =
 1970|      2|	R_make_altlist_class("wrap_list", WRAPPKG, dll);
  ------------------
  |  | 1819|      2|#define WRAPPKG "base"
  ------------------
 1971|      2|    wrap_list_class = cls;
 1972|       |
 1973|       |    /* override ALTREP methods */
 1974|      2|    R_set_altrep_Unserialize_method(cls, wrapper_Unserialize);
 1975|      2|    R_set_altrep_Serialized_state_method(cls, wrapper_Serialized_state);
 1976|      2|    R_set_altrep_Duplicate_method(cls, wrapper_Duplicate);
 1977|      2|    R_set_altrep_Inspect_method(cls, wrapper_Inspect);
 1978|      2|    R_set_altrep_Length_method(cls, wrapper_Length);
 1979|       |
 1980|       |    /* override ALTVEC methods */
 1981|      2|    R_set_altvec_Dataptr_method(cls, wrapper_Dataptr);
 1982|      2|    R_set_altvec_Dataptr_or_null_method(cls, wrapper_Dataptr_or_null);
 1983|      2|    R_set_altvec_Extract_subset_method(cls, wrapper_Extract_subset);
 1984|       |
 1985|       |    /* override ALTLIST methods */
 1986|      2|    R_set_altlist_Elt_method(cls, wrapper_list_Elt);
 1987|      2|    R_set_altlist_Set_elt_method(cls, wrapper_list_Set_elt);
 1988|      2|}

ALTREP_UNSERIALIZE_EX:
  350|      8|{
  351|      8|    if (! valid_altrep_serialized_class(info))
  ------------------
  |  Branch (351:9): [True: 0, False: 8]
  ------------------
  352|      0|	error("invalid ALTREP serialized class");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  353|       |
  354|      8|    SEXP csym = ALTREP_SERIALIZED_CLASS_CLSSYM(info);
  ------------------
  |  |   40|      8|#define ALTREP_SERIALIZED_CLASS_CLSSYM(x) CAR(x)
  ------------------
  355|      8|    SEXP psym = ALTREP_SERIALIZED_CLASS_PKGSYM(info);
  ------------------
  |  |   41|      8|#define ALTREP_SERIALIZED_CLASS_PKGSYM(x) CADR(x)
  ------------------
  356|      8|    int type = ALTREP_SERIALIZED_CLASS_TYPE(info);
  ------------------
  |  |   42|      8|#define ALTREP_SERIALIZED_CLASS_TYPE(x) INTEGER0(CADDR(x))[0]
  ------------------
  357|       |
  358|       |    /* look up the class in the registry and handle failure */
  359|      8|    SEXP class = ALTREP_UNSERIALIZE_CLASS(info);
  360|      8|    if (class == NULL) {
  ------------------
  |  Branch (360:9): [True: 0, False: 8]
  ------------------
  361|      0|	switch(type) {
  362|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (362:2): [True: 0, False: 0]
  ------------------
  363|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (363:2): [True: 0, False: 0]
  ------------------
  364|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (364:2): [True: 0, False: 0]
  ------------------
  365|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (365:2): [True: 0, False: 0]
  ------------------
  366|      0|	case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (366:2): [True: 0, False: 0]
  ------------------
  367|      0|	case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (367:2): [True: 0, False: 0]
  ------------------
  368|      0|	case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (368:2): [True: 0, False: 0]
  ------------------
  369|      0|	case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (369:2): [True: 0, False: 0]
  ------------------
  370|      0|	    warning("cannot unserialize ALTVEC object of class '%s' from "
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  371|      0|		    "package '%s'; returning length zero vector",
  372|      0|		    CHAR(PRINTNAME(csym)), CHAR(PRINTNAME(psym)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
              		    CHAR(PRINTNAME(csym)), CHAR(PRINTNAME(psym)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  373|      0|	    return allocVector(type, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
  374|      0|	default:
  ------------------
  |  Branch (374:2): [True: 0, False: 0]
  ------------------
  375|      0|	    error("cannot unserialize this ALTREP object");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  376|      0|	}
  377|      0|    }
  378|       |
  379|       |    /* check the registered and unserialized types match */
  380|      8|    int rtype = ALTREP_CLASS_BASE_TYPE(class);
  ------------------
  |  |   49|      8|    ALTREP_SERIALIZED_CLASS_TYPE(ALTREP_CLASS_SERIALIZED_CLASS(x))
  |  |  ------------------
  |  |  |  |   42|      8|#define ALTREP_SERIALIZED_CLASS_TYPE(x) INTEGER0(CADDR(x))[0]
  |  |  ------------------
  ------------------
  381|      8|    if (type != rtype)
  ------------------
  |  Branch (381:9): [True: 0, False: 8]
  ------------------
  382|      0|	warning("serialized class '%s' from package '%s' has type %s; "
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  383|      0|		"registered class has type %s",
  384|      0|		CHAR(PRINTNAME(csym)), CHAR(PRINTNAME(psym)),
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
              		CHAR(PRINTNAME(csym)), CHAR(PRINTNAME(psym)),
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  385|      0|		type2char(type), type2char(rtype));
  ------------------
  |  | 1040|      0|#define type2char		Rf_type2char
  ------------------
              		type2char(type), type2char(rtype));
  ------------------
  |  | 1040|      0|#define type2char		Rf_type2char
  ------------------
  386|       |    
  387|       |    /* dispatch to a class method */
  388|      8|    altrep_methods_t *m = CLASS_METHODS_TABLE(class);
  ------------------
  |  |  125|      8|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
  389|      8|    SEXP val = m->UnserializeEX(class, state, attr, objf, levs);
  390|      8|    return val;
  391|      8|}
ALTREP_LENGTH:
  394|  3.17k|{
  395|  3.17k|    return ALTREP_DISPATCH(Length, x);
  ------------------
  |  |  225|  3.17k|#define ALTREP_DISPATCH(fun, ...) DO_DISPATCH(ALTREP, fun, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  223|  3.17k|    type##_METHODS_TABLE(DISPATCH_TARGET(__VA_ARGS__))->fun(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |  129|  3.17k|#define ALTREP_METHODS_TABLE(x) GENERIC_METHODS_TABLE(x, altrep)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  127|  3.17k|    ((class##_methods_t *) CLASS_METHODS_TABLE(ALTREP_CLASS(x)))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  125|  3.17k|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  396|  3.17k|}
ALTVEC_DATAPTR_RO:
  433|    852|{
  434|    852|    return ALTVEC_DATAPTR_EX(x, FALSE);
  435|    852|}
ALTVEC_EXTRACT_SUBSET:
  445|     24|{
  446|     24|    return ALTVEC_DISPATCH(Extract_subset, x, indx, call);
  ------------------
  |  |  226|     24|#define ALTVEC_DISPATCH(fun, ...) DO_DISPATCH(ALTVEC, fun, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  223|     24|    type##_METHODS_TABLE(DISPATCH_TARGET(__VA_ARGS__))->fun(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |  130|     24|#define ALTVEC_METHODS_TABLE(x) GENERIC_METHODS_TABLE(x, altvec)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  127|     24|    ((class##_methods_t *) CLASS_METHODS_TABLE(ALTREP_CLASS(x)))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  125|     24|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  447|     24|}
ALTINTEGER_ELT:
  455|    337|{
  456|    337|    int val;
  457|    337|    NOGC_DISPATCH(val, ALTINTEGER_DISPATCH(Elt, x, i));
  ------------------
  |  |  242|    337|#define NOGC_DISPATCH(val, call) do {		\
  |  |  243|    337|	R_CHECK_THREAD;				\
  |  |  ------------------
  |  |  |  |  566|    337|# define R_CHECK_THREAD R_check_thread(__func__)
  |  |  ------------------
  |  |  244|    337|	int enabled__ = R_GCEnabled;		\
  |  |  245|    337|	R_GCEnabled = FALSE;			\
  |  |  246|    337|	val = call;				\
  |  |  247|    337|	R_GCEnabled = enabled__;		\
  |  |  248|    337|    } while (0)
  |  |  ------------------
  |  |  |  Branch (248:14): [Folded, False: 337]
  |  |  ------------------
  ------------------
  458|    337|    return val;
  459|    337|}
INTEGER_IS_SORTED:
  480|     10|{
  481|     10|    if (! ALTREP(x))
  ------------------
  |  Branch (481:9): [True: 10, False: 0]
  ------------------
  482|     10|	return UNKNOWN_SORTEDNESS;
  483|      0|    int val;
  484|      0|    NOGC_DISPATCH(val, ALTINTEGER_DISPATCH(Is_sorted, x));
  ------------------
  |  |  242|      0|#define NOGC_DISPATCH(val, call) do {		\
  |  |  243|      0|	R_CHECK_THREAD;				\
  |  |  ------------------
  |  |  |  |  566|      0|# define R_CHECK_THREAD R_check_thread(__func__)
  |  |  ------------------
  |  |  244|      0|	int enabled__ = R_GCEnabled;		\
  |  |  245|      0|	R_GCEnabled = FALSE;			\
  |  |  246|      0|	val = call;				\
  |  |  247|      0|	R_GCEnabled = enabled__;		\
  |  |  248|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (248:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  485|      0|    return val;
  486|     10|}
INTEGER_NO_NA:
  489|     68|{
  490|     68|    if (! ALTREP(x))
  ------------------
  |  Branch (490:9): [True: 68, False: 0]
  ------------------
  491|     68|	return 0;
  492|      0|    int val;
  493|      0|    NOGC_DISPATCH(val, ALTINTEGER_DISPATCH(No_NA, x));
  ------------------
  |  |  242|      0|#define NOGC_DISPATCH(val, call) do {		\
  |  |  243|      0|	R_CHECK_THREAD;				\
  |  |  ------------------
  |  |  |  |  566|      0|# define R_CHECK_THREAD R_check_thread(__func__)
  |  |  ------------------
  |  |  244|      0|	int enabled__ = R_GCEnabled;		\
  |  |  245|      0|	R_GCEnabled = FALSE;			\
  |  |  246|      0|	val = call;				\
  |  |  247|      0|	R_GCEnabled = enabled__;		\
  |  |  248|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (248:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  494|      0|    return val;
  495|     68|}
ALTSTRING_ELT:
  617|     41|{
  618|     41|    SEXP val = NULL;
  619|       |
  620|       |    /**** move GC disabling into method? */
  621|     41|    if (R_in_gc)
  ------------------
  |  Branch (621:9): [True: 0, False: 41]
  ------------------
  622|      0|	error("cannot get ALTSTRING_ELT during GC");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  623|     41|    R_CHECK_THREAD;
  ------------------
  |  |  566|     41|# define R_CHECK_THREAD R_check_thread(__func__)
  ------------------
  624|     41|    int enabled = R_GCEnabled;
  625|     41|    R_GCEnabled = FALSE;
  626|       |
  627|     41|    val = ALTSTRING_DISPATCH(Elt, x, i);
  ------------------
  |  |  232|     41|#define ALTSTRING_DISPATCH(fun, ...) DO_DISPATCH(ALTSTRING, fun, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  223|     41|    type##_METHODS_TABLE(DISPATCH_TARGET(__VA_ARGS__))->fun(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |  136|     41|#define ALTSTRING_METHODS_TABLE(x) GENERIC_METHODS_TABLE(x, altstring)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  127|     41|    ((class##_methods_t *) CLASS_METHODS_TABLE(ALTREP_CLASS(x)))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  125|     41|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  628|       |
  629|     41|    R_GCEnabled = enabled;
  630|     41|    return val;
  631|     41|}
ALTSTRING_SET_ELT:
  634|  1.30k|{
  635|       |    /**** move GC disabling into method? */
  636|  1.30k|    if (R_in_gc)
  ------------------
  |  Branch (636:9): [True: 0, False: 1.30k]
  ------------------
  637|      0|	error("cannot set ALTSTRING_ELT during GC");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  638|  1.30k|    R_CHECK_THREAD;
  ------------------
  |  |  566|  1.30k|# define R_CHECK_THREAD R_check_thread(__func__)
  ------------------
  639|  1.30k|    int enabled = R_GCEnabled;
  640|  1.30k|    R_GCEnabled = FALSE;
  641|       |
  642|  1.30k|    ALTSTRING_DISPATCH(Set_elt, x, i, v);
  ------------------
  |  |  232|  1.30k|#define ALTSTRING_DISPATCH(fun, ...) DO_DISPATCH(ALTSTRING, fun, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  223|  1.30k|    type##_METHODS_TABLE(DISPATCH_TARGET(__VA_ARGS__))->fun(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |  136|  1.30k|#define ALTSTRING_METHODS_TABLE(x) GENERIC_METHODS_TABLE(x, altstring)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  127|  1.30k|    ((class##_methods_t *) CLASS_METHODS_TABLE(ALTREP_CLASS(x)))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  125|  1.30k|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  643|       |
  644|  1.30k|    R_GCEnabled = enabled;
  645|  1.30k|}
R_make_altstring_class:
 1170|      4|    {								\
 1171|      4|	return  make_altrep_class(type, cname, pname, dll);	\
 1172|      4|    }
R_make_altlist_class:
 1170|      2|    {								\
 1171|      2|	return  make_altrep_class(type, cname, pname, dll);	\
 1172|      2|    }
R_make_altinteger_class:
 1170|      6|    {								\
 1171|      6|	return  make_altrep_class(type, cname, pname, dll);	\
 1172|      6|    }
R_make_altreal_class:
 1170|      6|    {								\
 1171|      6|	return  make_altrep_class(type, cname, pname, dll);	\
 1172|      6|    }
R_make_altlogical_class:
 1170|      2|    {								\
 1171|      2|	return  make_altrep_class(type, cname, pname, dll);	\
 1172|      2|    }
R_make_altraw_class:
 1170|      2|    {								\
 1171|      2|	return  make_altrep_class(type, cname, pname, dll);	\
 1172|      2|    }
R_make_altcomplex_class:
 1170|      2|    {								\
 1171|      2|	return  make_altrep_class(type, cname, pname, dll);	\
 1172|      2|    }
R_set_altrep_Unserialize_method:
 1204|     24|    {									\
 1205|     24|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|     24|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|     24|	m->MNAME = fun;							\
 1207|     24|    }
R_set_altrep_Serialized_state_method:
 1204|     24|    {									\
 1205|     24|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|     24|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|     24|	m->MNAME = fun;							\
 1207|     24|    }
R_set_altrep_Duplicate_method:
 1204|     18|    {									\
 1205|     18|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|     18|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|     18|	m->MNAME = fun;							\
 1207|     18|    }
R_set_altrep_Coerce_method:
 1204|      2|    {									\
 1205|      2|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      2|	m->MNAME = fun;							\
 1207|      2|    }
R_set_altrep_Inspect_method:
 1204|     24|    {									\
 1205|     24|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|     24|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|     24|	m->MNAME = fun;							\
 1207|     24|    }
R_set_altrep_Length_method:
 1204|     24|    {									\
 1205|     24|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|     24|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|     24|	m->MNAME = fun;							\
 1207|     24|    }
R_set_altvec_Dataptr_method:
 1204|     24|    {									\
 1205|     24|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|     24|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|     24|	m->MNAME = fun;							\
 1207|     24|    }
R_set_altvec_Dataptr_or_null_method:
 1204|     24|    {									\
 1205|     24|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|     24|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|     24|	m->MNAME = fun;							\
 1207|     24|    }
R_set_altvec_Extract_subset_method:
 1204|     16|    {									\
 1205|     16|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|     16|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|     16|	m->MNAME = fun;							\
 1207|     16|    }
R_set_altinteger_Elt_method:
 1204|      6|    {									\
 1205|      6|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      6|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      6|	m->MNAME = fun;							\
 1207|      6|    }
R_set_altinteger_Get_region_method:
 1204|      6|    {									\
 1205|      6|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      6|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      6|	m->MNAME = fun;							\
 1207|      6|    }
R_set_altinteger_Is_sorted_method:
 1204|      4|    {									\
 1205|      4|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      4|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      4|	m->MNAME = fun;							\
 1207|      4|    }
R_set_altinteger_No_NA_method:
 1204|      4|    {									\
 1205|      4|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      4|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      4|	m->MNAME = fun;							\
 1207|      4|    }
R_set_altinteger_Sum_method:
 1204|      2|    {									\
 1205|      2|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      2|	m->MNAME = fun;							\
 1207|      2|    }
R_set_altreal_Elt_method:
 1204|      6|    {									\
 1205|      6|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      6|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      6|	m->MNAME = fun;							\
 1207|      6|    }
R_set_altreal_Get_region_method:
 1204|      6|    {									\
 1205|      6|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      6|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      6|	m->MNAME = fun;							\
 1207|      6|    }
R_set_altreal_Is_sorted_method:
 1204|      4|    {									\
 1205|      4|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      4|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      4|	m->MNAME = fun;							\
 1207|      4|    }
R_set_altreal_No_NA_method:
 1204|      4|    {									\
 1205|      4|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      4|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      4|	m->MNAME = fun;							\
 1207|      4|    }
R_set_altreal_Sum_method:
 1204|      2|    {									\
 1205|      2|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      2|	m->MNAME = fun;							\
 1207|      2|    }
R_set_altlogical_Elt_method:
 1204|      2|    {									\
 1205|      2|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      2|	m->MNAME = fun;							\
 1207|      2|    }
R_set_altlogical_Get_region_method:
 1204|      2|    {									\
 1205|      2|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      2|	m->MNAME = fun;							\
 1207|      2|    }
R_set_altlogical_Is_sorted_method:
 1204|      2|    {									\
 1205|      2|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      2|	m->MNAME = fun;							\
 1207|      2|    }
R_set_altlogical_No_NA_method:
 1204|      2|    {									\
 1205|      2|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      2|	m->MNAME = fun;							\
 1207|      2|    }
R_set_altraw_Elt_method:
 1204|      2|    {									\
 1205|      2|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      2|	m->MNAME = fun;							\
 1207|      2|    }
R_set_altraw_Get_region_method:
 1204|      2|    {									\
 1205|      2|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      2|	m->MNAME = fun;							\
 1207|      2|    }
R_set_altcomplex_Elt_method:
 1204|      2|    {									\
 1205|      2|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      2|	m->MNAME = fun;							\
 1207|      2|    }
R_set_altcomplex_Get_region_method:
 1204|      2|    {									\
 1205|      2|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      2|	m->MNAME = fun;							\
 1207|      2|    }
R_set_altstring_Elt_method:
 1204|      4|    {									\
 1205|      4|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      4|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      4|	m->MNAME = fun;							\
 1207|      4|    }
R_set_altstring_Set_elt_method:
 1204|      4|    {									\
 1205|      4|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      4|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      4|	m->MNAME = fun;							\
 1207|      4|    }
R_set_altstring_Is_sorted_method:
 1204|      4|    {									\
 1205|      4|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      4|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      4|	m->MNAME = fun;							\
 1207|      4|    }
R_set_altstring_No_NA_method:
 1204|      4|    {									\
 1205|      4|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      4|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      4|	m->MNAME = fun;							\
 1207|      4|    }
R_set_altlist_Elt_method:
 1204|      2|    {									\
 1205|      2|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      2|	m->MNAME = fun;							\
 1207|      2|    }
R_set_altlist_Set_elt_method:
 1204|      2|    {									\
 1205|      2|	CNAME##_methods_t *m = CLASS_METHODS_TABLE(R_SEXP(cls));	\
  ------------------
  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
 1206|      2|	m->MNAME = fun;							\
 1207|      2|    }
R_new_altrep:
 1263|    247|{
 1264|    247|    void ALTREP_SET_TYPEOF(SEXP, int); /* in memory.c */
 1265|    247|    SEXP sclass = R_SEXP(aclass);
  ------------------
  |  |   37|    247|# define R_SEXP(x) (x).ptr
  ------------------
 1266|    247|    int type = ALTREP_CLASS_BASE_TYPE(sclass);
  ------------------
  |  |   49|    247|    ALTREP_SERIALIZED_CLASS_TYPE(ALTREP_CLASS_SERIALIZED_CLASS(x))
  |  |  ------------------
  |  |  |  |   42|    247|#define ALTREP_SERIALIZED_CLASS_TYPE(x) INTEGER0(CADDR(x))[0]
  |  |  ------------------
  ------------------
 1267|    247|    SEXP ans = CONS(data1, data2);
  ------------------
  |  |  309|    247|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 1268|    247|    ALTREP_SET_TYPEOF(ans, type);
 1269|    247|    SET_ALTREP_CLASS(ans, sclass);
 1270|    247|    return ans;
 1271|    247|}
R_altrep_inherits:
 1274|      8|{
 1275|      8|    return ALTREP(x) && ALTREP_CLASS(x) == R_SEXP(class);
  ------------------
  |  |   37|     16|# define R_SEXP(x) (x).ptr
  ------------------
  |  Branch (1275:12): [True: 8, False: 0]
  |  Branch (1275:25): [True: 8, False: 0]
  ------------------
 1276|      8|}
altrep.c:valid_altrep_serialized_class:
  312|      8|{
  313|      8|    if (TYPEOF(info) != LISTSXP)
  ------------------
  |  |  113|      8|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (313:9): [True: 0, False: 8]
  ------------------
  314|      0|	return FALSE;
  315|      8|    SEXP rest = CDR(info);
  316|      8|    if (TYPEOF(rest) != LISTSXP)
  ------------------
  |  |  113|      8|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (316:9): [True: 0, False: 8]
  ------------------
  317|      0|	return FALSE;
  318|      8|    rest = CDR(rest);
  319|      8|    if (TYPEOF(rest) != LISTSXP || CDR(rest) != R_NilValue)
  ------------------
  |  |  113|     16|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (319:9): [True: 0, False: 8]
  |  Branch (319:36): [True: 0, False: 8]
  ------------------
  320|      0|	return FALSE;
  321|       |
  322|      8|    SEXP stype = CAR(rest);
  323|      8|    return TYPEOF(CAR(info)) == SYMSXP &&
  ------------------
  |  |  112|     16|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (323:12): [True: 8, False: 0]
  ------------------
  324|      8|	TYPEOF(CADR(info)) == SYMSXP &&
  ------------------
  |  |  112|     16|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (324:2): [True: 8, False: 0]
  ------------------
  325|      8|	TYPEOF(stype) == INTSXP && XLENGTH(stype) == 1 &&
  ------------------
  |  |  123|     16|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (325:2): [True: 8, False: 0]
  |  Branch (325:29): [True: 8, False: 0]
  ------------------
  326|      8|	valid_altrep_serialized_type(INTEGER0(stype)[0]);
  ------------------
  |  Branch (326:2): [True: 8, False: 0]
  ------------------
  327|      8|}
altrep.c:valid_altrep_serialized_type:
  295|      8|{
  296|      8|    switch(type) {
  297|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (297:5): [True: 0, False: 8]
  ------------------
  298|      8|    case INTSXP:
  ------------------
  |  |  123|      8|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (298:5): [True: 8, False: 0]
  ------------------
  299|      8|    case REALSXP:
  ------------------
  |  |  124|      8|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (299:5): [True: 0, False: 8]
  ------------------
  300|      8|    case CPLXSXP:
  ------------------
  |  |  125|      8|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (300:5): [True: 0, False: 8]
  ------------------
  301|      8|    case STRSXP:
  ------------------
  |  |  126|      8|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (301:5): [True: 0, False: 8]
  ------------------
  302|      8|    case RAWSXP:
  ------------------
  |  |  136|      8|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (302:5): [True: 0, False: 8]
  ------------------
  303|      8|    case VECSXP:
  ------------------
  |  |  131|      8|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (303:5): [True: 0, False: 8]
  ------------------
  304|      8|    case EXPRSXP:
  ------------------
  |  |  132|      8|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (304:5): [True: 0, False: 8]
  ------------------
  305|      8|	return true;
  306|      0|    default:
  ------------------
  |  Branch (306:5): [True: 0, False: 8]
  ------------------
  307|      0|	return false;
  308|      8|    }
  309|      8|}
altrep.c:ALTREP_UNSERIALIZE_CLASS:
  330|      8|{
  331|      8|    if (TYPEOF(info) == LISTSXP) {
  ------------------
  |  |  113|      8|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (331:9): [True: 8, False: 0]
  ------------------
  332|      8|	SEXP csym = ALTREP_SERIALIZED_CLASS_CLSSYM(info);
  ------------------
  |  |   40|      8|#define ALTREP_SERIALIZED_CLASS_CLSSYM(x) CAR(x)
  ------------------
  333|      8|	SEXP psym = ALTREP_SERIALIZED_CLASS_PKGSYM(info);
  ------------------
  |  |   41|      8|#define ALTREP_SERIALIZED_CLASS_PKGSYM(x) CADR(x)
  ------------------
  334|      8|	SEXP class = LookupClass(csym, psym);
  335|      8|	if (class == NULL) {
  ------------------
  |  Branch (335:6): [True: 0, False: 8]
  ------------------
  336|      0|	    SEXP pname = ScalarString(PRINTNAME(psym));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
  337|      0|	    PROTECT(pname);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  338|      0|	    R_tryCatchError(find_namespace, pname,
  339|      0|			    handle_namespace_error, NULL);
  340|      0|	    class = LookupClass(csym, psym);
  341|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  342|      0|	}
  343|      8|	return class;
  344|      8|    }
  345|      0|    return NULL;
  346|      8|}
altrep.c:LookupClass:
   91|      8|{
   92|      8|    SEXP entry = LookupClassEntry(csym, psym);
   93|      8|    return entry != NULL ? CAR(entry) : NULL;
  ------------------
  |  Branch (93:12): [True: 8, False: 0]
  ------------------
   94|      8|}
altrep.c:LookupClassEntry:
   54|     32|{
   55|    252|    for (SEXP chain = CDR(Registry); chain != R_NilValue; chain = CDR(chain))
  ------------------
  |  Branch (55:38): [True: 228, False: 24]
  ------------------
   56|    228|	if (TAG(CAR(chain)) == csym && CADR(CAR(chain)) == psym)
  ------------------
  |  Branch (56:6): [True: 8, False: 220]
  |  Branch (56:33): [True: 8, False: 0]
  ------------------
   57|      8|	    return CAR(chain);
   58|     24|    return NULL;
   59|     32|}
altrep.c:ALTVEC_DATAPTR_EX:
  406|    852|{
  407|       |    /* Disallow taking the writable `DATAPTR()` of an ALTLIST. This
  408|       |       check could be moved to `DATAPTR()` to catch more faulty
  409|       |       usages. */
  410|    852|    if (TYPEOF(x) == VECSXP && writable)
  ------------------
  |  |  131|  1.70k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (410:9): [True: 0, False: 852]
  |  Branch (410:32): [True: 0, False: 0]
  ------------------
  411|      0|        ALTREP_ERROR_IN_CLASS("cannot take a writable DATAPTR of an ALTLIST",
  ------------------
  |  |  112|      0|#define ALTREP_ERROR_IN_CLASS(msg, x) do {			\
  |  |  113|      0|	error("%s [class: %s, pkg: %s]",			\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  114|      0|	      msg,						\
  |  |  115|      0|	      CHAR(PRINTNAME(ALTREP_OBJECT_CLSSYM(x))),		\
  |  |  ------------------
  |  |  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  |  |  116|      0|	      CHAR(PRINTNAME(ALTREP_OBJECT_PKGSYM(x))));	\
  |  |  ------------------
  |  |  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  |  |  117|      0|    } while(0)
  |  |  ------------------
  |  |  |  Branch (117:13): [Folded, False: 0]
  |  |  ------------------
  ------------------
  412|    852|			      x);
  413|       |
  414|       |    /**** move GC disabling into methods? */
  415|    852|    if (R_in_gc)
  ------------------
  |  Branch (415:9): [True: 0, False: 852]
  ------------------
  416|      0|	error("cannot get ALTVEC DATAPTR during GC");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  417|    852|    R_CHECK_THREAD;
  ------------------
  |  |  566|    852|# define R_CHECK_THREAD R_check_thread(__func__)
  ------------------
  418|    852|    int enabled = R_GCEnabled;
  419|    852|    R_GCEnabled = FALSE;
  420|       |
  421|    852|    void *val = ALTVEC_DISPATCH(Dataptr, x, writable);
  ------------------
  |  |  226|    852|#define ALTVEC_DISPATCH(fun, ...) DO_DISPATCH(ALTVEC, fun, __VA_ARGS__)
  |  |  ------------------
  |  |  |  |  223|    852|    type##_METHODS_TABLE(DISPATCH_TARGET(__VA_ARGS__))->fun(__VA_ARGS__)
  |  |  |  |  ------------------
  |  |  |  |  |  |  130|    852|#define ALTVEC_METHODS_TABLE(x) GENERIC_METHODS_TABLE(x, altvec)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  127|    852|    ((class##_methods_t *) CLASS_METHODS_TABLE(ALTREP_CLASS(x)))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  125|    852|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  422|       |
  423|    852|    R_GCEnabled = enabled;
  424|    852|    return val;
  425|    852|}
altrep.c:make_altrep_class:
 1147|     24|{
 1148|     24|    SEXP class;
 1149|     24|    switch(type) {
 1150|      6|    case INTSXP:  MAKE_CLASS(class, altinteger); break;
  ------------------
  |  |  123|      6|#define INTSXP	    13	  /* integer vectors */
  ------------------
                  case INTSXP:  MAKE_CLASS(class, altinteger); break;
  ------------------
  |  | 1132|      6|#define MAKE_CLASS(var, type) do {				\
  |  | 1133|      6|	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  875|      6|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  |               	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  136|      6|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  | 1134|      6|	R_PreserveObject(var);					\
  |  | 1135|      6|	INIT_CLASS(var, type);					\
  |  |  ------------------
  |  |  |  | 1127|      6|#define INIT_CLASS(cls, type) do {				\
  |  |  |  | 1128|      6|	*((type##_methods_t *) (CLASS_METHODS_TABLE(cls))) =	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      6|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  |  |  |  |  ------------------
  |  |  |  | 1129|      6|	    type##_default_methods;				\
  |  |  |  | 1130|      6|    } while (FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1130:14): [Folded, False: 6]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1136|      6|    } while (FALSE)
  |  |  ------------------
  |  |  |  Branch (1136:14): [Folded, False: 6]
  |  |  ------------------
  ------------------
  |  Branch (1150:5): [True: 6, False: 18]
  ------------------
 1151|      6|    case REALSXP: MAKE_CLASS(class, altreal);    break;
  ------------------
  |  |  124|      6|#define REALSXP	    14	  /* real variables */
  ------------------
                  case REALSXP: MAKE_CLASS(class, altreal);    break;
  ------------------
  |  | 1132|      6|#define MAKE_CLASS(var, type) do {				\
  |  | 1133|      6|	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  875|      6|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  |               	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  136|      6|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  | 1134|      6|	R_PreserveObject(var);					\
  |  | 1135|      6|	INIT_CLASS(var, type);					\
  |  |  ------------------
  |  |  |  | 1127|      6|#define INIT_CLASS(cls, type) do {				\
  |  |  |  | 1128|      6|	*((type##_methods_t *) (CLASS_METHODS_TABLE(cls))) =	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      6|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  |  |  |  |  ------------------
  |  |  |  | 1129|      6|	    type##_default_methods;				\
  |  |  |  | 1130|      6|    } while (FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1130:14): [Folded, False: 6]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1136|      6|    } while (FALSE)
  |  |  ------------------
  |  |  |  Branch (1136:14): [Folded, False: 6]
  |  |  ------------------
  ------------------
  |  Branch (1151:5): [True: 6, False: 18]
  ------------------
 1152|      2|    case LGLSXP:  MAKE_CLASS(class, altlogical); break;
  ------------------
  |  |  121|      2|#define LGLSXP	    10	  /* logical vectors */
  ------------------
                  case LGLSXP:  MAKE_CLASS(class, altlogical); break;
  ------------------
  |  | 1132|      2|#define MAKE_CLASS(var, type) do {				\
  |  | 1133|      2|	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  875|      2|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  |               	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  136|      2|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  | 1134|      2|	R_PreserveObject(var);					\
  |  | 1135|      2|	INIT_CLASS(var, type);					\
  |  |  ------------------
  |  |  |  | 1127|      2|#define INIT_CLASS(cls, type) do {				\
  |  |  |  | 1128|      2|	*((type##_methods_t *) (CLASS_METHODS_TABLE(cls))) =	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  |  |  |  |  ------------------
  |  |  |  | 1129|      2|	    type##_default_methods;				\
  |  |  |  | 1130|      2|    } while (FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1130:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1136|      2|    } while (FALSE)
  |  |  ------------------
  |  |  |  Branch (1136:14): [Folded, False: 2]
  |  |  ------------------
  ------------------
  |  Branch (1152:5): [True: 2, False: 22]
  ------------------
 1153|      2|    case RAWSXP:  MAKE_CLASS(class, altraw);     break;
  ------------------
  |  |  136|      2|#define RAWSXP      24    /* raw bytes */
  ------------------
                  case RAWSXP:  MAKE_CLASS(class, altraw);     break;
  ------------------
  |  | 1132|      2|#define MAKE_CLASS(var, type) do {				\
  |  | 1133|      2|	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  875|      2|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  |               	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  136|      2|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  | 1134|      2|	R_PreserveObject(var);					\
  |  | 1135|      2|	INIT_CLASS(var, type);					\
  |  |  ------------------
  |  |  |  | 1127|      2|#define INIT_CLASS(cls, type) do {				\
  |  |  |  | 1128|      2|	*((type##_methods_t *) (CLASS_METHODS_TABLE(cls))) =	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  |  |  |  |  ------------------
  |  |  |  | 1129|      2|	    type##_default_methods;				\
  |  |  |  | 1130|      2|    } while (FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1130:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1136|      2|    } while (FALSE)
  |  |  ------------------
  |  |  |  Branch (1136:14): [Folded, False: 2]
  |  |  ------------------
  ------------------
  |  Branch (1153:5): [True: 2, False: 22]
  ------------------
 1154|      2|    case CPLXSXP: MAKE_CLASS(class, altcomplex); break;
  ------------------
  |  |  125|      2|#define CPLXSXP	    15	  /* complex variables */
  ------------------
                  case CPLXSXP: MAKE_CLASS(class, altcomplex); break;
  ------------------
  |  | 1132|      2|#define MAKE_CLASS(var, type) do {				\
  |  | 1133|      2|	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  875|      2|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  |               	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  136|      2|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  | 1134|      2|	R_PreserveObject(var);					\
  |  | 1135|      2|	INIT_CLASS(var, type);					\
  |  |  ------------------
  |  |  |  | 1127|      2|#define INIT_CLASS(cls, type) do {				\
  |  |  |  | 1128|      2|	*((type##_methods_t *) (CLASS_METHODS_TABLE(cls))) =	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  |  |  |  |  ------------------
  |  |  |  | 1129|      2|	    type##_default_methods;				\
  |  |  |  | 1130|      2|    } while (FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1130:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1136|      2|    } while (FALSE)
  |  |  ------------------
  |  |  |  Branch (1136:14): [Folded, False: 2]
  |  |  ------------------
  ------------------
  |  Branch (1154:5): [True: 2, False: 22]
  ------------------
 1155|      4|    case STRSXP:  MAKE_CLASS(class, altstring);  break;
  ------------------
  |  |  126|      4|#define STRSXP	    16	  /* string vectors */
  ------------------
                  case STRSXP:  MAKE_CLASS(class, altstring);  break;
  ------------------
  |  | 1132|      4|#define MAKE_CLASS(var, type) do {				\
  |  | 1133|      4|	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  875|      4|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  |               	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  136|      4|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  | 1134|      4|	R_PreserveObject(var);					\
  |  | 1135|      4|	INIT_CLASS(var, type);					\
  |  |  ------------------
  |  |  |  | 1127|      4|#define INIT_CLASS(cls, type) do {				\
  |  |  |  | 1128|      4|	*((type##_methods_t *) (CLASS_METHODS_TABLE(cls))) =	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      4|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  |  |  |  |  ------------------
  |  |  |  | 1129|      4|	    type##_default_methods;				\
  |  |  |  | 1130|      4|    } while (FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1130:14): [Folded, False: 4]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1136|      4|    } while (FALSE)
  |  |  ------------------
  |  |  |  Branch (1136:14): [Folded, False: 4]
  |  |  ------------------
  ------------------
  |  Branch (1155:5): [True: 4, False: 20]
  ------------------
 1156|      2|    case VECSXP:  MAKE_CLASS(class, altlist);    break;
  ------------------
  |  |  131|      2|#define VECSXP	    19	  /* generic vectors */
  ------------------
                  case VECSXP:  MAKE_CLASS(class, altlist);    break;
  ------------------
  |  | 1132|      2|#define MAKE_CLASS(var, type) do {				\
  |  | 1133|      2|	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  875|      2|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  |               	var = allocVector(RAWSXP, sizeof(type##_methods_t));	\
  |  |  ------------------
  |  |  |  |  136|      2|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  | 1134|      2|	R_PreserveObject(var);					\
  |  | 1135|      2|	INIT_CLASS(var, type);					\
  |  |  ------------------
  |  |  |  | 1127|      2|#define INIT_CLASS(cls, type) do {				\
  |  |  |  | 1128|      2|	*((type##_methods_t *) (CLASS_METHODS_TABLE(cls))) =	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      2|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  |  |  |  |  ------------------
  |  |  |  | 1129|      2|	    type##_default_methods;				\
  |  |  |  | 1130|      2|    } while (FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1130:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1136|      2|    } while (FALSE)
  |  |  ------------------
  |  |  |  Branch (1136:14): [Folded, False: 2]
  |  |  ------------------
  ------------------
  |  Branch (1156:5): [True: 2, False: 22]
  ------------------
 1157|      0|    default: error("unsupported ALTREP class");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (1157:5): [True: 0, False: 24]
  ------------------
 1158|     24|    }
 1159|     24|    RegisterClass(class, type, cname, pname, dll);
 1160|     24|    return R_cast_altrep_class(class);
 1161|     24|}
altrep.c:altrep_UnserializeEX_default:
  791|      8|{
  792|      8|    altrep_methods_t *m = CLASS_METHODS_TABLE(class);
  ------------------
  |  |  125|      8|#define CLASS_METHODS_TABLE(class) STDVEC_DATAPTR(class)
  ------------------
  793|      8|    SEXP val = m->Unserialize(class, state);
  794|      8|    SET_ATTRIB(val, attr);
  795|      8|    SET_OBJECT(val, objf);
  796|      8|    SETLEVELS(val, levs);
  797|      8|    return val;
  798|      8|}
altrep.c:altvec_Extract_subset_default:
  861|     24|{
  862|       |    return NULL;
  863|     24|}
altrep.c:RegisterClass:
   64|     24|{
   65|     24|    PROTECT(class);
  ------------------
  |  |  357|     24|#define PROTECT(s)	Rf_protect(s)
  ------------------
   66|     24|    if (Registry == NULL) {
  ------------------
  |  Branch (66:9): [True: 2, False: 22]
  ------------------
   67|      2|	Registry = CONS(R_NilValue, R_NilValue);
  ------------------
  |  |  309|      2|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
   68|      2|	R_PreserveObject(Registry);
   69|      2|    }
   70|       |
   71|     24|    SEXP csym = install(cname);
  ------------------
  |  |  934|     24|#define install			Rf_install
  ------------------
   72|     24|    SEXP psym = install(pname);
  ------------------
  |  |  934|     24|#define install			Rf_install
  ------------------
   73|     24|    SEXP stype = PROTECT(ScalarInteger(type));
  ------------------
  |  |  357|     24|#define PROTECT(s)	Rf_protect(s)
  ------------------
   74|     24|    SEXP iptr = R_MakeExternalPtr(dll, R_NilValue, R_NilValue);
   75|     24|    SEXP entry = LookupClassEntry(csym, psym);
   76|     24|    if (entry == NULL) {
  ------------------
  |  Branch (76:9): [True: 24, False: 0]
  ------------------
   77|     24|	entry = list4(class, psym, stype, iptr);
  ------------------
  |  |  992|     24|#define list4			Rf_list4
  ------------------
   78|     24|	SET_TAG(entry, csym);
   79|     24|	SETCDR(Registry, CONS(entry, CDR(Registry)));
  ------------------
  |  |  309|     24|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
   80|     24|    }
   81|      0|    else {
   82|      0|	SETCAR(entry, class);
   83|      0|	SETCAR(CDR(CDR(entry)), stype);
   84|      0|	SETCAR(CDR(CDR(CDR(entry))), iptr);
   85|      0|    }
   86|     24|    SET_ALTREP_CLASS_SERIALIZED_CLASS(class, csym, psym, stype);
  ------------------
  |  |   39|     24|    SET_ATTRIB(x, list3(csym, psym, stype))
  |  |  ------------------
  |  |  |  |  991|     24|#define list3			Rf_list3
  |  |  ------------------
  ------------------
   87|     24|    UNPROTECT(2); /* class, stype */
  ------------------
  |  |  358|     24|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
   88|     24|}
altrep.c:R_cast_altrep_class:
 1139|     24|{
 1140|       |    /**** some king of optional check? */
 1141|     24|    R_altrep_class_t val = R_SUBTYPE_INIT(x);
  ------------------
  |  |   38|     24|# define R_SUBTYPE_INIT(x) { x }
  ------------------
 1142|     24|    return val;
 1143|     24|}
altrep.c:SET_ALTREP_CLASS:
  120|    247|{
  121|    247|    SETALTREP(x, 1);
  122|    247|    SET_TAG(x, class);
  123|    247|}

do_lapply:
   42|  1.32k|{
   43|  1.32k|    PROTECT_INDEX pidx, cidx;
   44|       |
   45|  1.32k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.32k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
   46|  1.32k|    SEXP X, XX, FUN;
   47|  1.32k|    X = checkArgIsSymbol(CAR(args));
   48|  1.32k|    XX = PROTECT(eval(CAR(args), rho));
  ------------------
  |  |  357|  1.32k|#define PROTECT(s)	Rf_protect(s)
  ------------------
   49|  1.32k|    R_xlen_t n = xlength(XX);  // a vector, so will be valid.
  ------------------
  |  | 1049|  1.32k|#define xlength(x)		Rf_xlength(x)
  ------------------
   50|  1.32k|    FUN = checkArgIsSymbol(CADR(args));
   51|  1.32k|    bool realIndx = n > INT_MAX;
   52|       |
   53|  1.32k|    SEXP ans = PROTECT(allocVector(VECSXP, n));
  ------------------
  |  |  357|  1.32k|#define PROTECT(s)	Rf_protect(s)
  ------------------
   54|  1.32k|    SEXP names = getAttrib(XX, R_NamesSymbol);
  ------------------
  |  |  924|  1.32k|#define getAttrib		Rf_getAttrib
  ------------------
   55|  1.32k|    if(!isNull(names)) setAttrib(ans, R_NamesSymbol, names);
  ------------------
  |  |  956|  1.32k|#define isNull			Rf_isNull
  ------------------
                  if(!isNull(names)) setAttrib(ans, R_NamesSymbol, names);
  ------------------
  |  | 1027|     34|#define setAttrib		Rf_setAttrib
  ------------------
  |  Branch (55:8): [True: 34, False: 1.29k]
  ------------------
   56|       |
   57|       |    /* Build call: FUN(X[[<ind>]], ...) */
   58|  1.32k|    SEXP isym = install("i");
  ------------------
  |  |  934|  1.32k|#define install			Rf_install
  ------------------
   59|  1.32k|    SEXP tmp = PROTECT(lang3(R_Bracket2Symbol, X, isym));
  ------------------
  |  |  357|  1.32k|#define PROTECT(s)	Rf_protect(s)
  ------------------
   60|  1.32k|    SEXP R_fcall = PROTECT(lang3(FUN, tmp, R_DotsSymbol));
  ------------------
  |  |  357|  1.32k|#define PROTECT(s)	Rf_protect(s)
  ------------------
   61|  1.32k|    MARK_NOT_MUTABLE(R_fcall);
   62|       |
   63|       |    /* Create the loop index variable and value */
   64|  1.32k|    SEXP ind = allocVector(realIndx ? REALSXP : INTSXP, 1);
  ------------------
  |  |  875|  1.32k|#define allocVector		Rf_allocVector
  ------------------
                  SEXP ind = allocVector(realIndx ? REALSXP : INTSXP, 1);
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
                  SEXP ind = allocVector(realIndx ? REALSXP : INTSXP, 1);
  ------------------
  |  |  123|  2.65k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (64:28): [True: 0, False: 1.32k]
  ------------------
   65|  1.32k|    PROTECT_WITH_INDEX(ind, &pidx);
  ------------------
  |  |  366|  1.32k|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
   66|  1.32k|    defineVar(isym, ind, rho);
  ------------------
  |  |  905|  1.32k|#define defineVar		Rf_defineVar
  ------------------
   67|  1.32k|    INCREMENT_NAMED(ind);
  ------------------
  |  |  222|  1.32k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 1.32k]
  |  |  ------------------
  ------------------
   68|  1.32k|    R_varloc_t loc = R_findVarLocInFrame(rho, isym);
   69|  1.32k|    PROTECT_WITH_INDEX(loc.cell, &cidx);
  ------------------
  |  |  366|  1.32k|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
   70|       |
   71|       |
   72|  2.44k|    for(R_xlen_t i = 0; i < n; i++) {
  ------------------
  |  Branch (72:25): [True: 1.11k, False: 1.32k]
  ------------------
   73|  1.11k|	if (realIndx) REAL(ind)[0] = (double)(i + 1);
  ------------------
  |  Branch (73:6): [True: 0, False: 1.11k]
  ------------------
   74|  1.11k|	else INTEGER(ind)[0] = (int)(i + 1);
   75|  1.11k|	tmp = R_forceAndCall(R_fcall, 1, rho);
   76|  1.11k|	if (MAYBE_REFERENCED(tmp)) tmp = lazy_duplicate(tmp);
  ------------------
  |  |  251|  1.11k|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 895, False: 220]
  |  |  ------------------
  ------------------
              	if (MAYBE_REFERENCED(tmp)) tmp = lazy_duplicate(tmp);
  ------------------
  |  |  985|    895|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
   77|  1.11k|	SET_VECTOR_ELT(ans, i, tmp);
   78|  1.11k|	if (ind != R_GetVarLocValue(loc) || MAYBE_SHARED(ind)) {
  ------------------
  |  Branch (78:6): [True: 0, False: 1.11k]
  |  Branch (78:38): [True: 0, False: 1.11k]
  ------------------
   79|       |	    /* ind has been captured or removed by FUN so fix it up */
   80|      0|	    REPROTECT(ind = duplicate(ind), pidx);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
   81|      0|	    defineVar(isym, ind, rho);
  ------------------
  |  |  905|      0|#define defineVar		Rf_defineVar
  ------------------
   82|      0|	    INCREMENT_NAMED(ind);
  ------------------
  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  ------------------
  ------------------
   83|      0|	    loc = R_findVarLocInFrame(rho, isym);
   84|      0|	    REPROTECT(loc.cell, cidx);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
   85|      0|	}
   86|  1.11k|    }
   87|       |
   88|  1.32k|    UNPROTECT(6);
  ------------------
  |  |  358|  1.32k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
   89|  1.32k|    return ans;
   90|  1.32k|}
do_vapply:
   96|     34|{
   97|     34|    SEXP R_fcall, ans, names = R_NilValue, rowNames = R_NilValue,
   98|     34|	X, XX, FUN, value, dim_v;
   99|     34|    R_xlen_t i, n;
  100|     34|    int commonLen;
  101|     34|    int useNames, rnk_v = -1; // = array_rank(value) := length(dim(value))
  102|     34|    bool array_value;
  103|     34|    SEXPTYPE commonType;
  104|     34|    PROTECT_INDEX index = 0; /* initialize to avoid a warning */
  105|       |
  106|     34|    checkArity(op, args);
  ------------------
  |  | 1788|     34|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  107|     34|    PROTECT(X = CAR(args));
  ------------------
  |  |  357|     34|#define PROTECT(s)	Rf_protect(s)
  ------------------
  108|     34|    PROTECT(XX = eval(CAR(args), rho));
  ------------------
  |  |  357|     34|#define PROTECT(s)	Rf_protect(s)
  ------------------
  109|     34|    FUN = CADR(args);  /* must be unevaluated for use in e.g. bquote */
  110|     34|    PROTECT(value = eval(CADDR(args), rho));
  ------------------
  |  |  357|     34|#define PROTECT(s)	Rf_protect(s)
  ------------------
  111|     34|    if (!isVector(value)) error(_("'FUN.VALUE' must be a vector"));
  ------------------
  |  |  974|     34|#define isVector		Rf_isVector
  ------------------
                  if (!isVector(value)) error(_("'FUN.VALUE' must be a vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (!isVector(value)) error(_("'FUN.VALUE' must be a vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (111:9): [True: 0, False: 34]
  ------------------
  112|     34|    useNames = asLogical(PROTECT(eval(CADDDR(args), rho)));
  ------------------
  |  |  886|     34|#define asLogical		Rf_asLogical
  ------------------
                  useNames = asLogical(PROTECT(eval(CADDDR(args), rho)));
  ------------------
  |  |  357|     34|#define PROTECT(s)	Rf_protect(s)
  ------------------
  113|     34|    UNPROTECT(1);
  ------------------
  |  |  358|     34|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  114|       |    // FIXME: does not protect against length > 1
  115|     34|    if (useNames == NA_LOGICAL) error(_("invalid '%s' value"), "USE.NAMES");
  ------------------
  |  |   55|     34|#define NA_LOGICAL	R_NaInt
  ------------------
                  if (useNames == NA_LOGICAL) error(_("invalid '%s' value"), "USE.NAMES");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (useNames == NA_LOGICAL) error(_("invalid '%s' value"), "USE.NAMES");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (115:9): [True: 0, False: 34]
  ------------------
  116|       |
  117|     34|    n = xlength(XX);
  ------------------
  |  | 1049|     34|#define xlength(x)		Rf_xlength(x)
  ------------------
  118|     34|    if (n == NA_INTEGER) error(_("invalid length"));
  ------------------
  |  |   56|     34|#define NA_INTEGER	R_NaInt
  ------------------
                  if (n == NA_INTEGER) error(_("invalid length"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (n == NA_INTEGER) error(_("invalid length"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (118:9): [True: 0, False: 34]
  ------------------
  119|     34|    bool realIndx = n > INT_MAX;
  120|       |
  121|     34|    commonLen = length(value);
  ------------------
  |  |  987|     34|#define length(x)		Rf_length(x)
  ------------------
  122|     34|    if (commonLen > 1 && n > INT_MAX)
  ------------------
  |  Branch (122:9): [True: 0, False: 34]
  |  Branch (122:26): [True: 0, False: 0]
  ------------------
  123|      0|	error(_("long vectors are not supported for matrix/array results"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("long vectors are not supported for matrix/array results"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  124|     34|    commonType = TYPEOF(value);
  125|       |    // check once here
  126|     34|    if (commonType != CPLXSXP && commonType != REALSXP &&
  ------------------
  |  |  125|     68|#define CPLXSXP	    15	  /* complex variables */
  ------------------
                  if (commonType != CPLXSXP && commonType != REALSXP &&
  ------------------
  |  |  124|     68|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (126:9): [True: 34, False: 0]
  |  Branch (126:34): [True: 34, False: 0]
  ------------------
  127|     34|	commonType != INTSXP  && commonType != LGLSXP &&
  ------------------
  |  |  123|     68|#define INTSXP	    13	  /* integer vectors */
  ------------------
              	commonType != INTSXP  && commonType != LGLSXP &&
  ------------------
  |  |  121|     68|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (127:2): [True: 34, False: 0]
  |  Branch (127:27): [True: 4, False: 30]
  ------------------
  128|      4|	commonType != RAWSXP  && commonType != STRSXP &&
  ------------------
  |  |  136|     38|#define RAWSXP      24    /* raw bytes */
  ------------------
              	commonType != RAWSXP  && commonType != STRSXP &&
  ------------------
  |  |  126|     38|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (128:2): [True: 4, False: 0]
  |  Branch (128:27): [True: 0, False: 4]
  ------------------
  129|      0|	commonType != VECSXP)
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (129:2): [True: 0, False: 0]
  ------------------
  130|      0|	error(_("type '%s' is not supported"), R_typeToChar(value));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("type '%s' is not supported"), R_typeToChar(value));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  131|     34|    dim_v = getAttrib(value, R_DimSymbol);
  ------------------
  |  |  924|     34|#define getAttrib		Rf_getAttrib
  ------------------
  132|     34|    array_value = (TYPEOF(dim_v) == INTSXP && LENGTH(dim_v) >= 1);
  ------------------
  |  |  123|     68|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (132:20): [True: 0, False: 34]
  |  Branch (132:47): [True: 0, False: 0]
  ------------------
  133|     34|    PROTECT(ans = allocVector(commonType, n*commonLen));
  ------------------
  |  |  357|     34|#define PROTECT(s)	Rf_protect(s)
  ------------------
  134|     34|    if (useNames) {
  ------------------
  |  Branch (134:9): [True: 34, False: 0]
  ------------------
  135|     34|	PROTECT(names = getAttrib(XX, R_NamesSymbol));
  ------------------
  |  |  357|     34|#define PROTECT(s)	Rf_protect(s)
  ------------------
  136|     34|	if (isNull(names) && TYPEOF(XX) == STRSXP) {
  ------------------
  |  |  956|     34|#define isNull			Rf_isNull
  ------------------
              	if (isNull(names) && TYPEOF(XX) == STRSXP) {
  ------------------
  |  |  126|     18|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (136:6): [True: 18, False: 16]
  |  Branch (136:23): [True: 0, False: 18]
  ------------------
  137|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  138|      0|	    PROTECT(names = XX);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  139|      0|	}
  140|     34|	PROTECT_WITH_INDEX(rowNames = getAttrib(value,
  ------------------
  |  |  366|     68|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  |  |  ------------------
  |  |  |  Branch (366:52): [True: 0, False: 34]
  |  |  ------------------
  ------------------
  141|     34|						array_value ? R_DimNamesSymbol
  142|     34|						: R_NamesSymbol),
  143|     34|			   &index);
  144|     34|    }
  145|       |    /* The R level code has ensured that XX is a vector.
  146|       |       If it is atomic we can speed things up slightly by
  147|       |       using the evaluated version.
  148|       |    */
  149|     34|    {
  150|     34|	SEXP ind, tmp;
  151|       |	/* Build call: FUN(XX[[<ind>]], ...) */
  152|       |
  153|     34|	SEXP isym = install("i");
  ------------------
  |  |  934|     34|#define install			Rf_install
  ------------------
  154|     34|	PROTECT(ind = allocVector(realIndx ? REALSXP : INTSXP, 1));
  ------------------
  |  |  357|     68|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  |  Branch (357:31): [True: 0, False: 34]
  |  |  ------------------
  ------------------
  155|     34|	defineVar(isym, ind, rho);
  ------------------
  |  |  905|     34|#define defineVar		Rf_defineVar
  ------------------
  156|     34|	INCREMENT_NAMED(ind);
  ------------------
  |  |  222|     34|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 34]
  |  |  ------------------
  ------------------
  157|       |
  158|       |	/* Notice that it is OK to have one arg to LCONS do memory
  159|       |	   allocation and not PROTECT the result (LCONS does memory
  160|       |	   protection of its args internally), but not both of them,
  161|       |	   since the computation of one may destroy the other */
  162|     34|	PROTECT(tmp = LCONS(R_Bracket2Symbol,
  ------------------
  |  |  357|     34|#define PROTECT(s)	Rf_protect(s)
  ------------------
  163|     34|			    LCONS(X, LCONS(isym, R_NilValue))));
  164|     34|	PROTECT(R_fcall = LCONS(FUN,
  ------------------
  |  |  357|     34|#define PROTECT(s)	Rf_protect(s)
  ------------------
  165|     34|				LCONS(tmp, LCONS(R_DotsSymbol, R_NilValue))));
  166|       |
  167|     34|	int common_len_offset = 0;
  168|     96|	for(i = 0; i < n; i++) {
  ------------------
  |  Branch (168:13): [True: 62, False: 34]
  ------------------
  169|     62|	    SEXP val; SEXPTYPE valType;
  170|     62|	    PROTECT_INDEX indx;
  171|     62|	    if (realIndx) REAL(ind)[0] = (double)(i + 1);
  ------------------
  |  Branch (171:10): [True: 0, False: 62]
  ------------------
  172|     62|	    else INTEGER(ind)[0] = (int)(i + 1);
  173|     62|	    val = R_forceAndCall(R_fcall, 1, rho);
  174|     62|	    if (MAYBE_REFERENCED(val))
  ------------------
  |  |  251|     62|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 26, False: 36]
  |  |  ------------------
  ------------------
  175|     26|		val = lazy_duplicate(val); // Need to duplicate? Copying again anyway
  ------------------
  |  |  985|     26|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
  176|     62|	    PROTECT_WITH_INDEX(val, &indx);
  ------------------
  |  |  366|     62|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
  177|     62|	    if (length(val) != commonLen)
  ------------------
  |  |  987|     62|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (177:10): [True: 0, False: 62]
  ------------------
  178|      0|		error(_("values must be length %d,\n but FUN(X[[%lld]]) result is length %d"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("values must be length %d,\n but FUN(X[[%lld]]) result is length %d"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  179|      0|		       commonLen, (long long)i+1, length(val));
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  180|     62|	    valType = TYPEOF(val);
  181|     62|	    if (valType != commonType) {
  ------------------
  |  Branch (181:10): [True: 0, False: 62]
  ------------------
  182|      0|		bool okay = false;
  183|      0|		switch (commonType) {
  ------------------
  |  Branch (183:11): [True: 0, False: 0]
  ------------------
  184|      0|		case CPLXSXP: okay = (valType == REALSXP) || (valType == INTSXP)
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
              		case CPLXSXP: okay = (valType == REALSXP) || (valType == INTSXP)
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
              		case CPLXSXP: okay = (valType == REALSXP) || (valType == INTSXP)
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (184:3): [True: 0, False: 0]
  |  Branch (184:24): [True: 0, False: 0]
  |  Branch (184:48): [True: 0, False: 0]
  ------------------
  185|      0|				    || (valType == LGLSXP); break;
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (185:12): [True: 0, False: 0]
  ------------------
  186|      0|		case REALSXP: okay = (valType == INTSXP) || (valType == LGLSXP); break;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
              		case REALSXP: okay = (valType == INTSXP) || (valType == LGLSXP); break;
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
              		case REALSXP: okay = (valType == INTSXP) || (valType == LGLSXP); break;
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (186:3): [True: 0, False: 0]
  |  Branch (186:24): [True: 0, False: 0]
  |  Branch (186:47): [True: 0, False: 0]
  ------------------
  187|      0|		case INTSXP:  okay = (valType == LGLSXP); break;
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
              		case INTSXP:  okay = (valType == LGLSXP); break;
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (187:3): [True: 0, False: 0]
  ------------------
  188|      0|		}
  189|      0|		if (!okay)
  ------------------
  |  Branch (189:7): [True: 0, False: 0]
  ------------------
  190|      0|		    error(_("values must be type '%s',\n but FUN(X[[%lld]]) result is type '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("values must be type '%s',\n but FUN(X[[%lld]]) result is type '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  191|      0|			  R_typeToChar(value), (long long)i+1, R_typeToChar(val));
  192|      0|		REPROTECT(val = coerceVector(val, commonType), indx);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  193|      0|	    }
  194|       |	    /* Take row names from the first result only */
  195|     62|	    if (i == 0 && useNames && isNull(rowNames))
  ------------------
  |  |  956|     22|#define isNull			Rf_isNull
  ------------------
  |  Branch (195:10): [True: 22, False: 40]
  |  Branch (195:20): [True: 22, False: 0]
  |  Branch (195:32): [True: 22, False: 0]
  ------------------
  196|     22|		REPROTECT(rowNames = getAttrib(val,
  ------------------
  |  |  367|     44|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  |  |  Branch (367:36): [True: 0, False: 22]
  |  |  ------------------
  ------------------
  197|     62|					       array_value ? R_DimNamesSymbol : R_NamesSymbol),
  198|     62|			  index);
  199|       |	    // two cases - only for efficiency
  200|     62|	    if(commonLen == 1) { // common case
  ------------------
  |  Branch (200:9): [True: 62, False: 0]
  ------------------
  201|     62|		switch (commonType) {
  ------------------
  |  Branch (201:11): [True: 62, False: 0]
  ------------------
  202|      0|		case CPLXSXP: COMPLEX(ans)[i] = COMPLEX(val)[0]; break;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (202:3): [True: 0, False: 62]
  ------------------
  203|      0|		case REALSXP: REAL(ans)   [i] = REAL   (val)[0]; break;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (203:3): [True: 0, False: 62]
  ------------------
  204|      0|		case INTSXP:  INTEGER(ans)[i] = INTEGER(val)[0]; break;
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (204:3): [True: 0, False: 62]
  ------------------
  205|     42|		case LGLSXP:  LOGICAL(ans)[i] = LOGICAL(val)[0]; break;
  ------------------
  |  |  121|     42|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (205:3): [True: 42, False: 20]
  ------------------
  206|      0|		case RAWSXP:  RAW(ans)    [i] = RAW    (val)[0]; break;
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (206:3): [True: 0, False: 62]
  ------------------
  207|     20|		case STRSXP:  SET_STRING_ELT(ans, i, STRING_ELT(val, 0)); break;
  ------------------
  |  |  126|     20|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (207:3): [True: 20, False: 42]
  ------------------
  208|      0|		case VECSXP:  SET_VECTOR_ELT(ans, i, VECTOR_ELT(val, 0)); break;
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (208:3): [True: 0, False: 62]
  ------------------
  209|     62|		}
  210|     62|	    } else if (commonLen) { // commonLen > 1
  ------------------
  |  Branch (210:17): [True: 0, False: 0]
  ------------------
  211|      0|		switch (commonType) {
  ------------------
  |  Branch (211:11): [True: 0, False: 0]
  ------------------
  212|      0|		case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (212:3): [True: 0, False: 0]
  ------------------
  213|      0|		    memcpy(REAL(ans) + common_len_offset,
  214|      0|			   REAL(val), commonLen * sizeof(double)); break;
  215|      0|		case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (215:3): [True: 0, False: 0]
  ------------------
  216|      0|		    memcpy(INTEGER(ans) + common_len_offset,
  217|      0|			   INTEGER(val), commonLen * sizeof(int)); break;
  218|      0|		case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (218:3): [True: 0, False: 0]
  ------------------
  219|      0|		    memcpy(LOGICAL(ans) + common_len_offset,
  220|      0|			   LOGICAL(val), commonLen * sizeof(int)); break;
  221|      0|		case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (221:3): [True: 0, False: 0]
  ------------------
  222|      0|		    memcpy(RAW(ans) + common_len_offset,
  223|      0|			   RAW(val), commonLen * sizeof(Rbyte)); break;
  224|      0|		case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (224:3): [True: 0, False: 0]
  ------------------
  225|      0|		    memcpy(COMPLEX(ans) + common_len_offset,
  226|      0|			   COMPLEX(val), commonLen * sizeof(Rcomplex)); break;
  227|      0|		case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (227:3): [True: 0, False: 0]
  ------------------
  228|      0|		    for (int j = 0; j < commonLen; j++)
  ------------------
  |  Branch (228:23): [True: 0, False: 0]
  ------------------
  229|      0|			SET_STRING_ELT(ans, common_len_offset + j, STRING_ELT(val, j));
  230|      0|		    break;
  231|      0|		case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (231:3): [True: 0, False: 0]
  ------------------
  232|      0|		    for (int j = 0; j < commonLen; j++)
  ------------------
  |  Branch (232:23): [True: 0, False: 0]
  ------------------
  233|      0|			SET_VECTOR_ELT(ans, common_len_offset + j, VECTOR_ELT(val, j));
  234|      0|		    break;
  235|      0|		}
  236|      0|		common_len_offset += commonLen;
  237|      0|	    }
  238|     62|	    UNPROTECT(1);
  ------------------
  |  |  358|     62|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  239|     62|	}
  240|     34|	UNPROTECT(3);
  ------------------
  |  |  358|     34|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  241|     34|    }
  242|       |
  243|     34|    if (commonLen != 1) {
  ------------------
  |  Branch (243:9): [True: 0, False: 34]
  ------------------
  244|      0|	SEXP dim;
  245|      0|	rnk_v = array_value ? LENGTH(dim_v) : 1;
  ------------------
  |  Branch (245:10): [True: 0, False: 0]
  ------------------
  246|      0|	PROTECT(dim = allocVector(INTSXP, rnk_v+1));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  247|      0|	if(array_value)
  ------------------
  |  Branch (247:5): [True: 0, False: 0]
  ------------------
  248|      0|	    for(int j = 0; j < rnk_v; j++)
  ------------------
  |  Branch (248:21): [True: 0, False: 0]
  ------------------
  249|      0|		INTEGER(dim)[j] = INTEGER(dim_v)[j];
  250|      0|	else
  251|      0|	    INTEGER(dim)[0] = commonLen;
  252|      0|	INTEGER(dim)[rnk_v] = (int) n;  // checked above
  253|      0|	setAttrib(ans, R_DimSymbol, dim);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  254|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  255|      0|    }
  256|       |
  257|     34|    if (useNames) {
  ------------------
  |  Branch (257:9): [True: 34, False: 0]
  ------------------
  258|     34|	if (commonLen == 1) {
  ------------------
  |  Branch (258:6): [True: 34, False: 0]
  ------------------
  259|     34|	    if(!isNull(names)) setAttrib(ans, R_NamesSymbol, names);
  ------------------
  |  |  956|     34|#define isNull			Rf_isNull
  ------------------
              	    if(!isNull(names)) setAttrib(ans, R_NamesSymbol, names);
  ------------------
  |  | 1027|     16|#define setAttrib		Rf_setAttrib
  ------------------
  |  Branch (259:9): [True: 16, False: 18]
  ------------------
  260|     34|	} else {
  261|      0|	    if (!isNull(names) || !isNull(rowNames)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
              	    if (!isNull(names) || !isNull(rowNames)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (261:10): [True: 0, False: 0]
  |  Branch (261:28): [True: 0, False: 0]
  ------------------
  262|      0|		SEXP dimnames;
  263|      0|		PROTECT(dimnames = allocVector(VECSXP, rnk_v+1));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  264|      0|		if(array_value && !isNull(rowNames)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (264:6): [True: 0, False: 0]
  |  Branch (264:21): [True: 0, False: 0]
  ------------------
  265|      0|		    if(TYPEOF(rowNames) != VECSXP || LENGTH(rowNames) != rnk_v)
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (265:10): [True: 0, False: 0]
  |  Branch (265:40): [True: 0, False: 0]
  ------------------
  266|       |			// should never happen ..
  267|      0|			error(_("dimnames(<value>) is neither NULL nor list of length %d"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              			error(_("dimnames(<value>) is neither NULL nor list of length %d"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  268|      0|			      rnk_v);
  269|      0|		    for(int j = 0; j < rnk_v; j++)
  ------------------
  |  Branch (269:22): [True: 0, False: 0]
  ------------------
  270|      0|			SET_VECTOR_ELT(dimnames, j, VECTOR_ELT(rowNames, j));
  271|      0|		} else
  272|      0|		    SET_VECTOR_ELT(dimnames, 0, rowNames);
  273|       |
  274|      0|		SET_VECTOR_ELT(dimnames, rnk_v, names);
  275|      0|		setAttrib(ans, R_DimNamesSymbol, dimnames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  276|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  277|      0|	    }
  278|      0|	}
  279|     34|	UNPROTECT(2); /* names and rowNames */
  ------------------
  |  |  358|     34|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  280|     34|    }
  281|     34|    UNPROTECT(4); /* X, XX, value, ans */
  ------------------
  |  |  358|     34|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  282|     34|    return ans;
  283|     34|}
do_islistfactor:
  399|     75|{
  400|     75|    checkArity(op, args);
  ------------------
  |  | 1788|     75|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  401|     75|    SEXP X = CAR(args);
  402|     75|    bool recursive = asBool2(CADR(args), call);
  ------------------
  |  | 1860|     75|# define asBool2	       	Rf_asBool2
  ------------------
  403|     75|    int n = length(X);
  ------------------
  |  |  987|     75|#define length(x)		Rf_length(x)
  ------------------
  404|     75|    if(n == 0 || !isVectorList(X))
  ------------------
  |  |  977|     73|#define isVectorList		Rf_isVectorList
  ------------------
  |  Branch (404:8): [True: 2, False: 73]
  |  Branch (404:18): [True: 0, False: 73]
  ------------------
  405|      2|	return ScalarLogical(false);
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  406|       |
  407|     73|    if(!recursive) {
  ------------------
  |  Branch (407:8): [True: 26, False: 47]
  ------------------
  408|     26|	for(int i = 0; i < n; i++)
  ------------------
  |  Branch (408:17): [True: 26, False: 0]
  ------------------
  409|     26|	    if(!isFactor(VECTOR_ELT(X, i)))
  ------------------
  |  |  946|     26|#define isFactor		Rf_isFactor
  ------------------
  |  Branch (409:9): [True: 26, False: 0]
  ------------------
  410|     26|		return ScalarLogical(false);
  ------------------
  |  | 1023|     26|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  411|       |
  412|      0|	return ScalarLogical(true);
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  413|     26|    }
  414|     47|    else { // recursive:  isVectorList(X) <==> X is VECSXP or EXPRSXP
  415|     47|	return ScalarLogical((islistfactor(X) == true) ? true : false);
  ------------------
  |  | 1023|     47|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  |  Branch (415:23): [True: 0, False: 47]
  ------------------
  416|     47|    }
  417|     73|}
apply.c:checkArgIsSymbol:
   27|  2.65k|static SEXP checkArgIsSymbol(SEXP x) {
   28|  2.65k|    if (TYPEOF(x) != SYMSXP)
  ------------------
  |  |  112|  2.65k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (28:9): [True: 0, False: 2.65k]
  ------------------
   29|      0|	error("argument must be a symbol");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
   30|  2.65k|    return x;
   31|  2.65k|}
apply.c:islistfactor:
  375|     94|{
  376|     94|    switch(TYPEOF(X)) {
  377|     47|    case VECSXP:
  ------------------
  |  |  131|     47|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (377:5): [True: 47, False: 47]
  ------------------
  378|     47|    case EXPRSXP: {
  ------------------
  |  |  132|     47|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (378:5): [True: 0, False: 94]
  ------------------
  379|     47|	int n = LENGTH(X), ans = NA_LOGICAL;
  ------------------
  |  |   55|     47|#define NA_LOGICAL	R_NaInt
  ------------------
  380|     47|	for(int i = 0; i < n; i++) {
  ------------------
  |  Branch (380:17): [True: 47, False: 0]
  ------------------
  381|     47|	    int isLF = islistfactor(VECTOR_ELT(X, i));
  382|     47|	    if(!isLF)
  ------------------
  |  Branch (382:9): [True: 47, False: 0]
  ------------------
  383|     47|		return false;
  384|      0|	    else if(isLF == true)
  ------------------
  |  Branch (384:14): [True: 0, False: 0]
  ------------------
  385|      0|		ans = true;
  386|       |	    // else isLF is NA
  387|     47|	}
  388|      0|	return ans;
  389|     47|    }
  390|     47|    default:
  ------------------
  |  Branch (390:5): [True: 47, False: 47]
  ------------------
  391|     47|	return isFactor(X);
  ------------------
  |  |  946|     47|#define isFactor		Rf_isFactor
  ------------------
  392|     94|    }
  393|     94|}

R_IsNA:
  110|  3.82k|{
  111|  3.82k|    return isnan(x) && R_NaN_is_R_NA(x);
  ------------------
  |  Branch (111:12): [True: 0, False: 3.82k]
  |  Branch (111:24): [True: 0, False: 0]
  ------------------
  112|  3.82k|}
Rf_InitArithmetic:
  143|      2|{
  144|      2|    R_NaInt = INT_MIN;
  145|      2|    R_NaReal = R_ValueOfNA();
  146|       |// we assume C99, so
  147|      2|#ifndef OLD
  148|      2|    R_NaN = NAN;
  149|      2|    R_PosInf = INFINITY;
  150|      2|    R_NegInf = -INFINITY;
  151|       |#else
  152|       |    R_NaN = 0.0/R_Zero_Hack;
  153|       |    R_PosInf = 1.0/R_Zero_Hack;
  154|       |    R_NegInf = -1.0/R_Zero_Hack;
  155|       |#endif
  156|      2|}
R_pow:
  206|    192|{
  207|       |    /* squaring is the most common of the specially handled cases so
  208|       |       check for it first. */
  209|    192|    if(y == 2.)
  ------------------
  |  Branch (209:8): [True: 0, False: 192]
  ------------------
  210|      0|	return x * x;
  211|    192|    if(x == 1. || y == 0.)
  ------------------
  |  Branch (211:8): [True: 0, False: 192]
  |  Branch (211:19): [True: 64, False: 128]
  ------------------
  212|     64|	return(1.);
  213|    128|    if(x == 0.) {
  ------------------
  |  Branch (213:8): [True: 0, False: 128]
  ------------------
  214|      0|	if(y > 0.) return(0.);
  ------------------
  |  Branch (214:5): [True: 0, False: 0]
  ------------------
  215|      0|	else if(y < 0) return(R_PosInf);
  ------------------
  |  Branch (215:10): [True: 0, False: 0]
  ------------------
  216|      0|	else return(y); /* NA or NaN, we assert */
  217|      0|    }
  218|    128|    if (x >= -11. && x <= 11.) {
  ------------------
  |  Branch (218:9): [True: 128, False: 0]
  |  Branch (218:22): [True: 128, False: 0]
  ------------------
  219|    128|	if(y == 4.)
  ------------------
  |  Branch (219:5): [True: 0, False: 128]
  ------------------
  220|      0|	    return x * x * x * x;
  221|    128|	if(y == 3.)
  ------------------
  |  Branch (221:5): [True: 0, False: 128]
  ------------------
  222|      0|	    return x * x * x;
  223|    128|    }
  224|    128|    if (R_FINITE(x) && R_FINITE(y)) {
  ------------------
  |  |   82|    128|# define R_FINITE(x)    isfinite(x)
  ------------------
                  if (R_FINITE(x) && R_FINITE(y)) {
  ------------------
  |  |   82|    128|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (224:9): [True: 128, False: 0]
  |  Branch (224:24): [True: 128, False: 0]
  ------------------
  225|       |	/* There was a special case for y == 0.5 here, but
  226|       |	   gcc 4.3.0 -g -O2 mis-compiled it.  Showed up with
  227|       |	   100^0.5 as 3.162278, example(pbirthday) failed. */
  228|       |#ifdef USE_POWL_IN_R_POW
  229|       |	// this is used only on 64-bit Windows (so has powl).
  230|       |	return powl(x, y);
  231|       |#else
  232|    128|	return pow(x, y);
  233|    128|#endif
  234|    128|    }
  235|      0|    if (ISNAN(x) || ISNAN(y))
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  if (ISNAN(x) || ISNAN(y))
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  236|      0|	return(x + y);
  237|      0|    if(!R_FINITE(x)) {
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (237:8): [True: 0, False: 0]
  ------------------
  238|      0|	if(x > 0)		/* Inf ^ y */
  ------------------
  |  Branch (238:5): [True: 0, False: 0]
  ------------------
  239|      0|	    return (y < 0.)? 0. : R_PosInf;
  ------------------
  |  Branch (239:13): [True: 0, False: 0]
  ------------------
  240|      0|	else {			/* (-Inf) ^ y */
  241|      0|	    if(R_FINITE(y) && y == floor(y)) /* (-Inf) ^ n */
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (241:9): [True: 0, False: 0]
  |  Branch (241:24): [True: 0, False: 0]
  ------------------
  242|      0|		return (y < 0.) ? 0. : (myfmod(y, 2.) != 0 ? x  : -x);
  ------------------
  |  Branch (242:10): [True: 0, False: 0]
  |  Branch (242:27): [True: 0, False: 0]
  ------------------
  243|      0|	}
  244|      0|    }
  245|      0|    if(!R_FINITE(y)) {
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (245:8): [True: 0, False: 0]
  ------------------
  246|      0|	if(x >= 0) {
  ------------------
  |  Branch (246:5): [True: 0, False: 0]
  ------------------
  247|      0|	    if(y > 0)		/* y == +Inf */
  ------------------
  |  Branch (247:9): [True: 0, False: 0]
  ------------------
  248|      0|		return (x >= 1) ? R_PosInf : 0.;
  ------------------
  |  Branch (248:10): [True: 0, False: 0]
  ------------------
  249|      0|	    else		/* y == -Inf */
  250|      0|		return (x < 1) ? R_PosInf : 0.;
  ------------------
  |  Branch (250:10): [True: 0, False: 0]
  ------------------
  251|      0|	}
  252|      0|    }
  253|      0|    return R_NaN; // all other cases: (-Inf)^{+-Inf, non-int}; (neg)^{+-Inf}
  254|      0|}
do_arith:
  398|  2.12k|{
  399|  2.12k|    int argc;
  400|  2.12k|    if (args == R_NilValue)
  ------------------
  |  Branch (400:9): [True: 0, False: 2.12k]
  ------------------
  401|      0|	argc = 0;
  402|  2.12k|    else if (CDR(args) == R_NilValue)
  ------------------
  |  Branch (402:14): [True: 116, False: 2.00k]
  ------------------
  403|    116|	argc = 1;
  404|  2.00k|    else if (CDDR(args) == R_NilValue)
  ------------------
  |  Branch (404:14): [True: 2.00k, False: 0]
  ------------------
  405|  2.00k|	argc = 2;
  406|      0|    else
  407|      0|	argc = length(args);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  408|       |
  409|  2.12k|    SEXP ans,
  410|  2.12k|	arg1 = CAR(args),
  411|  2.12k|	arg2 = CADR(args);
  412|  2.12k|    if (ATTRIB(arg1) != R_NilValue || ATTRIB(arg2) != R_NilValue) {
  ------------------
  |  Branch (412:9): [True: 0, False: 2.12k]
  |  Branch (412:39): [True: 0, False: 2.12k]
  ------------------
  413|      0|	if (DispatchGroup("Ops", call, op, args, env, &ans))
  ------------------
  |  | 1886|      0|# define DispatchGroup		Rf_DispatchGroup
  ------------------
  |  Branch (413:6): [True: 0, False: 0]
  ------------------
  414|      0|	    return ans;
  415|      0|    }
  416|  2.12k|    else if (argc == 2) {
  ------------------
  |  Branch (416:14): [True: 2.00k, False: 116]
  ------------------
  417|       |	/* Handle some scaler operations immediately */
  418|  2.00k|	if (IS_SCALAR(arg1, REALSXP)) {
  ------------------
  |  |  124|  2.00k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (418:6): [True: 43, False: 1.96k]
  ------------------
  419|     43|	    double x1 = SCALAR_DVAL(arg1);
  420|     43|	    if (IS_SCALAR(arg2, REALSXP)) {
  ------------------
  |  |  124|     43|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (420:10): [True: 43, False: 0]
  ------------------
  421|     43|		double x2 = SCALAR_DVAL(arg2);
  422|     43|		ans = ScalarValue2(arg1, arg2);
  423|     43|		switch (PRIMVAL(op)) {
  ------------------
  |  | 1347|     43|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (1347:20): [True: 0, False: 43]
  |  |  ------------------
  ------------------
  424|      0|		case PLUSOP: SET_SCALAR_DVAL(ans, x1 + x2); return ans;
  ------------------
  |  Branch (424:3): [True: 0, False: 43]
  ------------------
  425|      0|		case MINUSOP: SET_SCALAR_DVAL(ans, x1 - x2); return ans;
  ------------------
  |  Branch (425:3): [True: 0, False: 43]
  ------------------
  426|      0|		case TIMESOP: SET_SCALAR_DVAL(ans, x1 * x2); return ans;
  ------------------
  |  Branch (426:3): [True: 0, False: 43]
  ------------------
  427|      0|		case DIVOP: SET_SCALAR_DVAL(ans, x1 / x2); return ans;
  ------------------
  |  Branch (427:3): [True: 0, False: 43]
  ------------------
  428|     43|		}
  429|     43|	    }
  430|      0|	    else if (IS_SCALAR(arg2, INTSXP)) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (430:15): [True: 0, False: 0]
  ------------------
  431|      0|		int i2 = SCALAR_IVAL(arg2);
  432|      0|		double x2 = i2 != NA_INTEGER ? (double) i2 : NA_REAL;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
              		double x2 = i2 != NA_INTEGER ? (double) i2 : NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  |  Branch (432:15): [True: 0, False: 0]
  ------------------
  433|      0|		ans = ScalarValue1(arg1);
  434|      0|		switch (PRIMVAL(op)) {
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (1347:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  435|      0|		case PLUSOP: SET_SCALAR_DVAL(ans, x1 + x2); return ans;
  ------------------
  |  Branch (435:3): [True: 0, False: 0]
  ------------------
  436|      0|		case MINUSOP: SET_SCALAR_DVAL(ans, x1 - x2); return ans;
  ------------------
  |  Branch (436:3): [True: 0, False: 0]
  ------------------
  437|      0|		case TIMESOP: SET_SCALAR_DVAL(ans, x1 * x2); return ans;
  ------------------
  |  Branch (437:3): [True: 0, False: 0]
  ------------------
  438|      0|		case DIVOP: SET_SCALAR_DVAL(ans, x1 / x2); return ans;
  ------------------
  |  Branch (438:3): [True: 0, False: 0]
  ------------------
  439|      0|		}
  440|      0|	    }
  441|     43|	}
  442|  1.96k|	else if (IS_SCALAR(arg1, INTSXP)) {
  ------------------
  |  |  123|  1.96k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (442:11): [True: 1.00k, False: 960]
  ------------------
  443|  1.00k|	    int i1 = SCALAR_IVAL(arg1);
  444|  1.00k|	    if (IS_SCALAR(arg2, REALSXP)) {
  ------------------
  |  |  124|  1.00k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (444:10): [True: 0, False: 1.00k]
  ------------------
  445|      0|		double x1 = i1 != NA_INTEGER ? (double) i1 : NA_REAL;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
              		double x1 = i1 != NA_INTEGER ? (double) i1 : NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  |  Branch (445:15): [True: 0, False: 0]
  ------------------
  446|      0|		double x2 = SCALAR_DVAL(arg2);
  447|      0|		ans = ScalarValue1(arg2);
  448|      0|		switch (PRIMVAL(op)) {
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (1347:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  449|      0|		case PLUSOP: SET_SCALAR_DVAL(ans, x1 + x2); return ans;
  ------------------
  |  Branch (449:3): [True: 0, False: 0]
  ------------------
  450|      0|		case MINUSOP: SET_SCALAR_DVAL(ans, x1 - x2); return ans;
  ------------------
  |  Branch (450:3): [True: 0, False: 0]
  ------------------
  451|      0|		case TIMESOP: SET_SCALAR_DVAL(ans, x1 * x2); return ans;
  ------------------
  |  Branch (451:3): [True: 0, False: 0]
  ------------------
  452|      0|		case DIVOP: SET_SCALAR_DVAL(ans, x1 / x2); return ans;
  ------------------
  |  Branch (452:3): [True: 0, False: 0]
  ------------------
  453|      0|		}
  454|      0|	    }
  455|  1.00k|	    else if (IS_SCALAR(arg2, INTSXP)) {
  ------------------
  |  |  123|  1.00k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (455:15): [True: 1.00k, False: 0]
  ------------------
  456|  1.00k|		bool naflag = false;
  457|  1.00k|		int i2 = SCALAR_IVAL(arg2);
  458|  1.00k|		switch (PRIMVAL(op)) {
  ------------------
  |  | 1347|  1.00k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (1347:20): [True: 2, False: 1.00k]
  |  |  ------------------
  ------------------
  459|      0|		case PLUSOP:
  ------------------
  |  Branch (459:3): [True: 0, False: 1.00k]
  ------------------
  460|      0|		    ans = ScalarValue2(arg1, arg2);
  461|      0|		    SET_SCALAR_IVAL(ans, R_integer_plus(i1, i2, &naflag));
  462|      0|		    CHECK_INTEGER_OVERFLOW(call, ans, naflag);
  ------------------
  |  |  312|      0|#define CHECK_INTEGER_OVERFLOW(call, ans, naflag) do {		\
  |  |  313|      0|	if (naflag) {						\
  |  |  ------------------
  |  |  |  Branch (313:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  314|      0|	    PROTECT(ans);					\
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  315|      0|	    warningcall(call, INTEGER_OVERFLOW_WARNING);	\
  |  |  ------------------
  |  |  |  | 2013|      0|# define warningcall		Rf_warningcall
  |  |  ------------------
  |  |               	    warningcall(call, INTEGER_OVERFLOW_WARNING);	\
  |  |  ------------------
  |  |  |  |  310|      0|#define INTEGER_OVERFLOW_WARNING _("NAs produced by integer overflow")
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  316|      0|	    UNPROTECT(1);					\
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |  317|      0|	}							\
  |  |  318|      0|    } while(0)
  |  |  ------------------
  |  |  |  Branch (318:13): [Folded, False: 0]
  |  |  ------------------
  ------------------
  463|      0|		    return ans;
  464|      0|		case MINUSOP:
  ------------------
  |  Branch (464:3): [True: 0, False: 1.00k]
  ------------------
  465|      0|		    ans = ScalarValue2(arg1, arg2);
  466|      0|		    SET_SCALAR_IVAL(ans, R_integer_minus(i1, i2, &naflag));
  467|      0|		    CHECK_INTEGER_OVERFLOW(call, ans, naflag);
  ------------------
  |  |  312|      0|#define CHECK_INTEGER_OVERFLOW(call, ans, naflag) do {		\
  |  |  313|      0|	if (naflag) {						\
  |  |  ------------------
  |  |  |  Branch (313:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  314|      0|	    PROTECT(ans);					\
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  315|      0|	    warningcall(call, INTEGER_OVERFLOW_WARNING);	\
  |  |  ------------------
  |  |  |  | 2013|      0|# define warningcall		Rf_warningcall
  |  |  ------------------
  |  |               	    warningcall(call, INTEGER_OVERFLOW_WARNING);	\
  |  |  ------------------
  |  |  |  |  310|      0|#define INTEGER_OVERFLOW_WARNING _("NAs produced by integer overflow")
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  316|      0|	    UNPROTECT(1);					\
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |  317|      0|	}							\
  |  |  318|      0|    } while(0)
  |  |  ------------------
  |  |  |  Branch (318:13): [Folded, False: 0]
  |  |  ------------------
  ------------------
  468|      0|		    return ans;
  469|      2|		case TIMESOP:
  ------------------
  |  Branch (469:3): [True: 2, False: 1.00k]
  ------------------
  470|      2|		    ans = ScalarValue2(arg1, arg2);
  471|      2|		    SET_SCALAR_IVAL(ans, R_integer_times(i1, i2, &naflag));
  472|      2|		    CHECK_INTEGER_OVERFLOW(call, ans, naflag);
  ------------------
  |  |  312|      2|#define CHECK_INTEGER_OVERFLOW(call, ans, naflag) do {		\
  |  |  313|      2|	if (naflag) {						\
  |  |  ------------------
  |  |  |  Branch (313:6): [True: 0, False: 2]
  |  |  ------------------
  |  |  314|      0|	    PROTECT(ans);					\
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  315|      0|	    warningcall(call, INTEGER_OVERFLOW_WARNING);	\
  |  |  ------------------
  |  |  |  | 2013|      0|# define warningcall		Rf_warningcall
  |  |  ------------------
  |  |               	    warningcall(call, INTEGER_OVERFLOW_WARNING);	\
  |  |  ------------------
  |  |  |  |  310|      0|#define INTEGER_OVERFLOW_WARNING _("NAs produced by integer overflow")
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  316|      0|	    UNPROTECT(1);					\
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |  317|      0|	}							\
  |  |  318|      2|    } while(0)
  |  |  ------------------
  |  |  |  Branch (318:13): [Folded, False: 2]
  |  |  ------------------
  ------------------
  473|      2|		    return ans;
  474|      0|		case DIVOP:
  ------------------
  |  Branch (474:3): [True: 0, False: 1.00k]
  ------------------
  475|      0|		    return ScalarReal(R_integer_divide(i1, i2));
  ------------------
  |  | 1024|      0|#define ScalarReal		Rf_ScalarReal
  ------------------
  476|  1.00k|		}
  477|  1.00k|	    }
  478|  1.00k|	}
  479|  2.00k|    }
  480|    116|    else if (argc == 1) {
  ------------------
  |  Branch (480:14): [True: 116, False: 0]
  ------------------
  481|    116|	if (IS_SCALAR(arg1, REALSXP)) {
  ------------------
  |  |  124|    116|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (481:6): [True: 2, False: 114]
  ------------------
  482|      2|	    switch(PRIMVAL(op)) {
  ------------------
  |  | 1347|      2|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (1347:20): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  483|      0|	    case PLUSOP: return(arg1);
  ------------------
  |  Branch (483:6): [True: 0, False: 2]
  ------------------
  484|      2|	    case MINUSOP:
  ------------------
  |  Branch (484:6): [True: 2, False: 0]
  ------------------
  485|      2|		ans = ScalarValue1(arg1);
  486|      2|		SET_SCALAR_DVAL(ans, -SCALAR_DVAL(arg1));
  487|      2|		return ans;
  488|      2|	    }
  489|      2|	}
  490|    114|	else if (IS_SCALAR(arg1, INTSXP)) {
  ------------------
  |  |  123|    114|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (490:11): [True: 114, False: 0]
  ------------------
  491|    114|	    int ival;
  492|    114|	    switch(PRIMVAL(op)) {
  ------------------
  |  | 1347|    114|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (1347:20): [True: 114, False: 0]
  |  |  ------------------
  ------------------
  493|      0|	    case PLUSOP: return(arg1);
  ------------------
  |  Branch (493:6): [True: 0, False: 114]
  ------------------
  494|    114|	    case MINUSOP:
  ------------------
  |  Branch (494:6): [True: 114, False: 0]
  ------------------
  495|    114|		ival = SCALAR_IVAL(arg1);
  496|    114|		ans = ScalarValue1(arg1);
  497|    114|		SET_SCALAR_IVAL(ans, ival == NA_INTEGER ? NA_INTEGER : -ival);
  ------------------
  |  |   56|    114|#define NA_INTEGER	R_NaInt
  ------------------
              		SET_SCALAR_IVAL(ans, ival == NA_INTEGER ? NA_INTEGER : -ival);
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (497:24): [True: 0, False: 114]
  ------------------
  498|    114|		return ans;
  499|    114|	    }
  500|    114|	}
  501|    116|    }
  502|       |
  503|  2.00k|    if (argc == 2)
  ------------------
  |  Branch (503:9): [True: 2.00k, False: 0]
  ------------------
  504|  2.00k|	return R_binary(call, op, arg1, arg2);
  505|      0|    else if (argc == 1)
  ------------------
  |  Branch (505:14): [True: 0, False: 0]
  ------------------
  506|      0|	return R_unary(call, op, arg1);
  507|      0|    else
  508|      0|	errorcall(call,_("operator needs one or two arguments"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call,_("operator needs one or two arguments"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  509|      0|    return ans;			/* never used; to keep -Wall happy */
  510|  2.00k|}
R_binary:
  529|  2.15k|{
  530|  2.15k|    bool xattr, yattr, xarray, yarray, xts, yts, xS4, yS4;
  531|  2.15k|    PROTECT_INDEX xpi, ypi;
  532|  2.15k|    ARITHOP_TYPE oper = (ARITHOP_TYPE) PRIMVAL(op);
  ------------------
  |  | 1347|  2.15k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  533|  2.15k|    int nprotect = 2; /* x and y */
  534|       |
  535|       |
  536|  2.15k|    PROTECT_WITH_INDEX(x, &xpi);
  ------------------
  |  |  366|  2.15k|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
  537|  2.15k|    PROTECT_WITH_INDEX(y, &ypi);
  ------------------
  |  |  366|  2.15k|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
  538|       |
  539|  2.15k|    FIXUP_NULL_AND_CHECK_TYPES(x, xpi);
  ------------------
  |  |  520|  2.15k|#define FIXUP_NULL_AND_CHECK_TYPES(v, vpi) do { \
  |  |  521|  2.15k|    switch (TYPEOF(v)) { \
  |  |  522|      0|    case NILSXP: REPROTECT(v = allocVector(INTSXP,0), vpi); break; \
  |  |  ------------------
  |  |  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  |  |  ------------------
  |  |                   case NILSXP: REPROTECT(v = allocVector(INTSXP,0), vpi); break; \
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  |  |  Branch (522:5): [True: 0, False: 2.15k]
  |  |  ------------------
  |  |  523|  2.15k|    case CPLXSXP: case REALSXP: case INTSXP: case LGLSXP: break; \
  |  |  ------------------
  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |                   case CPLXSXP: case REALSXP: case INTSXP: case LGLSXP: break; \
  |  |  ------------------
  |  |  |  |  124|  1.06k|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |                   case CPLXSXP: case REALSXP: case INTSXP: case LGLSXP: break; \
  |  |  ------------------
  |  |  |  |  123|  2.15k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |                   case CPLXSXP: case REALSXP: case INTSXP: case LGLSXP: break; \
  |  |  ------------------
  |  |  |  |  121|  2.15k|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (523:5): [True: 0, False: 2.15k]
  |  |  |  Branch (523:19): [True: 1.06k, False: 1.08k]
  |  |  |  Branch (523:33): [True: 1.08k, False: 1.06k]
  |  |  |  Branch (523:46): [True: 0, False: 2.15k]
  |  |  ------------------
  |  |  524|  2.15k|    default: errorcall(call, _("non-numeric argument to binary operator")); \
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |                   default: errorcall(call, _("non-numeric argument to binary operator")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  |  Branch (524:5): [True: 0, False: 2.15k]
  |  |  ------------------
  |  |  525|  2.15k|    } \
  |  |  526|  2.15k|} while (0)
  |  |  ------------------
  |  |  |  Branch (526:10): [Folded, False: 2.15k]
  |  |  ------------------
  ------------------
  540|  2.15k|    FIXUP_NULL_AND_CHECK_TYPES(y, ypi);
  ------------------
  |  |  520|  2.15k|#define FIXUP_NULL_AND_CHECK_TYPES(v, vpi) do { \
  |  |  521|  2.15k|    switch (TYPEOF(v)) { \
  |  |  522|      0|    case NILSXP: REPROTECT(v = allocVector(INTSXP,0), vpi); break; \
  |  |  ------------------
  |  |  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  |  |  ------------------
  |  |                   case NILSXP: REPROTECT(v = allocVector(INTSXP,0), vpi); break; \
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  |  |  Branch (522:5): [True: 0, False: 2.15k]
  |  |  ------------------
  |  |  523|  2.15k|    case CPLXSXP: case REALSXP: case INTSXP: case LGLSXP: break; \
  |  |  ------------------
  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |                   case CPLXSXP: case REALSXP: case INTSXP: case LGLSXP: break; \
  |  |  ------------------
  |  |  |  |  124|  1.13k|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |                   case CPLXSXP: case REALSXP: case INTSXP: case LGLSXP: break; \
  |  |  ------------------
  |  |  |  |  123|  2.13k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |                   case CPLXSXP: case REALSXP: case INTSXP: case LGLSXP: break; \
  |  |  ------------------
  |  |  |  |  121|  2.15k|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (523:5): [True: 0, False: 2.15k]
  |  |  |  Branch (523:19): [True: 1.13k, False: 1.02k]
  |  |  |  Branch (523:33): [True: 1.00k, False: 1.14k]
  |  |  |  Branch (523:46): [True: 18, False: 2.13k]
  |  |  ------------------
  |  |  524|  2.13k|    default: errorcall(call, _("non-numeric argument to binary operator")); \
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |                   default: errorcall(call, _("non-numeric argument to binary operator")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  |  Branch (524:5): [True: 0, False: 2.15k]
  |  |  ------------------
  |  |  525|  2.15k|    } \
  |  |  526|  2.15k|} while (0)
  |  |  ------------------
  |  |  |  Branch (526:10): [Folded, False: 2.15k]
  |  |  ------------------
  ------------------
  541|       |
  542|  2.15k|    R_xlen_t
  543|  2.15k|	nx = XLENGTH(x),
  544|  2.15k|	ny = XLENGTH(y);
  545|  2.15k|    if (ATTRIB(x) != R_NilValue) {
  ------------------
  |  Branch (545:9): [True: 0, False: 2.15k]
  ------------------
  546|      0|	xattr = true;
  547|      0|	xarray = isArray(x);
  ------------------
  |  |  940|      0|#define isArray			Rf_isArray
  ------------------
  548|      0|	xts = isTs(x);
  ------------------
  |  |  967|      0|#define isTs			Rf_isTs
  ------------------
  549|      0|	xS4 = isS4(x);
  ------------------
  |  |  964|      0|#define isS4			Rf_isS4
  ------------------
  550|      0|    }
  551|  2.15k|    else xattr = xarray = xts = xS4 = false;
  552|  2.15k|    if (ATTRIB(y) != R_NilValue) {
  ------------------
  |  Branch (552:9): [True: 0, False: 2.15k]
  ------------------
  553|      0|	yattr = true;
  554|      0|	yarray = isArray(y);
  ------------------
  |  |  940|      0|#define isArray			Rf_isArray
  ------------------
  555|      0|	yts = isTs(y);
  ------------------
  |  |  967|      0|#define isTs			Rf_isTs
  ------------------
  556|      0|	yS4 = isS4(y);
  ------------------
  |  |  964|      0|#define isS4			Rf_isS4
  ------------------
  557|      0|    }
  558|  2.15k|    else yattr = yarray = yts = yS4 = false;
  559|       |
  560|  2.15k|#define R_ARITHMETIC_ARRAY_1_SPECIAL
  561|       |
  562|  2.15k|#ifdef R_ARITHMETIC_ARRAY_1_SPECIAL
  563|       |    /* If either x or y is a matrix with length 1 and the other is a
  564|       |       vector of a different length, we want to coerce the matrix to be a vector.
  565|       |       Do we want to?  We don't do it!  BDR 2004-03-06
  566|       |
  567|       |       From 3.4.0 (Sep. 2016), this signals a warning,
  568|       |       and in the future we will disable these 2 clauses,
  569|       |       so it will give an error.
  570|       |    */
  571|       |
  572|       |    /* FIXME: Danger Will Robinson.
  573|       |     * -----  We might be trashing arguments here.
  574|       |     */
  575|  2.15k|    if (xarray != yarray) {
  ------------------
  |  Branch (575:9): [True: 0, False: 2.15k]
  ------------------
  576|      0|    	if (xarray && nx==1 && ny!=1) {
  ------------------
  |  Branch (576:10): [True: 0, False: 0]
  |  Branch (576:20): [True: 0, False: 0]
  |  Branch (576:29): [True: 0, False: 0]
  ------------------
  577|      0|	    if(ny != 0)
  ------------------
  |  Branch (577:9): [True: 0, False: 0]
  ------------------
  578|      0|		warningcall(call, _(
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              		warningcall(call, _(
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  579|      0|	"Recycling array of length 1 in array-vector arithmetic is deprecated.\n\
  580|      0|  Use c() or as.vector() instead."));
  581|      0|    	    REPROTECT(x = duplicate(x), xpi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  582|      0|    	    setAttrib(x, R_DimSymbol, R_NilValue);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  583|      0|    	}
  584|      0|    	if (yarray && ny==1 && nx!=1) {
  ------------------
  |  Branch (584:10): [True: 0, False: 0]
  |  Branch (584:20): [True: 0, False: 0]
  |  Branch (584:29): [True: 0, False: 0]
  ------------------
  585|      0|	    if(nx != 0)
  ------------------
  |  Branch (585:9): [True: 0, False: 0]
  ------------------
  586|      0|		warningcall(call, _(
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              		warningcall(call, _(
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  587|      0|	"Recycling array of length 1 in vector-array arithmetic is deprecated.\n\
  588|      0|  Use c() or as.vector() instead."));
  589|      0|    	    REPROTECT(y = duplicate(y), ypi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  590|      0|    	    setAttrib(y, R_DimSymbol, R_NilValue);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  591|      0|    	}
  592|      0|    }
  593|  2.15k|#endif
  594|       |
  595|  2.15k|    SEXP dims, xnames, ynames;
  596|  2.15k|    if (xarray || yarray) {
  ------------------
  |  Branch (596:9): [True: 0, False: 2.15k]
  |  Branch (596:19): [True: 0, False: 2.15k]
  ------------------
  597|       |	/* if one is a length-atleast-1-array and the
  598|       |	 * other  is a length-0 *non*array, then do not use array treatment */
  599|      0|	if (xarray && yarray) {
  ------------------
  |  Branch (599:6): [True: 0, False: 0]
  |  Branch (599:16): [True: 0, False: 0]
  ------------------
  600|      0|	    if (!conformable(x, y))
  ------------------
  |  |  896|      0|#define conformable		Rf_conformable
  ------------------
  |  Branch (600:10): [True: 0, False: 0]
  ------------------
  601|      0|		errorcall(call, _("non-conformable arrays"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		errorcall(call, _("non-conformable arrays"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  602|      0|	    PROTECT(dims = getAttrib(x, R_DimSymbol)); nprotect++;
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  603|      0|	}
  604|      0|	else if (xarray && (ny != 0 || nx == 0)) {
  ------------------
  |  Branch (604:11): [True: 0, False: 0]
  |  Branch (604:22): [True: 0, False: 0]
  |  Branch (604:33): [True: 0, False: 0]
  ------------------
  605|      0|	    PROTECT(dims = getAttrib(x, R_DimSymbol)); nprotect++;
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  606|      0|	}
  607|      0|	else if (yarray && (nx != 0 || ny == 0)) {
  ------------------
  |  Branch (607:11): [True: 0, False: 0]
  |  Branch (607:22): [True: 0, False: 0]
  |  Branch (607:33): [True: 0, False: 0]
  ------------------
  608|      0|	    PROTECT(dims = getAttrib(y, R_DimSymbol)); nprotect++;
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  609|      0|	} else
  610|      0|	    dims = R_NilValue;
  611|      0|	if (xattr) {
  ------------------
  |  Branch (611:6): [True: 0, False: 0]
  ------------------
  612|      0|	    PROTECT(xnames = getAttrib(x, R_DimNamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  613|      0|	    nprotect++;
  614|      0|	}
  615|      0|	else xnames = R_NilValue;
  616|      0|	if (yattr) {
  ------------------
  |  Branch (616:6): [True: 0, False: 0]
  ------------------
  617|      0|	    PROTECT(ynames = getAttrib(y, R_DimNamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  618|      0|	    nprotect++;
  619|      0|	}
  620|      0|	else ynames = R_NilValue;
  621|      0|    }
  622|  2.15k|    else {
  623|  2.15k|	dims = R_NilValue;
  624|  2.15k|	if (xattr) {
  ------------------
  |  Branch (624:6): [True: 0, False: 2.15k]
  ------------------
  625|      0|	    PROTECT(xnames = getAttrib(x, R_NamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  626|      0|	    nprotect++;
  627|      0|	}
  628|  2.15k|	else xnames = R_NilValue;
  629|  2.15k|	if (yattr) {
  ------------------
  |  Branch (629:6): [True: 0, False: 2.15k]
  ------------------
  630|      0|	    PROTECT(ynames = getAttrib(y, R_NamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  631|      0|	    nprotect++;
  632|      0|	}
  633|  2.15k|	else ynames = R_NilValue;
  634|  2.15k|    }
  635|       |
  636|  2.15k|    SEXP klass = NULL, tsp = NULL; // -Wall
  637|  2.15k|    if (xts || yts) {
  ------------------
  |  Branch (637:9): [True: 0, False: 2.15k]
  |  Branch (637:16): [True: 0, False: 2.15k]
  ------------------
  638|      0|	if (xts && yts) {
  ------------------
  |  Branch (638:6): [True: 0, False: 0]
  |  Branch (638:13): [True: 0, False: 0]
  ------------------
  639|       |	    /* could check ts conformance here */
  640|      0|	    PROTECT(tsp = getAttrib(x, R_TspSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  641|      0|	    PROTECT(klass = getAttrib(x, R_ClassSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  642|      0|	}
  643|      0|	else if (xts) {
  ------------------
  |  Branch (643:11): [True: 0, False: 0]
  ------------------
  644|      0|	    if (nx < ny)
  ------------------
  |  Branch (644:10): [True: 0, False: 0]
  ------------------
  645|      0|		ErrorMessage(call, ERROR_TSVEC_MISMATCH);
  ------------------
  |  | 1897|      0|# define ErrorMessage		Rf_ErrorMessage
  ------------------
  646|      0|	    PROTECT(tsp = getAttrib(x, R_TspSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  647|      0|	    PROTECT(klass = getAttrib(x, R_ClassSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  648|      0|	}
  649|      0|	else {			/* (yts) */
  650|      0|	    if (ny < nx)
  ------------------
  |  Branch (650:10): [True: 0, False: 0]
  ------------------
  651|      0|		ErrorMessage(call, ERROR_TSVEC_MISMATCH);
  ------------------
  |  | 1897|      0|# define ErrorMessage		Rf_ErrorMessage
  ------------------
  652|      0|	    PROTECT(tsp = getAttrib(y, R_TspSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  653|      0|	    PROTECT(klass = getAttrib(y, R_ClassSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  654|      0|	}
  655|      0|	nprotect += 2;
  656|      0|    }
  657|       |
  658|  2.15k|    if (nx > 0 && ny > 0 &&
  ------------------
  |  Branch (658:9): [True: 2.05k, False: 96]
  |  Branch (658:19): [True: 2.05k, False: 0]
  ------------------
  659|  2.05k|	((nx > ny) ? nx % ny : ny % nx) != 0) // mismatch
  ------------------
  |  Branch (659:2): [True: 0, False: 2.05k]
  |  Branch (659:3): [True: 928, False: 1.12k]
  ------------------
  660|      0|	warningcall(call,
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
  661|      0|		    _("longer object length is not a multiple of shorter object length"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  662|       |
  663|  2.15k|    SEXP val;
  664|       |    /* need to preserve object here, as *_binary copies class attributes */
  665|  2.15k|    if (TYPEOF(x) == CPLXSXP || TYPEOF(y) == CPLXSXP) {
  ------------------
  |  |  125|  4.30k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
                  if (TYPEOF(x) == CPLXSXP || TYPEOF(y) == CPLXSXP) {
  ------------------
  |  |  125|  2.15k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (665:9): [True: 0, False: 2.15k]
  |  Branch (665:33): [True: 0, False: 2.15k]
  ------------------
  666|       |/* TODO: if not both are CPLX, work with "coordinate-wise   scalar o <2D-vector> "
  667|       |   1) can be *faster* for all ops
  668|       |   2) for '*' and '/' (with  y  DBL/INT/LGL ) really different use C standard <real> o <cmplx>
  669|       |*/
  670|      0|	COERCE_IF_NEEDED(x, CPLXSXP, xpi);
  ------------------
  |  |  512|      0|#define COERCE_IF_NEEDED(v, tp, vpi) do { \
  |  |  513|      0|    if (TYPEOF(v) != (tp)) { \
  |  |  ------------------
  |  |  |  Branch (513:9): [True: 0, False: 0]
  |  |  ------------------
  |  |  514|      0|	int __vo__ = OBJECT(v); \
  |  |  515|      0|	REPROTECT(v = coerceVector(v, (tp)), vpi); \
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  |  516|      0|	if (__vo__) SET_OBJECT(v, 1); \
  |  |  ------------------
  |  |  |  Branch (516:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  517|      0|    } \
  |  |  518|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (518:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  671|      0|	COERCE_IF_NEEDED(y, CPLXSXP, ypi);
  ------------------
  |  |  512|      0|#define COERCE_IF_NEEDED(v, tp, vpi) do { \
  |  |  513|      0|    if (TYPEOF(v) != (tp)) { \
  |  |  ------------------
  |  |  |  Branch (513:9): [True: 0, False: 0]
  |  |  ------------------
  |  |  514|      0|	int __vo__ = OBJECT(v); \
  |  |  515|      0|	REPROTECT(v = coerceVector(v, (tp)), vpi); \
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  |  516|      0|	if (__vo__) SET_OBJECT(v, 1); \
  |  |  ------------------
  |  |  |  Branch (516:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  517|      0|    } \
  |  |  518|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (518:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  672|      0|	val = complex_binary(oper, x, y);
  673|      0|    }
  674|  2.15k|    else if (TYPEOF(x) == REALSXP || TYPEOF(y) == REALSXP) {
  ------------------
  |  |  124|  4.30k|#define REALSXP	    14	  /* real variables */
  ------------------
                  else if (TYPEOF(x) == REALSXP || TYPEOF(y) == REALSXP) {
  ------------------
  |  |  124|  1.08k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (674:14): [True: 1.06k, False: 1.08k]
  |  Branch (674:38): [True: 64, False: 1.02k]
  ------------------
  675|       |	/* real_binary can handle REALSXP or INTSXP operand, but not LGLSXP. */
  676|       |	/* Can get a LGLSXP. In base-Ex.R on 24 Oct '06, got 8 of these. */
  677|  1.13k|	if (TYPEOF(x) != INTSXP) COERCE_IF_NEEDED(x, REALSXP, xpi);
  ------------------
  |  |  123|  1.13k|#define INTSXP	    13	  /* integer vectors */
  ------------------
              	if (TYPEOF(x) != INTSXP) COERCE_IF_NEEDED(x, REALSXP, xpi);
  ------------------
  |  |  512|  1.06k|#define COERCE_IF_NEEDED(v, tp, vpi) do { \
  |  |  513|  1.06k|    if (TYPEOF(v) != (tp)) { \
  |  |  ------------------
  |  |  |  Branch (513:9): [True: 0, False: 1.06k]
  |  |  ------------------
  |  |  514|      0|	int __vo__ = OBJECT(v); \
  |  |  515|      0|	REPROTECT(v = coerceVector(v, (tp)), vpi); \
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  |  516|      0|	if (__vo__) SET_OBJECT(v, 1); \
  |  |  ------------------
  |  |  |  Branch (516:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  517|      0|    } \
  |  |  518|  1.06k|} while (0)
  |  |  ------------------
  |  |  |  Branch (518:10): [Folded, False: 1.06k]
  |  |  ------------------
  ------------------
  |  Branch (677:6): [True: 1.06k, False: 64]
  ------------------
  678|  1.13k|	if (TYPEOF(y) != INTSXP) COERCE_IF_NEEDED(y, REALSXP, ypi);
  ------------------
  |  |  123|  1.13k|#define INTSXP	    13	  /* integer vectors */
  ------------------
              	if (TYPEOF(y) != INTSXP) COERCE_IF_NEEDED(y, REALSXP, ypi);
  ------------------
  |  |  512|  1.13k|#define COERCE_IF_NEEDED(v, tp, vpi) do { \
  |  |  513|  1.13k|    if (TYPEOF(v) != (tp)) { \
  |  |  ------------------
  |  |  |  Branch (513:9): [True: 0, False: 1.13k]
  |  |  ------------------
  |  |  514|      0|	int __vo__ = OBJECT(v); \
  |  |  515|      0|	REPROTECT(v = coerceVector(v, (tp)), vpi); \
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  |  516|      0|	if (__vo__) SET_OBJECT(v, 1); \
  |  |  ------------------
  |  |  |  Branch (516:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  517|      0|    } \
  |  |  518|  1.13k|} while (0)
  |  |  ------------------
  |  |  |  Branch (518:10): [Folded, False: 1.13k]
  |  |  ------------------
  ------------------
  |  Branch (678:6): [True: 1.13k, False: 0]
  ------------------
  679|  1.13k|	val = real_binary(oper, x, y);
  680|  1.13k|    }
  681|  1.02k|    else val = integer_binary(oper, x, y, call);
  682|       |
  683|       |    /* quick return if there are no attributes */
  684|  2.15k|    if (! xattr && ! yattr) {
  ------------------
  |  Branch (684:9): [True: 2.15k, False: 0]
  |  Branch (684:20): [True: 2.15k, False: 0]
  ------------------
  685|  2.15k|	UNPROTECT(nprotect);
  ------------------
  |  |  358|  2.15k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  686|  2.15k|	return val;
  687|  2.15k|    }
  688|       |
  689|      0|    PROTECT(val);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  690|      0|    nprotect++;
  691|       |
  692|      0|    if (dims != R_NilValue) {
  ------------------
  |  Branch (692:9): [True: 0, False: 0]
  ------------------
  693|      0|	    setAttrib(val, R_DimSymbol, dims);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  694|      0|	    if (xnames != R_NilValue)
  ------------------
  |  Branch (694:10): [True: 0, False: 0]
  ------------------
  695|      0|		setAttrib(val, R_DimNamesSymbol, xnames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  696|      0|	    else if (ynames != R_NilValue)
  ------------------
  |  Branch (696:15): [True: 0, False: 0]
  ------------------
  697|      0|		setAttrib(val, R_DimNamesSymbol, ynames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  698|      0|    }
  699|      0|    else {
  700|      0|	if (XLENGTH(val) == xlength(xnames))
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (700:6): [True: 0, False: 0]
  ------------------
  701|      0|	    setAttrib(val, R_NamesSymbol, xnames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  702|      0|	else if (XLENGTH(val) == xlength(ynames))
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (702:11): [True: 0, False: 0]
  ------------------
  703|      0|	    setAttrib(val, R_NamesSymbol, ynames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  704|      0|    }
  705|       |
  706|      0|    if (xts || yts) {		/* must set *after* dims! */
  ------------------
  |  Branch (706:9): [True: 0, False: 0]
  |  Branch (706:16): [True: 0, False: 0]
  ------------------
  707|      0|	setAttrib(val, R_TspSymbol, tsp);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  708|      0|	setAttrib(val, R_ClassSymbol, klass);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  709|      0|    }
  710|       |
  711|      0|    if(xS4 || yS4) {   /* Only set the bit:  no method defined! */
  ------------------
  |  Branch (711:8): [True: 0, False: 0]
  |  Branch (711:15): [True: 0, False: 0]
  ------------------
  712|      0|	val = asS4(val, TRUE, TRUE); // from objects.c
  ------------------
  |  |  890|      0|#define asS4			Rf_asS4
  ------------------
  713|      0|    }
  714|      0|    UNPROTECT(nprotect);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  715|      0|    return val;
  716|  2.15k|}
R_unary:
  719|     14|{
  720|     14|    ARITHOP_TYPE operation = (ARITHOP_TYPE) PRIMVAL(op);
  ------------------
  |  | 1347|     14|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  721|     14|    switch (TYPEOF(s1)) {
  722|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (722:5): [True: 0, False: 14]
  ------------------
  723|      0|	return logical_unary(operation, s1, call);
  724|     14|    case INTSXP:
  ------------------
  |  |  123|     14|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (724:5): [True: 14, False: 0]
  ------------------
  725|     14|	return integer_unary(operation, s1, call);
  726|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (726:5): [True: 0, False: 14]
  ------------------
  727|      0|	return real_unary(operation, s1, call);
  728|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (728:5): [True: 0, False: 14]
  ------------------
  729|      0|	return complex_unary(operation, s1, call);
  730|      0|    default:
  ------------------
  |  Branch (730:5): [True: 0, False: 14]
  ------------------
  731|      0|	errorcall(call, _("invalid argument to unary operator"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid argument to unary operator"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  732|     14|    }
  733|      0|    return s1;			/* never used; to keep -Wall happy */
  734|     14|}
do_abs:
 1468|  1.77k|{
 1469|  1.77k|    SEXP x, s = R_NilValue /* -Wall */;
 1470|       |
 1471|  1.77k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.77k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1472|  1.77k|    check1arg(args, call, "x");
  ------------------
  |  | 1867|  1.77k|# define check1arg		Rf_check1arg
  ------------------
 1473|  1.77k|    x = CAR(args);
 1474|       |
 1475|  1.77k|    if (DispatchGroup("Math", call, op, args, env, &s))
  ------------------
  |  | 1886|  1.77k|# define DispatchGroup		Rf_DispatchGroup
  ------------------
  |  Branch (1475:9): [True: 0, False: 1.77k]
  ------------------
 1476|      0|	return s;
 1477|       |
 1478|  1.77k|    if (isInteger(x) || isLogical(x)) {
  ------------------
  |  |  949|  1.77k|#define isInteger		Rf_isInteger
  ------------------
                  if (isInteger(x) || isLogical(x)) {
  ------------------
  |  |  952|  1.77k|#define isLogical		Rf_isLogical
  ------------------
  |  Branch (1478:9): [True: 0, False: 1.77k]
  |  Branch (1478:25): [True: 0, False: 1.77k]
  ------------------
 1479|       |	/* integer or logical ==> return integer,
 1480|       |	   factor was covered by Math.factor. */
 1481|      0|	R_xlen_t i, n = XLENGTH(x);
 1482|      0|	s = (NO_REFERENCES(x) && TYPEOF(x) == INTSXP) ?
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1482:7): [True: 0, False: 0]
  |  Branch (1482:27): [True: 0, False: 0]
  ------------------
 1483|      0|	    x : allocVector(INTSXP, n);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	    x : allocVector(INTSXP, n);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
 1484|      0|	PROTECT(s);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1485|       |	/* Note: relying on INTEGER(.) === LOGICAL(.) : */
 1486|      0|	int *pa = INTEGER(s);
 1487|      0|	const int *px = INTEGER_RO(x);
 1488|      0|	for(i = 0 ; i < n ; i++) {
  ------------------
  |  Branch (1488:14): [True: 0, False: 0]
  ------------------
 1489|      0|	    int xi = px[i];
 1490|      0|	    pa[i] = (xi == NA_INTEGER) ? xi : abs(xi);
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1490:14): [True: 0, False: 0]
  ------------------
 1491|      0|	}
 1492|  1.77k|    } else if (TYPEOF(x) == REALSXP) {
  ------------------
  |  |  124|  1.77k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1492:16): [True: 1.77k, False: 0]
  ------------------
 1493|  1.77k|	R_xlen_t i, n = XLENGTH(x);
 1494|  1.77k|	PROTECT(s = NO_REFERENCES(x) ? x : allocVector(REALSXP, n));
  ------------------
  |  |  357|  3.55k|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  |  Branch (357:31): [True: 1.77k, False: 0]
  |  |  ------------------
  ------------------
 1495|  1.77k|	double *pa = REAL(s);
 1496|  1.77k|	const double *px = REAL_RO(x);
 1497|   483k|	for(i = 0 ; i < n ; i++)
  ------------------
  |  Branch (1497:14): [True: 481k, False: 1.77k]
  ------------------
 1498|   481k|	    pa[i] = fabs(px[i]);
 1499|  1.77k|    } else if (isComplex(x)) {
  ------------------
  |  |  942|      0|#define isComplex		Rf_isComplex
  ------------------
  |  Branch (1499:16): [True: 0, False: 0]
  ------------------
 1500|      0|	SET_TAG(args, R_NilValue); /* cmathfuns want "z"; we might have "x" PR#16047 */
 1501|      0|	return do_cmathfuns(call, op, args, env);
 1502|      0|    } else
 1503|      0|	errorcall(call, R_MSG_NONNUM_MATH);
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, R_MSG_NONNUM_MATH);
  ------------------
  |  |   51|      0|#define R_MSG_NONNUM_MATH _("non-numeric argument to mathematical function")
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  ------------------
 1504|       |
 1505|  1.77k|    if (x != s && ATTRIB(x) != R_NilValue)
  ------------------
  |  Branch (1505:9): [True: 0, False: 1.77k]
  |  Branch (1505:19): [True: 0, False: 0]
  ------------------
 1506|      0|	SHALLOW_DUPLICATE_ATTRIB(s, x);
 1507|  1.77k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.77k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1508|  1.77k|    return s;
 1509|  1.77k|}
arithmetic.c:R_ValueOfNA:
   92|      2|{
   93|       |    /* The gcc (3.2.1?) shipping with Red Hat Linux 9 gets this wrong
   94|       |     * without the volatile declaration. Thanks to Marc Schwartz. */
   95|      2|    volatile ieee_double x;
   96|      2|    x.word[hw] = 0x7ff00000;
   97|      2|    x.word[lw] = 1954;
   98|      2|    return x.value;
   99|      2|}
arithmetic.c:myfmod:
  174|   476k|{
  175|   476k|    if (x2 == 0.0) return R_NaN;
  ------------------
  |  Branch (175:9): [True: 0, False: 476k]
  ------------------
  176|   476k|    if(fabs(x2) * c_eps > 1 && R_FINITE(x1) && fabs(x1) <= fabs(x2)) {
  ------------------
  |  |  167|   476k|# define c_eps LDBL_EPSILON
  ------------------
                  if(fabs(x2) * c_eps > 1 && R_FINITE(x1) && fabs(x1) <= fabs(x2)) {
  ------------------
  |  |   82|   476k|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (176:8): [True: 0, False: 476k]
  |  Branch (176:32): [True: 0, False: 0]
  |  Branch (176:48): [True: 0, False: 0]
  ------------------
  177|      0|	return
  178|      0|	    (fabs(x1) == fabs(x2)) ? 0 :
  ------------------
  |  Branch (178:6): [True: 0, False: 0]
  ------------------
  179|      0|	    ((x1 < 0 && x2 > 0) ||
  ------------------
  |  Branch (179:8): [True: 0, False: 0]
  |  Branch (179:18): [True: 0, False: 0]
  ------------------
  180|      0|	     (x2 < 0 && x1 > 0))
  ------------------
  |  Branch (180:8): [True: 0, False: 0]
  |  Branch (180:18): [True: 0, False: 0]
  ------------------
  181|      0|	     ? x1+x2  // differing signs
  182|      0|	     : x1   ; // "same" signs (incl. 0)
  183|      0|    }
  184|   476k|    double q = x1 / x2;
  185|   476k|    if(R_FINITE(q) && (fabs(q) * c_eps > 1))
  ------------------
  |  |   82|   476k|# define R_FINITE(x)    isfinite(x)
  ------------------
                  if(R_FINITE(q) && (fabs(q) * c_eps > 1))
  ------------------
  |  |  167|   476k|# define c_eps LDBL_EPSILON
  ------------------
  |  Branch (185:8): [True: 476k, False: 0]
  |  Branch (185:23): [True: 384k, False: 92.0k]
  ------------------
  186|   384k|	warning(_("probable complete loss of accuracy in modulus"));
  ------------------
  |  |   89|   384k|#define warning Rf_warning
  ------------------
              	warning(_("probable complete loss of accuracy in modulus"));
  ------------------
  |  | 2531|   384k|#   define _(String) gettext (String)
  ------------------
  187|   476k|    LDOUBLE tmp = (LDOUBLE)x1 - floor(q) * (LDOUBLE)x2;
  ------------------
  |  | 2577|   476k|# define LDOUBLE long double
  ------------------
  188|   476k|    return (double) (tmp - floorl(tmp/x2) * x2);
  189|   476k|}
arithmetic.c:ScalarValue2:
  386|     45|{
  387|     45|    if (NO_REFERENCES(x))
  ------------------
  |  Branch (387:9): [True: 0, False: 45]
  ------------------
  388|      0|	return x;
  389|     45|    else if (NO_REFERENCES(y))
  ------------------
  |  Branch (389:14): [True: 2, False: 43]
  ------------------
  390|      2|	return y;
  391|     43|    else
  392|     43|	return allocVector(TYPEOF(x), 1);
  ------------------
  |  |  875|     43|#define allocVector		Rf_allocVector
  ------------------
  393|     45|}
arithmetic.c:ScalarValue1:
  378|    116|{
  379|    116|    if (NO_REFERENCES(x))
  ------------------
  |  Branch (379:9): [True: 0, False: 116]
  ------------------
  380|      0|	return x;
  381|    116|    else
  382|    116|	return allocVector(TYPEOF(x), 1);
  ------------------
  |  |  875|    116|#define allocVector		Rf_allocVector
  ------------------
  383|    116|}
arithmetic.c:R_integer_plus:
  325|      2|{
  326|      2|    if (x == NA_INTEGER || y == NA_INTEGER)
  ------------------
  |  |   56|      4|#define NA_INTEGER	R_NaInt
  ------------------
                  if (x == NA_INTEGER || y == NA_INTEGER)
  ------------------
  |  |   56|      2|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (326:9): [True: 0, False: 2]
  |  Branch (326:28): [True: 0, False: 2]
  ------------------
  327|      0|	return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  328|       |
  329|      2|    if (((y > 0) && (x > (R_INT_MAX - y))) ||
  ------------------
  |  |  320|      2|#define R_INT_MAX  INT_MAX
  ------------------
  |  Branch (329:10): [True: 2, False: 0]
  |  Branch (329:21): [True: 0, False: 2]
  ------------------
  330|      2|	((y < 0) && (x < (R_INT_MIN - y)))) {
  ------------------
  |  |  321|      0|#define R_INT_MIN -INT_MAX
  ------------------
  |  Branch (330:3): [True: 0, False: 2]
  |  Branch (330:14): [True: 0, False: 0]
  ------------------
  331|      0|	if (pnaflag != NULL)
  ------------------
  |  Branch (331:6): [True: 0, False: 0]
  ------------------
  332|      0|	    *pnaflag = true;
  333|      0|	return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  334|      0|    }
  335|      2|    return x + y;
  336|      2|}
arithmetic.c:R_integer_minus:
  339|     16|{
  340|     16|    if (x == NA_INTEGER || y == NA_INTEGER)
  ------------------
  |  |   56|     32|#define NA_INTEGER	R_NaInt
  ------------------
                  if (x == NA_INTEGER || y == NA_INTEGER)
  ------------------
  |  |   56|     16|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (340:9): [True: 0, False: 16]
  |  Branch (340:28): [True: 0, False: 16]
  ------------------
  341|      0|	return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  342|       |
  343|     16|    if (((y < 0) && (x > (R_INT_MAX + y))) ||
  ------------------
  |  |  320|      0|#define R_INT_MAX  INT_MAX
  ------------------
  |  Branch (343:10): [True: 0, False: 16]
  |  Branch (343:21): [True: 0, False: 0]
  ------------------
  344|     16|	((y > 0) && (x < (R_INT_MIN + y)))) {
  ------------------
  |  |  321|      0|#define R_INT_MIN -INT_MAX
  ------------------
  |  Branch (344:3): [True: 0, False: 16]
  |  Branch (344:14): [True: 0, False: 0]
  ------------------
  345|      0|	if (pnaflag != NULL)
  ------------------
  |  Branch (345:6): [True: 0, False: 0]
  ------------------
  346|      0|	    *pnaflag = true;
  347|      0|	return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  348|      0|    }
  349|     16|    return x - y;
  350|     16|}
arithmetic.c:R_integer_times:
  354|      2|{
  355|      2|    if (x == NA_INTEGER || y == NA_INTEGER)
  ------------------
  |  |   56|      4|#define NA_INTEGER	R_NaInt
  ------------------
                  if (x == NA_INTEGER || y == NA_INTEGER)
  ------------------
  |  |   56|      2|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (355:9): [True: 0, False: 2]
  |  Branch (355:28): [True: 0, False: 2]
  ------------------
  356|      0|	return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  357|      2|    else {
  358|      2|	int z = x * y;  // UBSAN will warn if this overflows (happens in bda)
  359|      2|	if (GOODIPROD(x, y, z) && z != NA_INTEGER)
  ------------------
  |  |  352|      4|#define GOODIPROD(x, y, z) ((double) (x) * (double) (y) == (z))
  |  |  ------------------
  |  |  |  Branch (352:28): [True: 2, False: 0]
  |  |  ------------------
  ------------------
              	if (GOODIPROD(x, y, z) && z != NA_INTEGER)
  ------------------
  |  |   56|      2|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (359:28): [True: 2, False: 0]
  ------------------
  360|      2|	    return z;
  361|      0|	else {
  362|      0|	    if (pnaflag != NULL)
  ------------------
  |  Branch (362:10): [True: 0, False: 0]
  ------------------
  363|      0|		*pnaflag = true;
  364|      0|	    return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  365|      0|	}
  366|      2|    }
  367|      2|}
arithmetic.c:integer_unary:
  770|     14|{
  771|     14|    R_xlen_t i, n;
  772|     14|    SEXP ans;
  773|       |
  774|     14|    switch (code) {
  775|      0|    case PLUSOP:
  ------------------
  |  Branch (775:5): [True: 0, False: 14]
  ------------------
  776|      0|	return s1;
  777|     14|    case MINUSOP:
  ------------------
  |  Branch (777:5): [True: 14, False: 0]
  ------------------
  778|     14|	ans = NO_REFERENCES(s1) ? s1 : duplicate(s1);
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
  |  Branch (778:8): [True: 14, False: 0]
  ------------------
  779|     14|	int *pa = INTEGER(ans);
  780|     14|	const int *px = INTEGER_RO(s1);
  781|     14|	n = XLENGTH(s1);
  782|     56|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (782:14): [True: 42, False: 14]
  ------------------
  783|     42|	    int x = px[i];
  784|     42|	    pa[i] = (x == NA_INTEGER) ?
  ------------------
  |  |   56|     42|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (784:14): [True: 0, False: 42]
  ------------------
  785|     42|		NA_INTEGER : ((x == 0.0) ? 0 : -x);
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (785:17): [True: 14, False: 28]
  ------------------
  786|     42|	}
  787|     14|	return ans;
  788|      0|    default:
  ------------------
  |  Branch (788:5): [True: 0, False: 14]
  ------------------
  789|      0|	errorcall(call, _("invalid unary operator"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid unary operator"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  790|     14|    }
  791|      0|    return s1;			/* never used; to keep -Wall happy */
  792|     14|}
arithmetic.c:integer_binary:
  816|  1.02k|{
  817|  1.02k|    R_xlen_t i, i1, i2, n, n1, n2;
  818|  1.02k|    int x1, x2;
  819|  1.02k|    SEXP ans;
  820|  1.02k|    bool naflag = false;
  821|       |
  822|  1.02k|    n1 = XLENGTH(s1);
  823|  1.02k|    n2 = XLENGTH(s2);
  824|       |    /* S4-compatibility change: if n1 or n2 is 0, result is of length 0 */
  825|  1.02k|    if (n1 == 0 || n2 == 0) n = 0; else n = (n1 > n2) ? n1 : n2;
  ------------------
  |  Branch (825:9): [True: 0, False: 1.02k]
  |  Branch (825:20): [True: 0, False: 1.02k]
  |  Branch (825:45): [True: 0, False: 1.02k]
  ------------------
  826|       |
  827|  1.02k|    if (code == DIVOP || code == POWOP)
  ------------------
  |  Branch (827:9): [True: 0, False: 1.02k]
  |  Branch (827:26): [True: 0, False: 1.02k]
  ------------------
  828|      0|	ans = allocVector(REALSXP, n);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	ans = allocVector(REALSXP, n);
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  829|  1.02k|    else
  830|  1.02k|	ans = R_allocOrReuseVector(s1, s2, INTSXP, n);
  ------------------
  |  |  123|  1.02k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  831|  1.02k|    if (n == 0) return(ans);
  ------------------
  |  Branch (831:9): [True: 0, False: 1.02k]
  ------------------
  832|  1.02k|    PROTECT(ans);
  ------------------
  |  |  357|  1.02k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  833|       |
  834|  1.02k|    switch (code) {
  ------------------
  |  Branch (834:13): [True: 1.02k, False: 0]
  ------------------
  835|      2|    case PLUSOP:
  ------------------
  |  Branch (835:5): [True: 2, False: 1.01k]
  ------------------
  836|      2|	{
  837|      2|	    int *pa = INTEGER(ans);
  838|      2|	    const int *px1 = INTEGER_RO(s1);
  839|      2|	    const int *px2 = INTEGER_RO(s2);
  840|      2|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2, {
  ------------------
  |  |   92|      2|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      2|	i = i1 = i2 = 0;						\
  |  |   94|      2|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      2|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      2|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      2|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 2, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      2|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      2|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      2|		n : __intr_threshold__;					\
  |  |  |  |   38|      2|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      2|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      2|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      4|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 2, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      2|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      2|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      2|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      2|	    loop_body							\
  |  |  |  |  |  |  |  |   84|      2|		}							\
  |  |  |  |  |  |  |  |   85|      2|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      2|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      2|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      2|	}								\
  |  |  |  |   42|      2|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      2|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      2|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 2]
  |  |  ------------------
  ------------------
  841|      2|		    x1 = px1[i1];
  842|      2|		    x2 = px2[i2];
  843|      2|		    pa[i] = R_integer_plus(x1, x2, &naflag);
  844|      2|		});
  845|      2|	    if (naflag)
  ------------------
  |  Branch (845:10): [True: 0, False: 2]
  ------------------
  846|      0|		warningcall(lcall, INTEGER_OVERFLOW_WARNING);
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              		warningcall(lcall, INTEGER_OVERFLOW_WARNING);
  ------------------
  |  |  310|      0|#define INTEGER_OVERFLOW_WARNING _("NAs produced by integer overflow")
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  ------------------
  847|      2|	}
  848|      2|	break;
  849|     16|    case MINUSOP:
  ------------------
  |  Branch (849:5): [True: 16, False: 1.00k]
  ------------------
  850|     16|	{
  851|     16|	    int *pa = INTEGER(ans);
  852|     16|	    const int *px1 = INTEGER_RO(s1);
  853|     16|	    const int *px2 = INTEGER_RO(s2);
  854|     16|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2, {
  ------------------
  |  |   92|     16|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|     16|	i = i1 = i2 = 0;						\
  |  |   94|     16|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|     16|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|     16|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|     16|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 16, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|     16|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|     16|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 16, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|     16|		n : __intr_threshold__;					\
  |  |  |  |   38|     16|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|     16|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|     16|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|     32|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 16, False: 16]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|     16|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 16, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|     16|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 16, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|     16|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|     16|	    loop_body							\
  |  |  |  |  |  |  |  |   84|     16|		}							\
  |  |  |  |  |  |  |  |   85|     16|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 16]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|     16|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 16, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|     16|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|     16|	}								\
  |  |  |  |   42|     16|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 16]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|     16|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|     16|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 16]
  |  |  ------------------
  ------------------
  855|     16|		    x1 = px1[i1];
  856|     16|		    x2 = px2[i2];
  857|     16|		    pa[i] = R_integer_minus(x1, x2, &naflag);
  858|     16|		});
  859|     16|	    if (naflag)
  ------------------
  |  Branch (859:10): [True: 0, False: 16]
  ------------------
  860|      0|		warningcall(lcall, INTEGER_OVERFLOW_WARNING);
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              		warningcall(lcall, INTEGER_OVERFLOW_WARNING);
  ------------------
  |  |  310|      0|#define INTEGER_OVERFLOW_WARNING _("NAs produced by integer overflow")
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  ------------------
  861|     16|	}
  862|     16|	break;
  863|      0|    case TIMESOP:
  ------------------
  |  Branch (863:5): [True: 0, False: 1.02k]
  ------------------
  864|      0|	{
  865|      0|	    int *pa = INTEGER(ans);
  866|      0|	    const int *px1 = INTEGER_RO(s1);
  867|      0|	    const int *px2 = INTEGER_RO(s2);
  868|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2, {
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  869|      0|		    x1 = px1[i1];
  870|      0|		    x2 = px2[i2];
  871|      0|		    pa[i] = R_integer_times(x1, x2, &naflag);
  872|      0|		});
  873|      0|	    if (naflag)
  ------------------
  |  Branch (873:10): [True: 0, False: 0]
  ------------------
  874|      0|		warningcall(lcall, INTEGER_OVERFLOW_WARNING);
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              		warningcall(lcall, INTEGER_OVERFLOW_WARNING);
  ------------------
  |  |  310|      0|#define INTEGER_OVERFLOW_WARNING _("NAs produced by integer overflow")
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  ------------------
  875|      0|	}
  876|      0|	break;
  877|      0|    case DIVOP:
  ------------------
  |  Branch (877:5): [True: 0, False: 1.02k]
  ------------------
  878|      0|	{
  879|      0|	    double *pa = REAL(ans);
  880|      0|	    const int *px1 = INTEGER_RO(s1);
  881|      0|	    const int *px2 = INTEGER_RO(s2);
  882|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2, {
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  883|      0|		    x1 = px1[i1];
  884|      0|		    x2 = px2[i2];
  885|      0|		    pa[i] = R_integer_divide(x1, x2);
  886|      0|		});
  887|      0|	}
  888|      0|	break;
  889|      0|    case POWOP:
  ------------------
  |  Branch (889:5): [True: 0, False: 1.02k]
  ------------------
  890|      0|	{
  891|      0|	    double *pa = REAL(ans);
  892|      0|	    const int *px1 = INTEGER_RO(s1);
  893|      0|	    const int *px2 = INTEGER_RO(s2);
  894|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2, {
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  895|      0|		    if((x1 = px1[i1]) == 1 || (x2 = px2[i2]) == 0)
  896|      0|			pa[i] = 1.;
  897|      0|		    else if (x1 == NA_INTEGER || x2 == NA_INTEGER)
  898|      0|			pa[i] = NA_REAL;
  899|      0|		    else
  900|      0|			pa[i] = R_POW((double) x1, (double) x2);
  901|      0|		});
  902|      0|	}
  903|      0|	break;
  904|      0|    case MODOP:
  ------------------
  |  Branch (904:5): [True: 0, False: 1.02k]
  ------------------
  905|      0|	{
  906|      0|	    int *pa = INTEGER(ans);
  907|      0|	    const int *px1 = INTEGER_RO(s1);
  908|      0|	    const int *px2 = INTEGER_RO(s2);
  909|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2, {
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  910|      0|		    x1 = px1[i1];
  911|      0|		    x2 = px2[i2];
  912|      0|		    if (x1 == NA_INTEGER || x2 == NA_INTEGER || x2 == 0)
  913|      0|			pa[i] = NA_INTEGER;
  914|      0|		    else {
  915|      0|			pa[i] = /* till 0.63.2:	x1 % x2 */
  916|      0|			    (x1 >= 0 && x2 > 0) ? x1 % x2 :
  917|      0|			    (int)myfmod((double)x1,(double)x2);
  918|      0|		    }
  919|      0|		});
  920|      0|	}
  921|      0|	break;
  922|  1.00k|    case IDIVOP:
  ------------------
  |  Branch (922:5): [True: 1.00k, False: 18]
  ------------------
  923|  1.00k|	{
  924|  1.00k|	    int *pa = INTEGER(ans);
  925|  1.00k|	    const int *px1 = INTEGER_RO(s1);
  926|  1.00k|	    const int *px2 = INTEGER_RO(s2);
  927|  1.00k|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2, {
  ------------------
  |  |   92|  1.00k|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|  1.00k|	i = i1 = i2 = 0;						\
  |  |   94|  1.00k|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|  1.00k|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|  1.00k|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|  1.00k|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 1.00k, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|  1.00k|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|  1.00k|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 1.00k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|  1.00k|		n : __intr_threshold__;					\
  |  |  |  |   38|  1.00k|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|  1.00k|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|  1.00k|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|  2.00k|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 1.00k, False: 1.00k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|  1.00k|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 1.00k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|  1.00k|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 1.00k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|  1.00k|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|  6.01k|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 1.00k]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 1.00k]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 1.00k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|  1.00k|		}							\
  |  |  |  |  |  |  |  |   85|  1.00k|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 1.00k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|  1.00k|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 1.00k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|  1.00k|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|  1.00k|	}								\
  |  |  |  |   42|  1.00k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 1.00k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|  1.00k|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|  1.00k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 1.00k]
  |  |  ------------------
  ------------------
  928|  1.00k|		    x1 = px1[i1];
  929|  1.00k|		    x2 = px2[i2];
  930|       |		    /* This had x %/% 0 == 0 prior to 2.14.1, but
  931|       |		       it seems conventionally to be undefined */
  932|  1.00k|		    if (x1 == NA_INTEGER || x2 == NA_INTEGER || x2 == 0)
  933|  1.00k|			pa[i] = NA_INTEGER;
  934|  1.00k|		    else
  935|  1.00k|			pa[i] = (int) floor((double)x1 / (double)x2);
  936|  1.00k|		});
  937|  1.00k|	}
  938|  1.00k|	break;
  939|  1.02k|    }
  940|  1.02k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.02k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  941|       |
  942|       |    /* quick return if there are no attributes */
  943|  1.02k|    if (ATTRIB(s1) == R_NilValue && ATTRIB(s2) == R_NilValue)
  ------------------
  |  Branch (943:9): [True: 1.02k, False: 0]
  |  Branch (943:37): [True: 1.02k, False: 0]
  ------------------
  944|  1.02k|	return ans;
  945|       |
  946|       |    /* Copy attributes from longer argument. */
  947|       |
  948|      0|    if (ans != s2 && n == n2 && ATTRIB(s2) != R_NilValue)
  ------------------
  |  Branch (948:9): [True: 0, False: 0]
  |  Branch (948:22): [True: 0, False: 0]
  |  Branch (948:33): [True: 0, False: 0]
  ------------------
  949|      0|	copyMostAttrib(s2, ans);
  ------------------
  |  |  901|      0|#define copyMostAttrib		Rf_copyMostAttrib
  ------------------
  950|      0|    if (ans != s1 && n == n1 && ATTRIB(s1) != R_NilValue)
  ------------------
  |  Branch (950:9): [True: 0, False: 0]
  |  Branch (950:22): [True: 0, False: 0]
  |  Branch (950:33): [True: 0, False: 0]
  ------------------
  951|      0|	copyMostAttrib(s1, ans); /* Done 2nd so s1's attrs overwrite s2's */
  ------------------
  |  |  901|      0|#define copyMostAttrib		Rf_copyMostAttrib
  ------------------
  952|       |
  953|      0|    return ans;
  954|  1.02k|}
arithmetic.c:real_binary:
  959|  1.13k|{
  960|  1.13k|    R_xlen_t i, i1, i2, n, n1, n2;
  961|  1.13k|    SEXP ans;
  962|       |
  963|       |    /* Note: "s1" and "s2" are protected above. */
  964|  1.13k|    n1 = XLENGTH(s1);
  965|  1.13k|    n2 = XLENGTH(s2);
  966|       |
  967|       |    /* S4-compatibility change: if n1 or n2 is 0, result is of length 0 */
  968|  1.13k|    if (n1 == 0 || n2 == 0) return(allocVector(REALSXP, 0));
  ------------------
  |  |  875|     96|#define allocVector		Rf_allocVector
  ------------------
                  if (n1 == 0 || n2 == 0) return(allocVector(REALSXP, 0));
  ------------------
  |  |  124|     96|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (968:9): [True: 96, False: 1.03k]
  |  Branch (968:20): [True: 0, False: 1.03k]
  ------------------
  969|       |
  970|  1.03k|    n = (n1 > n2) ? n1 : n2;
  ------------------
  |  Branch (970:9): [True: 928, False: 107]
  ------------------
  971|  1.03k|    PROTECT(ans = R_allocOrReuseVector(s1, s2, REALSXP, n));
  ------------------
  |  |  357|  1.03k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  972|       |
  973|  1.03k|    switch (code) {
  ------------------
  |  Branch (973:13): [True: 1.03k, False: 0]
  ------------------
  974|      0|    case PLUSOP:
  ------------------
  |  Branch (974:5): [True: 0, False: 1.03k]
  ------------------
  975|      0|	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
              	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (975:5): [True: 0, False: 0]
  |  Branch (975:30): [True: 0, False: 0]
  ------------------
  976|      0|	    double *da = REAL(ans);
  977|      0|	    const double *dx = REAL_RO(s1);
  978|      0|	    const double *dy = REAL_RO(s2);
  979|      0|	    if (n2 == 1) {
  ------------------
  |  Branch (979:10): [True: 0, False: 0]
  ------------------
  980|      0|		double tmp = dy[0];
  981|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = dx[i] + tmp;);
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  982|      0|	    }
  983|      0|	    else if (n1 == 1) {
  ------------------
  |  Branch (983:15): [True: 0, False: 0]
  ------------------
  984|      0|		double tmp = dx[0];
  985|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = tmp + dy[i];);
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  986|      0|	    }
  987|      0|	    else if (n1 == n2)
  ------------------
  |  Branch (987:15): [True: 0, False: 0]
  ------------------
  988|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = dx[i] + dy[i];);
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  989|      0|	    else
  990|      0|		MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  991|      0|				  da[i] = dx[i1] + dy[i2];);
  992|      0|	}
  993|      0|	else if(TYPEOF(s1) == INTSXP ) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (993:10): [True: 0, False: 0]
  ------------------
  994|      0|	    double *da = REAL(ans);
  995|      0|	    const int *px1 = INTEGER_RO(s1);
  996|      0|	    const double *px2 = REAL_RO(s2);
  997|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  998|      0|			       da[i] = R_INTEGER(px1[i1]) + px2[i2];);
  999|      0|	}
 1000|      0|	else if(TYPEOF(s2) == INTSXP ) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1000:10): [True: 0, False: 0]
  ------------------
 1001|      0|	    double *da = REAL(ans);
 1002|      0|	    const double *px1 = REAL_RO(s1);
 1003|      0|	    const int *px2 = INTEGER_RO(s2);
 1004|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1005|      0|			       da[i] = px1[i1] + R_INTEGER(px2[i2]););
 1006|      0|	}
 1007|      0|	break;
 1008|     64|    case MINUSOP:
  ------------------
  |  Branch (1008:5): [True: 64, False: 971]
  ------------------
 1009|     64|	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|    128|#define REALSXP	    14	  /* real variables */
  ------------------
              	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1009:5): [True: 0, False: 64]
  |  Branch (1009:30): [True: 0, False: 0]
  ------------------
 1010|      0|	    double *da = REAL(ans);
 1011|      0|	    const double *dx = REAL_RO(s1);
 1012|      0|	    const double *dy = REAL_RO(s2);
 1013|      0|	    if (n2 == 1) {
  ------------------
  |  Branch (1013:10): [True: 0, False: 0]
  ------------------
 1014|      0|		double tmp = dy[0];
 1015|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = dx[i] - tmp;);
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1016|      0|	    }
 1017|      0|	    else if (n1 == 1) {
  ------------------
  |  Branch (1017:15): [True: 0, False: 0]
  ------------------
 1018|      0|		double tmp = dx[0];
 1019|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = tmp - dy[i];);
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1020|      0|	    }
 1021|      0|	    else if (n1 == n2)
  ------------------
  |  Branch (1021:15): [True: 0, False: 0]
  ------------------
 1022|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = dx[i] - dy[i];);
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1023|      0|	    else
 1024|      0|		MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1025|      0|				  da[i] = dx[i1] - dy[i2];);
 1026|      0|	}
 1027|     64|	else if(TYPEOF(s1) == INTSXP ) {
  ------------------
  |  |  123|     64|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1027:10): [True: 64, False: 0]
  ------------------
 1028|     64|	    double *da = REAL(ans);
 1029|     64|	    const int *px1 = INTEGER_RO(s1);
 1030|     64|	    const double *px2 = REAL_RO(s2);
 1031|     64|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|     64|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|     64|	i = i1 = i2 = 0;						\
  |  |   94|     64|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|     64|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|     64|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|     64|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 64, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|     64|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|     64|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 64, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|     64|		n : __intr_threshold__;					\
  |  |  |  |   38|     64|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|     64|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|     64|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|    320|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 256, False: 64]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|    256|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 64, False: 192]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|    256|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 256, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|    256|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|    512|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 256]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|    256|		}							\
  |  |  |  |  |  |  |  |   85|     64|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 64]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|     64|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 64, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|     64|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|     64|	}								\
  |  |  |  |   42|     64|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 64]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|     64|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|     64|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 64]
  |  |  ------------------
  ------------------
 1032|     64|			       da[i] = R_INTEGER(px1[i1]) - px2[i2];);
 1033|     64|	}
 1034|      0|	else if(TYPEOF(s2) == INTSXP ) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1034:10): [True: 0, False: 0]
  ------------------
 1035|      0|	    double *da = REAL(ans);
 1036|      0|	    const double *px1 = REAL_RO(s1);
 1037|      0|	    const int *px2 = INTEGER_RO(s2);
 1038|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1039|      0|			       da[i] = px1[i1] - R_INTEGER(px2[i2]););
 1040|      0|	}
 1041|     64|	break;
 1042|      0|    case TIMESOP:
  ------------------
  |  Branch (1042:5): [True: 0, False: 1.03k]
  ------------------
 1043|      0|	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
              	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1043:5): [True: 0, False: 0]
  |  Branch (1043:30): [True: 0, False: 0]
  ------------------
 1044|      0|	    double *da = REAL(ans);
 1045|      0|	    const double *dx = REAL_RO(s1);
 1046|      0|	    const double *dy = REAL_RO(s2);
 1047|      0|	    if (n2 == 1) {
  ------------------
  |  Branch (1047:10): [True: 0, False: 0]
  ------------------
 1048|      0|		double tmp = dy[0];
 1049|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = dx[i] * tmp;);
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1050|      0|	    }
 1051|      0|	    else if (n1 == 1) {
  ------------------
  |  Branch (1051:15): [True: 0, False: 0]
  ------------------
 1052|      0|		double tmp = dx[0];
 1053|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = tmp * dy[i];);
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1054|      0|	    }
 1055|      0|	    else if (n1 == n2)
  ------------------
  |  Branch (1055:15): [True: 0, False: 0]
  ------------------
 1056|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = dx[i] * dy[i];);
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1057|      0|	    else
 1058|      0|		MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1059|      0|				  da[i] = dx[i1] * dy[i2];);
 1060|      0|	}
 1061|      0|	else if(TYPEOF(s1) == INTSXP ) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1061:10): [True: 0, False: 0]
  ------------------
 1062|      0|	    double *da = REAL(ans);
 1063|      0|	    const int *px1 = INTEGER_RO(s1);
 1064|      0|	    const double *px2 = REAL_RO(s2);
 1065|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1066|      0|			       da[i] = R_INTEGER(px1[i1]) * px2[i2];);
 1067|      0|	}
 1068|      0|	else if(TYPEOF(s2) == INTSXP ) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1068:10): [True: 0, False: 0]
  ------------------
 1069|      0|	    double *da = REAL(ans);
 1070|      0|	    const double *px1 = REAL_RO(s1);
 1071|      0|	    const int *px2 = INTEGER_RO(s2);
 1072|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1073|      0|			       da[i] = px1[i1] * R_INTEGER(px2[i2]););
 1074|      0|	}
 1075|      0|	break;
 1076|      0|    case DIVOP:
  ------------------
  |  Branch (1076:5): [True: 0, False: 1.03k]
  ------------------
 1077|      0|	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
              	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1077:5): [True: 0, False: 0]
  |  Branch (1077:30): [True: 0, False: 0]
  ------------------
 1078|      0|	    double *da = REAL(ans);
 1079|      0|	    const double *dx = REAL_RO(s1);
 1080|      0|	    const double *dy = REAL_RO(s2);
 1081|      0|	    if (n2 == 1) {
  ------------------
  |  Branch (1081:10): [True: 0, False: 0]
  ------------------
 1082|      0|		double tmp = dy[0];
 1083|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = dx[i] / tmp;);
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1084|      0|	    }
 1085|      0|	    else if (n1 == 1) {
  ------------------
  |  Branch (1085:15): [True: 0, False: 0]
  ------------------
 1086|      0|		double tmp = dx[0];
 1087|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = tmp / dy[i];);
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1088|      0|	    }
 1089|      0|	    else if (n1 == n2)
  ------------------
  |  Branch (1089:15): [True: 0, False: 0]
  ------------------
 1090|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = dx[i] / dy[i];);
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1091|      0|	    else
 1092|      0|		MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1093|      0|				  da[i] = dx[i1] / dy[i2];);
 1094|      0|	}
 1095|      0|	else if(TYPEOF(s1) == INTSXP ) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1095:10): [True: 0, False: 0]
  ------------------
 1096|      0|	    double *da = REAL(ans);
 1097|      0|	    const int *px1 = INTEGER_RO(s1);
 1098|      0|	    const double *px2 = REAL_RO(s2);
 1099|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1100|      0|			       da[i] = R_INTEGER(px1[i1]) / px2[i2];);
 1101|      0|	}
 1102|      0|	else if(TYPEOF(s2) == INTSXP ) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1102:10): [True: 0, False: 0]
  ------------------
 1103|      0|	    double *da = REAL(ans);
 1104|      0|	    const double *px1 = REAL_RO(s1);
 1105|      0|	    const int *px2 = INTEGER_RO(s2);
 1106|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1107|      0|			       da[i] = px1[i1] / R_INTEGER(px2[i2]););
 1108|      0|	}
 1109|      0|	break;
 1110|     64|    case POWOP:
  ------------------
  |  Branch (1110:5): [True: 64, False: 971]
  ------------------
 1111|     64|	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|    128|#define REALSXP	    14	  /* real variables */
  ------------------
              	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|     64|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1111:5): [True: 64, False: 0]
  |  Branch (1111:30): [True: 64, False: 0]
  ------------------
 1112|     64|	    double *da = REAL(ans);
 1113|     64|	    const double *dx = REAL_RO(s1);
 1114|     64|	    const double *dy = REAL_RO(s2);
 1115|     64|	    if (n2 == 1) {
  ------------------
  |  Branch (1115:10): [True: 0, False: 64]
  ------------------
 1116|      0|		double tmp = dy[0];
 1117|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = R_POW(dx[i], tmp););
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1118|      0|	    }
 1119|     64|	    else if (n1 == 1) {
  ------------------
  |  Branch (1119:15): [True: 64, False: 0]
  ------------------
 1120|     64|		double tmp = dx[0];
 1121|     64|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = R_POW(tmp, dy[i]););
  ------------------
  |  |   53|     64|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|     64|	i = 0;								\
  |  |   55|     64|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|     64|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|     64|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|     64|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 64, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|     64|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|     64|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 64, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|     64|		n : __intr_threshold__;					\
  |  |  |  |   38|     64|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|     64|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|     64|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|    320|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 256, False: 64]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|     64|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 64]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|     64|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 64, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|     64|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|     64|	}								\
  |  |  |  |   42|     64|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 64]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|     64|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 64]
  |  |  ------------------
  ------------------
 1122|     64|	    }
 1123|      0|	    else if (n1 == n2)
  ------------------
  |  Branch (1123:15): [True: 0, False: 0]
  ------------------
 1124|      0|		R_ITERATE_CHECK(NINTERRUPT, n, i, da[i] = R_POW(dx[i], dy[i]););
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1125|      0|	    else
 1126|      0|		MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1127|     64|				  da[i] = R_POW(dx[i1], dy[i2]););
 1128|     64|	}
 1129|      0|	else if(TYPEOF(s1) == INTSXP ) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1129:10): [True: 0, False: 0]
  ------------------
 1130|      0|	    double *da = REAL(ans);
 1131|      0|	    const int *px1 = INTEGER_RO(s1);
 1132|      0|	    const double *px2 = REAL_RO(s2);
 1133|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1134|      0|			       da[i] = R_POW( R_INTEGER(px1[i1]), px2[i2]););
 1135|      0|	}
 1136|      0|	else if(TYPEOF(s2) == INTSXP ) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1136:10): [True: 0, False: 0]
  ------------------
 1137|      0|	    double *da = REAL(ans);
 1138|      0|	    const double *px1 = REAL_RO(s1);
 1139|      0|	    const int *px2 = INTEGER_RO(s2);
 1140|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1141|      0|			       da[i] = R_POW(px1[i1], R_INTEGER(px2[i2])););
 1142|      0|	}
 1143|     64|	break;
 1144|    907|    case MODOP:
  ------------------
  |  Branch (1144:5): [True: 907, False: 128]
  ------------------
 1145|    907|	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|  1.81k|#define REALSXP	    14	  /* real variables */
  ------------------
              	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|    907|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1145:5): [True: 907, False: 0]
  |  Branch (1145:30): [True: 907, False: 0]
  ------------------
 1146|    907|	    double *da = REAL(ans);
 1147|    907|	    const double *px1 = REAL_RO(s1);
 1148|    907|	    const double *px2 = REAL_RO(s2);
 1149|    907|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|    907|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|    907|	i = i1 = i2 = 0;						\
  |  |   94|    907|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|    907|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|    907|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|    907|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 907, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|    907|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|    907|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 907, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|    907|		n : __intr_threshold__;					\
  |  |  |  |   38|    907|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|    907|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|    907|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|   477k|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 476k, False: 907]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|   476k|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 907, False: 475k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|   476k|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 476k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|   476k|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|   476k|	    loop_body							\
  |  |  |  |  |  |  |  |   84|   476k|		}							\
  |  |  |  |  |  |  |  |   85|    907|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 907]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|    907|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 907, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|    907|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|    907|	}								\
  |  |  |  |   42|    907|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 907]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|    907|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|    907|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 907]
  |  |  ------------------
  ------------------
 1150|    907|			       da[i] = myfmod(px1[i1], px2[i2]););
 1151|    907|	}
 1152|      0|	else if(TYPEOF(s1) == INTSXP ) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1152:10): [True: 0, False: 0]
  ------------------
 1153|      0|	    double *da = REAL(ans);
 1154|      0|	    const int *px1 = INTEGER_RO(s1);
 1155|      0|	    const double *px2 = REAL_RO(s2);
 1156|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1157|      0|			       da[i] = myfmod(R_INTEGER(px1[i1]), px2[i2]););
 1158|      0|	}
 1159|      0|	else if(TYPEOF(s2) == INTSXP ) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1159:10): [True: 0, False: 0]
  ------------------
 1160|      0|	    double *da = REAL(ans);
 1161|      0|	    const double *px1 = REAL_RO(s1);
 1162|      0|	    const int *px2 = INTEGER_RO(s2);
 1163|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1164|      0|			       da[i] = myfmod(px1[i1], R_INTEGER(px2[i2])););
 1165|      0|	}
 1166|    907|	break;
 1167|      0|    case IDIVOP:
  ------------------
  |  Branch (1167:5): [True: 0, False: 1.03k]
  ------------------
 1168|      0|	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
              	if(TYPEOF(s1) == REALSXP && TYPEOF(s2) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1168:5): [True: 0, False: 0]
  |  Branch (1168:30): [True: 0, False: 0]
  ------------------
 1169|      0|	    double *da = REAL(ans);
 1170|      0|	    const double *px1 = REAL_RO(s1);
 1171|      0|	    const double *px2 = REAL_RO(s2);
 1172|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1173|      0|			       da[i] = myfloor(px1[i1], px2[i2]););
 1174|      0|	}
 1175|      0|	else if(TYPEOF(s1) == INTSXP ) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1175:10): [True: 0, False: 0]
  ------------------
 1176|      0|	    double *da = REAL(ans);
 1177|      0|	    const int *px1 = INTEGER_RO(s1);
 1178|      0|	    const double *px2 = REAL_RO(s2);
 1179|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1180|      0|			       da[i] = myfloor(R_INTEGER(px1[i1]), px2[i2]););
 1181|      0|	}
 1182|      0|	else if(TYPEOF(s2) == INTSXP ) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1182:10): [True: 0, False: 0]
  ------------------
 1183|      0|	    double *da = REAL(ans);
 1184|      0|	    const double *px1 = REAL_RO(s1);
 1185|      0|	    const int *px2 = INTEGER_RO(s2);
 1186|      0|	    MOD_ITERATE2_CHECK(NINTERRUPT, n, n1, n2, i, i1, i2,
  ------------------
  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |   96|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1187|      0|			       da[i] = myfloor(px1[i1], R_INTEGER(px2[i2])););
 1188|      0|	}
 1189|      0|	break;
 1190|  1.03k|    }
 1191|  1.03k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.03k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1192|       |
 1193|       |    /* quick return if there are no attributes */
 1194|  1.03k|    if (ATTRIB(s1) == R_NilValue && ATTRIB(s2) == R_NilValue)
  ------------------
  |  Branch (1194:9): [True: 1.03k, False: 0]
  |  Branch (1194:37): [True: 1.03k, False: 0]
  ------------------
 1195|  1.03k|	return ans;
 1196|       |
 1197|       |    /* Copy attributes from longer argument. */
 1198|       |
 1199|      0|    if (ans != s2 && n == n2 && ATTRIB(s2) != R_NilValue)
  ------------------
  |  Branch (1199:9): [True: 0, False: 0]
  |  Branch (1199:22): [True: 0, False: 0]
  |  Branch (1199:33): [True: 0, False: 0]
  ------------------
 1200|      0|	copyMostAttrib(s2, ans);
  ------------------
  |  |  901|      0|#define copyMostAttrib		Rf_copyMostAttrib
  ------------------
 1201|      0|    if (ans != s1 && n == n1 && ATTRIB(s1) != R_NilValue)
  ------------------
  |  Branch (1201:9): [True: 0, False: 0]
  |  Branch (1201:22): [True: 0, False: 0]
  |  Branch (1201:33): [True: 0, False: 0]
  ------------------
 1202|      0|	copyMostAttrib(s1, ans); /* Done 2nd so s1's attrs overwrite s2's */
  ------------------
  |  |  901|      0|#define copyMostAttrib		Rf_copyMostAttrib
  ------------------
 1203|       |
 1204|      0|    return ans;
 1205|  1.03k|}

arithmetic.c:R_POW:
   36|    256|{
   37|    256|    return y == 2.0 ? x * x : R_pow(x, y);
  ------------------
  |  Branch (37:12): [True: 64, False: 192]
  ------------------
   38|    256|}
arithmetic.c:R_allocOrReuseVector:
   67|  2.05k|{
   68|  2.05k|    R_xlen_t n1 = XLENGTH(s1);
   69|  2.05k|    R_xlen_t n2 = XLENGTH(s2);
   70|       |
   71|       |    /* Try to use space for 2nd arg if both same length, so 1st argument's
   72|       |       attributes will then take precedence when copied. */
   73|       |
   74|  2.05k|    if (n == n2) {
  ------------------
  |  Branch (74:9): [True: 1.12k, False: 928]
  ------------------
   75|  1.12k|        if (TYPEOF(s2) == type && NO_REFERENCES(s2)) {
  ------------------
  |  Branch (75:13): [True: 1.11k, False: 18]
  |  Branch (75:35): [True: 64, False: 1.04k]
  ------------------
   76|     64|	    if (ATTRIB(s2) != R_NilValue)
  ------------------
  |  Branch (76:10): [True: 0, False: 64]
  ------------------
   77|       |		/* need to remove 'names' attribute if present to
   78|       |		   match what copyMostAttrib does. copyMostAttrib()
   79|       |		   also skips 'dim' and 'dimnames' but those, here
   80|       |		   since those, if present, will be replaced by
   81|       |		   attribute cleanup code in R_Binary) */
   82|      0|		setAttrib(s2, R_NamesSymbol, R_NilValue);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
   83|     64|            return s2;
   84|     64|	}
   85|  1.06k|        else
   86|       |            /* Can use 1st arg's space only if 2nd arg has no attributes, else
   87|       |               we may not get attributes of result right. */
   88|  1.06k|            if (n == n1 && TYPEOF(s1) == type && NO_REFERENCES(s1)
  ------------------
  |  Branch (88:17): [True: 1.06k, False: 0]
  |  Branch (88:28): [True: 1.06k, False: 0]
  |  Branch (88:50): [True: 1.02k, False: 43]
  ------------------
   89|  1.02k|		&& ATTRIB(s2) == R_NilValue)
  ------------------
  |  Branch (89:6): [True: 1.02k, False: 0]
  ------------------
   90|  1.02k|                return s1;
   91|  1.12k|    }
   92|    928|    else if (n == n1 && TYPEOF(s1) == type && NO_REFERENCES(s1))
  ------------------
  |  Branch (92:14): [True: 928, False: 0]
  |  Branch (92:25): [True: 864, False: 64]
  |  Branch (92:47): [True: 0, False: 864]
  ------------------
   93|      0|	return s1;
   94|       |
   95|    971|    return allocVector(type, n);
  ------------------
  |  |  875|    971|#define allocVector		Rf_allocVector
  ------------------
   96|  2.05k|}

Rf_GetColNames:
   74|      8|{
   75|      8|    if (TYPEOF(dimnames) == VECSXP)
  ------------------
  |  |  131|      8|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (75:9): [True: 0, False: 8]
  ------------------
   76|      0|	return VECTOR_ELT(dimnames, 1);
   77|      8|    else
   78|      8|	return R_NilValue;
   79|      8|}
do_matrix:
   83|  1.02k|{
   84|  1.02k|    SEXP vals, ans, snr, snc, dimnames;
   85|  1.02k|    int nr = 1, nc = 1, byrow0, miss_nr, miss_nc;
   86|  1.02k|    R_xlen_t lendat;
   87|       |
   88|  1.02k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.02k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
   89|  1.02k|    vals = CAR(args); args = CDR(args);
   90|  1.02k|    if (!isVector(vals))
  ------------------
  |  |  974|  1.02k|#define isVector		Rf_isVector
  ------------------
  |  Branch (90:9): [True: 0, False: 1.02k]
  ------------------
   91|      0|	error(_("'data' must be of a vector type, was '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'data' must be of a vector type, was '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   92|      0|	    R_typeToChar(vals));
   93|  1.02k|    lendat = XLENGTH(vals);
   94|  1.02k|    snr = CAR(args); args = CDR(args);
   95|  1.02k|    snc = CAR(args); args = CDR(args);
   96|  1.02k|    byrow0 = asLogical(CAR(args)); args = CDR(args);
  ------------------
  |  |  886|  1.02k|#define asLogical		Rf_asLogical
  ------------------
   97|  1.02k|    if (byrow0 == NA_INTEGER)
  ------------------
  |  |   56|  1.02k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (97:9): [True: 0, False: 1.02k]
  ------------------
   98|      0|	error(_("invalid '%s' argument"), "byrow");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "byrow");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   99|  1.02k|    bool byrow = (bool) byrow0;
  100|  1.02k|    dimnames = CAR(args);
  101|  1.02k|    args = CDR(args);
  102|  1.02k|    miss_nr = asLogical(CAR(args)); args = CDR(args);
  ------------------
  |  |  886|  1.02k|#define asLogical		Rf_asLogical
  ------------------
  103|  1.02k|    miss_nc = asLogical(CAR(args));
  ------------------
  |  |  886|  1.02k|#define asLogical		Rf_asLogical
  ------------------
  104|       |
  105|  1.02k|    static int nowarn = -1;
  106|  1.02k|    if (nowarn == -1) {
  ------------------
  |  Branch (106:9): [True: 2, False: 1.02k]
  ------------------
  107|      2|	char *p = getenv("_R_CHECK_MATRIX_DATA_");
  108|      2|	nowarn = (p && StringTrue(p)) ? 1 : 0; // if(nowarn) <error>
  ------------------
  |  |   52|      0|#define StringTrue    Rf_StringTrue
  ------------------
  |  Branch (108:12): [True: 0, False: 2]
  |  Branch (108:17): [True: 0, False: 0]
  ------------------
  109|      2|    }
  110|  1.02k|    if (!miss_nr) {
  ------------------
  |  Branch (110:9): [True: 1.02k, False: 0]
  ------------------
  111|  1.02k|	if (!isNumeric(snr)) error(_("non-numeric matrix extent"));
  ------------------
  |  |  957|  1.02k|#define isNumeric		Rf_isNumeric
  ------------------
              	if (!isNumeric(snr)) error(_("non-numeric matrix extent"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if (!isNumeric(snr)) error(_("non-numeric matrix extent"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (111:6): [True: 0, False: 1.02k]
  ------------------
  112|  1.02k|	nr = asInteger(snr);
  ------------------
  |  |  885|  1.02k|#define asInteger		Rf_asInteger
  ------------------
  113|  1.02k|	if (nr == NA_INTEGER)
  ------------------
  |  |   56|  1.02k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (113:6): [True: 0, False: 1.02k]
  ------------------
  114|      0|	    error(_("invalid 'nrow' value (too large or NA)"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid 'nrow' value (too large or NA)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  115|  1.02k|	if (nr < 0)
  ------------------
  |  Branch (115:6): [True: 0, False: 1.02k]
  ------------------
  116|      0|	    error(_("invalid 'nrow' value (< 0)"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid 'nrow' value (< 0)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  117|  1.02k|    }
  118|  1.02k|    if (!miss_nc) {
  ------------------
  |  Branch (118:9): [True: 22, False: 1.00k]
  ------------------
  119|     22|	if (!isNumeric(snc)) error(_("non-numeric matrix extent"));
  ------------------
  |  |  957|     22|#define isNumeric		Rf_isNumeric
  ------------------
              	if (!isNumeric(snc)) error(_("non-numeric matrix extent"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if (!isNumeric(snc)) error(_("non-numeric matrix extent"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (119:6): [True: 0, False: 22]
  ------------------
  120|     22|	nc = asInteger(snc);
  ------------------
  |  |  885|     22|#define asInteger		Rf_asInteger
  ------------------
  121|     22|	if (nc == NA_INTEGER)
  ------------------
  |  |   56|     22|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (121:6): [True: 0, False: 22]
  ------------------
  122|      0|	    error(_("invalid 'ncol' value (too large or NA)"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid 'ncol' value (too large or NA)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  123|     22|	if (nc < 0)
  ------------------
  |  Branch (123:6): [True: 0, False: 22]
  ------------------
  124|      0|	    error(_("invalid 'ncol' value (< 0)"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid 'ncol' value (< 0)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  125|     22|    }
  126|  1.02k|    if (miss_nr && miss_nc) {
  ------------------
  |  Branch (126:9): [True: 0, False: 1.02k]
  |  Branch (126:20): [True: 0, False: 0]
  ------------------
  127|      0|	if (lendat > INT_MAX) error("data is too long");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (127:6): [True: 0, False: 0]
  ------------------
  128|      0|	nr = (int) lendat;
  129|  1.02k|    } else if (miss_nr) {
  ------------------
  |  Branch (129:16): [True: 0, False: 1.02k]
  ------------------
  130|      0|	if (lendat > (double) nc * INT_MAX) error("data is too long"); // incl lendat > nc == 0
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (130:6): [True: 0, False: 0]
  ------------------
  131|      0|	if (nc == 0) // as lendat <= nc, have lendat == 0
  ------------------
  |  Branch (131:6): [True: 0, False: 0]
  ------------------
  132|      0|	    nr = 0;
  133|      0|	else
  134|      0|	    nr = (int) ceil((double) lendat / (double) nc);
  135|  1.02k|    } else if (miss_nc) {
  ------------------
  |  Branch (135:16): [True: 1.00k, False: 22]
  ------------------
  136|  1.00k|	if (lendat > (double) nr * INT_MAX) error("data is too long"); // incl lendat > nr == 0
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (136:6): [True: 0, False: 1.00k]
  ------------------
  137|  1.00k|	if (nr == 0) // then lendat == 0
  ------------------
  |  Branch (137:6): [True: 0, False: 1.00k]
  ------------------
  138|      0|	    nc = 0;
  139|  1.00k|	else
  140|  1.00k|	    nc = (int) ceil((double) lendat / (double) nr);
  141|  1.00k|    }
  142|       |
  143|  1.02k|    if (lendat > 0) {
  ------------------
  |  Branch (143:9): [True: 1.02k, False: 0]
  ------------------
  144|  1.02k|	R_xlen_t nrc = (R_xlen_t) nr * nc;
  145|  1.02k|	if (lendat > 1 && (nrc % lendat) != 0) { // ==> nrc > 0
  ------------------
  |  Branch (145:6): [True: 1.00k, False: 22]
  |  Branch (145:20): [True: 0, False: 1.00k]
  ------------------
  146|      0|	    if (((lendat > nr) && (lendat / nr) * nr != lendat) ||
  ------------------
  |  Branch (146:11): [True: 0, False: 0]
  |  Branch (146:28): [True: 0, False: 0]
  ------------------
  147|      0|		((lendat < nr) && (nr / lendat) * lendat != nr))
  ------------------
  |  Branch (147:4): [True: 0, False: 0]
  |  Branch (147:21): [True: 0, False: 0]
  ------------------
  148|      0|		warning(_("data length [%lld] is not a sub-multiple or multiple of the number of rows [%d]"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		warning(_("data length [%lld] is not a sub-multiple or multiple of the number of rows [%d]"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  149|      0|			(long long)lendat, nr);
  150|      0|	    else if (((lendat > nc) && (lendat / nc) * nc != lendat) ||
  ------------------
  |  Branch (150:16): [True: 0, False: 0]
  |  Branch (150:33): [True: 0, False: 0]
  ------------------
  151|      0|		     ((lendat < nc) && (nc / lendat) * lendat != nc))
  ------------------
  |  Branch (151:9): [True: 0, False: 0]
  |  Branch (151:26): [True: 0, False: 0]
  ------------------
  152|      0|		warning(_("data length [%lld] is not a sub-multiple or multiple of the number of columns [%d]"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		warning(_("data length [%lld] is not a sub-multiple or multiple of the number of columns [%d]"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  153|      0|			(long long)lendat, nc);
  154|      0|	    else if (nrc != lendat) {
  ------------------
  |  Branch (154:15): [True: 0, False: 0]
  ------------------
  155|      0|		if(nowarn)
  ------------------
  |  Branch (155:6): [True: 0, False: 0]
  ------------------
  156|      0|		    error(_("data length differs from size of matrix: [%lld != %d x %d]"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("data length differs from size of matrix: [%lld != %d x %d]"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  157|      0|			  (long long)lendat, nr, nc);
  158|      0|		else
  159|      0|		    warning(_("data length differs from size of matrix: [%lld != %d x %d]"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		    warning(_("data length differs from size of matrix: [%lld != %d x %d]"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  160|      0|			    (long long)lendat, nr, nc);
  161|      0|	    }
  162|      0|	}
  163|  1.02k|	else if (lendat > 1 && nrc == 0) // for now *not* warning for e.g., matrix(NA, 0, 4)
  ------------------
  |  Branch (163:11): [True: 1.00k, False: 22]
  |  Branch (163:25): [True: 0, False: 1.00k]
  ------------------
  164|      0|	    warning(_("non-empty data for zero-extent matrix"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("non-empty data for zero-extent matrix"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  165|  1.02k|    }
  166|       |
  167|  1.02k|#ifdef LONG_VECTOR_SUPPORT
  168|  1.02k|    if ((double)nr * (double)nc > R_XLEN_T_MAX)
  ------------------
  |  |   76|  1.02k|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (168:9): [True: 0, False: 1.02k]
  ------------------
  169|      0|	error(_("too many elements specified"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("too many elements specified"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  170|       |#else
  171|       |    if ((double)nr * (double)nc > INT_MAX)
  172|       |	error(_("too many elements specified"));
  173|       |#endif
  174|       |
  175|  1.02k|    PROTECT(ans = allocMatrix(TYPEOF(vals), nr, nc));
  ------------------
  |  |  357|  1.02k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  176|  1.02k|    if(lendat)
  ------------------
  |  Branch (176:8): [True: 1.02k, False: 0]
  ------------------
  177|  1.02k|	copyMatrix(ans, vals, byrow);
  ------------------
  |  |  900|  1.02k|#define copyMatrix		Rf_copyMatrix
  ------------------
  178|      0|    else { /* fill with NAs */
  179|      0|	R_xlen_t N = (R_xlen_t) nr * nc, i;
  180|      0|	switch(TYPEOF(vals)) {
  181|      0|	case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (181:2): [True: 0, False: 0]
  ------------------
  182|      0|	    for (i = 0; i < N; i++)
  ------------------
  |  Branch (182:18): [True: 0, False: 0]
  ------------------
  183|      0|		SET_STRING_ELT(ans, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  184|      0|	    break;
  185|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (185:2): [True: 0, False: 0]
  ------------------
  186|      0|	    for (i = 0; i < N; i++)
  ------------------
  |  Branch (186:18): [True: 0, False: 0]
  ------------------
  187|      0|		LOGICAL(ans)[i] = NA_LOGICAL;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  188|      0|	    break;
  189|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (189:2): [True: 0, False: 0]
  ------------------
  190|      0|	    for (i = 0; i < N; i++)
  ------------------
  |  Branch (190:18): [True: 0, False: 0]
  ------------------
  191|      0|		INTEGER(ans)[i] = NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  192|      0|	    break;
  193|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (193:2): [True: 0, False: 0]
  ------------------
  194|      0|	    for (i = 0; i < N; i++)
  ------------------
  |  Branch (194:18): [True: 0, False: 0]
  ------------------
  195|      0|		REAL(ans)[i] = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  196|      0|	    break;
  197|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (197:2): [True: 0, False: 0]
  ------------------
  198|      0|	    {
  199|      0|		Rcomplex na_cmplx;
  200|      0|		na_cmplx.r = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  201|      0|		na_cmplx.i = 0;
  202|      0|		for (i = 0; i < N; i++)
  ------------------
  |  Branch (202:15): [True: 0, False: 0]
  ------------------
  203|      0|		    COMPLEX(ans)[i] = na_cmplx;
  204|      0|	    }
  205|      0|	    break;
  206|      0|	case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (206:2): [True: 0, False: 0]
  ------------------
  207|      0|	    if (N) memset(RAW(ans), 0, N);
  ------------------
  |  Branch (207:10): [True: 0, False: 0]
  ------------------
  208|      0|	    break;
  209|      0|	default:
  ------------------
  |  Branch (209:2): [True: 0, False: 0]
  ------------------
  210|       |	    /* don't fill with anything */
  211|      0|	    ;
  212|      0|	}
  213|      0|    }
  214|  1.02k|    if(!isNull(dimnames) && length(dimnames) > 0)
  ------------------
  |  |  956|  1.02k|#define isNull			Rf_isNull
  ------------------
                  if(!isNull(dimnames) && length(dimnames) > 0)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (214:8): [True: 0, False: 1.02k]
  |  Branch (214:29): [True: 0, False: 0]
  ------------------
  215|      0|	ans = dimnamesgets(ans, dimnames);
  ------------------
  |  |  907|      0|#define dimnamesgets		Rf_dimnamesgets
  ------------------
  216|  1.02k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.02k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  217|  1.02k|    return ans;
  218|  1.02k|}
Rf_allocMatrix:
  222|  1.04k|{
  223|  1.04k|    SEXP s, t;
  224|  1.04k|    R_xlen_t n;
  225|       |
  226|  1.04k|    if (nrow < 0 || ncol < 0)
  ------------------
  |  Branch (226:9): [True: 0, False: 1.04k]
  |  Branch (226:21): [True: 0, False: 1.04k]
  ------------------
  227|      0|	error(_("negative extents to matrix"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("negative extents to matrix"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  228|  1.04k|#ifdef LONG_VECTOR_SUPPORT
  229|  1.04k|    if ((double)nrow * (double)ncol > R_XLEN_T_MAX)
  ------------------
  |  |   76|  1.04k|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (229:9): [True: 0, False: 1.04k]
  ------------------
  230|      0|	error(_("allocMatrix: too many elements specified"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("allocMatrix: too many elements specified"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  231|       |#else
  232|       |    if ((double)nrow * (double)ncol > INT_MAX)
  233|       |	error(_("allocMatrix: too many elements specified"));
  234|       |#endif
  235|  1.04k|    n = ((R_xlen_t) nrow) * ncol;
  236|  1.04k|    PROTECT(s = allocVector(mode, n));
  ------------------
  |  |  357|  1.04k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  237|  1.04k|    PROTECT(t = allocVector(INTSXP, 2));
  ------------------
  |  |  357|  1.04k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  238|  1.04k|    INTEGER(t)[0] = nrow;
  239|  1.04k|    INTEGER(t)[1] = ncol;
  240|  1.04k|    setAttrib(s, R_DimSymbol, t);
  ------------------
  |  | 1027|  1.04k|#define setAttrib		Rf_setAttrib
  ------------------
  241|  1.04k|    UNPROTECT(2);
  ------------------
  |  |  358|  1.04k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  242|  1.04k|    return s;
  243|  1.04k|}
dim2total:
  283|  3.45k|{
  284|  3.45k|    int ndim = LENGTH(dim);
  285|  3.45k|    if (ndim == 0)
  ------------------
  |  Branch (285:9): [True: 0, False: 3.45k]
  ------------------
  286|      0|	error(_("'dim' cannot be of length 0"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'dim' cannot be of length 0"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  287|  3.45k|    *err = false;
  288|  3.45k|    double dn = 1.;
  289|  10.3k|    for (int i = 0; i < ndim; i++) {
  ------------------
  |  Branch (289:21): [True: 6.90k, False: 3.45k]
  ------------------
  290|  6.90k|        int d;
  291|       |
  292|  6.90k|	d = INTEGER(dim)[i];
  293|       |	/* dn *= d can overflow, but the result is 0 if any dimension is
  294|       |	 * (unless NA, so we can't simply break here).
  295|       |	 */
  296|  6.90k|        if (d == 0)
  ------------------
  |  Branch (296:13): [True: 30, False: 6.87k]
  ------------------
  297|     30|            dn = 0.0;
  298|       |       /* Actually, NA_INTEGER is < 0, so we don't need to test for it
  299|       |           explicitly, but the value might change, so better be safe... 
  300|       |           An optimizing compiler will likely strip the && part.
  301|       |         */
  302|  6.90k|	if (d >= 0 && d != NA_INTEGER) {
  ------------------
  |  |   56|  6.90k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (302:6): [True: 6.90k, False: 0]
  |  Branch (302:16): [True: 6.90k, False: 0]
  ------------------
  303|  6.90k|            dn *= d;
  304|       |	// Better to check for total here to avoid f/p overflow.
  305|  6.90k|        } else {
  306|      0|            if (d == NA_INTEGER)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (306:17): [True: 0, False: 0]
  ------------------
  307|      0|	        error(_("the dims contain missing values"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	        error(_("the dims contain missing values"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  308|      0|            else
  309|      0|	        error(_("the dims contain negative values"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	        error(_("the dims contain negative values"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  310|      0|        }
  311|  6.90k|    }
  312|  3.45k|#ifdef LONG_VECTOR_SUPPORT
  313|  3.45k|    if (dn > R_XLEN_T_MAX)
  ------------------
  |  |   76|  3.45k|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (313:9): [True: 0, False: 3.45k]
  ------------------
  314|       |#else
  315|       |    if (dn > INT_MAX)
  316|       |#endif
  317|      0|	*err = true; // and callers should not use the return value.
  318|  3.45k|    return (R_xlen_t) dn;
  319|  3.45k|}
Rf_DropDims:
  341|  2.37k|{
  342|  2.37k|    PROTECT(x);
  ------------------
  |  |  357|  2.37k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  343|  2.37k|    SEXP dims = getAttrib(x, R_DimSymbol);
  ------------------
  |  |  924|  2.37k|#define getAttrib		Rf_getAttrib
  ------------------
  344|       |
  345|       |    /* Check that dropping will actually do something. */
  346|       |    /* (1) Check that there is a "dim" attribute. */
  347|       |
  348|  2.37k|    if (dims == R_NilValue) {
  ------------------
  |  Branch (348:9): [True: 0, False: 2.37k]
  ------------------
  349|      0|	UNPROTECT(1); /* x */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  350|      0|	return x;
  351|      0|    }
  352|       |
  353|  2.37k|    int ndims = LENGTH(dims);
  354|  2.37k|    int *dim = INTEGER(dims); // used several times
  355|       |
  356|       |    /* (2) Check whether there are redundant extents */
  357|  2.37k|    int i, n = 0;
  358|  7.11k|    for (i = 0; i < ndims; i++)
  ------------------
  |  Branch (358:17): [True: 4.74k, False: 2.37k]
  ------------------
  359|  4.74k|	if (dim[i] != 1) n++;
  ------------------
  |  Branch (359:6): [True: 76, False: 4.66k]
  ------------------
  360|  2.37k|    if (n == ndims) {
  ------------------
  |  Branch (360:9): [True: 0, False: 2.37k]
  ------------------
  361|      0|	UNPROTECT(1); /* x */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  362|      0|	return x;
  363|      0|    }
  364|       |
  365|  2.37k|    SEXP dimnames = PROTECT(getAttrib(x, R_DimNamesSymbol)),
  ------------------
  |  |  357|  2.37k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  366|  2.37k|	newnames = R_NilValue;
  367|  2.37k|    if (n <= 1) {
  ------------------
  |  Branch (367:9): [True: 2.37k, False: 0]
  ------------------
  368|       |	/* We have reduced to a vector result.
  369|       |	   If that has length one, it is ambiguous which dimnames to use,
  370|       |	   so use it if there is only one (as from R 2.7.0).
  371|       |	 */
  372|  2.37k|	if (dimnames != R_NilValue) {
  ------------------
  |  Branch (372:6): [True: 2.33k, False: 40]
  ------------------
  373|  2.33k|	    if(XLENGTH(x) != 1) {
  ------------------
  |  Branch (373:9): [True: 36, False: 2.29k]
  ------------------
  374|     36|		for (i = 0; i < LENGTH(dims); i++) {
  ------------------
  |  Branch (374:15): [True: 36, False: 0]
  ------------------
  375|     36|		    if (dim[i] != 1) {
  ------------------
  |  Branch (375:11): [True: 36, False: 0]
  ------------------
  376|     36|			newnames = VECTOR_ELT(dimnames, i);
  377|     36|			break;
  378|     36|		    }
  379|     36|		}
  380|  2.29k|	    } else { /* drop all dims: keep names if unambiguous */
  381|  2.29k|		int cnt;
  382|  6.88k|		for(i = 0, cnt = 0; i < LENGTH(dims); i++)
  ------------------
  |  Branch (382:23): [True: 4.59k, False: 2.29k]
  ------------------
  383|  4.59k|		    if(VECTOR_ELT(dimnames, i) != R_NilValue) cnt++;
  ------------------
  |  Branch (383:10): [True: 2.29k, False: 2.29k]
  ------------------
  384|  2.29k|		if(cnt == 1)
  ------------------
  |  Branch (384:6): [True: 2.29k, False: 0]
  ------------------
  385|  4.59k|		    for (i = 0; i < LENGTH(dims); i++) {
  ------------------
  |  Branch (385:19): [True: 4.59k, False: 0]
  ------------------
  386|  4.59k|			newnames = VECTOR_ELT(dimnames, i);
  387|  4.59k|			if(newnames != R_NilValue) break;
  ------------------
  |  Branch (387:7): [True: 2.29k, False: 2.29k]
  ------------------
  388|  4.59k|		    }
  389|  2.29k|	    }
  390|  2.33k|	}
  391|  2.37k|	PROTECT(newnames);
  ------------------
  |  |  357|  2.37k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  392|  2.37k|	setAttrib(x, R_DimNamesSymbol, R_NilValue);
  ------------------
  |  | 1027|  2.37k|#define setAttrib		Rf_setAttrib
  ------------------
  393|  2.37k|	setAttrib(x, R_DimSymbol, R_NilValue);
  ------------------
  |  | 1027|  2.37k|#define setAttrib		Rf_setAttrib
  ------------------
  394|  2.37k|	setAttrib(x, R_NamesSymbol, newnames);
  ------------------
  |  | 1027|  2.37k|#define setAttrib		Rf_setAttrib
  ------------------
  395|       |	/* FIXME: the following is desirable, but pointless as long as
  396|       |	   subset.c & others have a contrary version that leaves the
  397|       |	   S4 class in, incorrectly, in the case of vectors.  JMC
  398|       |	   3/3/09 */
  399|       |/*	if(IS_S4_OBJECT(x)) {/\* no longer valid subclass of array or
  400|       |	matrix *\/ */
  401|       |/*	    setAttrib(x, R_ClassSymbol, R_NilValue); */
  402|       |/*	    UNSET_S4_OBJECT(x); */
  403|       |/*	} */
  404|  2.37k|	UNPROTECT(1); /* newnames */
  ------------------
  |  |  358|  2.37k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  405|  2.37k|    } else {
  406|       |	// We have a lower dimensional array, and  n == length(newdims)
  407|      0|	SEXP newdims, dnn, newnamesnames = R_NilValue;
  408|      0|	PROTECT(dnn = getAttrib(dimnames, R_NamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  409|      0|	PROTECT(newdims = allocVector(INTSXP, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  410|      0|	for (i = 0, n = 0; i < ndims; i++)
  ------------------
  |  Branch (410:21): [True: 0, False: 0]
  ------------------
  411|      0|	    if (dim[i] != 1)
  ------------------
  |  Branch (411:10): [True: 0, False: 0]
  ------------------
  412|      0|		INTEGER(newdims)[n++] = dim[i];
  413|      0|	if(!isNull(getAttrib(dims, R_NamesSymbol))) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
              	if(!isNull(getAttrib(dims, R_NamesSymbol))) {
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (413:5): [True: 0, False: 0]
  ------------------
  414|      0|	    SEXP new_nms = PROTECT(allocVector(STRSXP, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  415|      0|	    SEXP nms_d = getAttrib(dims, R_NamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  416|      0|	    for (i = 0, n = 0; i < ndims; i++)
  ------------------
  |  Branch (416:25): [True: 0, False: 0]
  ------------------
  417|      0|		if (dim[i] != 1)
  ------------------
  |  Branch (417:7): [True: 0, False: 0]
  ------------------
  418|      0|		    SET_STRING_ELT(new_nms, n++, STRING_ELT(nms_d, i));
  419|      0|	    setAttrib(newdims, R_NamesSymbol, new_nms);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  420|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  421|      0|	}
  422|      0|	bool havenames = false;
  423|      0|	if (!isNull(dimnames)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (423:6): [True: 0, False: 0]
  ------------------
  424|      0|	    for (i = 0; i < ndims; i++)
  ------------------
  |  Branch (424:18): [True: 0, False: 0]
  ------------------
  425|      0|		if (dim[i] != 1 &&
  ------------------
  |  Branch (425:7): [True: 0, False: 0]
  ------------------
  426|      0|		    VECTOR_ELT(dimnames, i) != R_NilValue)
  ------------------
  |  Branch (426:7): [True: 0, False: 0]
  ------------------
  427|      0|		    havenames = true;
  428|      0|	    if (havenames) {
  ------------------
  |  Branch (428:10): [True: 0, False: 0]
  ------------------
  429|      0|		PROTECT(newnames = allocVector(VECSXP, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  430|      0|		PROTECT(newnamesnames = allocVector(STRSXP, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  431|      0|		for (i = 0, n = 0; i < ndims; i++) {
  ------------------
  |  Branch (431:22): [True: 0, False: 0]
  ------------------
  432|      0|		    if (dim[i] != 1) {
  ------------------
  |  Branch (432:11): [True: 0, False: 0]
  ------------------
  433|      0|			if(!isNull(dnn))
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (433:7): [True: 0, False: 0]
  ------------------
  434|      0|			    SET_STRING_ELT(newnamesnames, n,
  435|      0|					   STRING_ELT(dnn, i));
  436|      0|			SET_VECTOR_ELT(newnames, n++, VECTOR_ELT(dimnames, i));
  437|      0|		    }
  438|      0|		}
  439|      0|	    }
  440|      0|	    else dimnames = R_NilValue;
  441|      0|	}
  442|      0|	setAttrib(x, R_DimNamesSymbol, R_NilValue);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  443|      0|	setAttrib(x, R_DimSymbol, newdims);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  444|      0|	if (havenames)
  ------------------
  |  Branch (444:6): [True: 0, False: 0]
  ------------------
  445|      0|	{
  446|      0|	    if(!isNull(dnn))
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (446:9): [True: 0, False: 0]
  ------------------
  447|      0|		setAttrib(newnames, R_NamesSymbol, newnamesnames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  448|      0|	    setAttrib(x, R_DimNamesSymbol, newnames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  449|      0|	    UNPROTECT(2); /* newnamesnames, newnames */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  450|      0|	}
  451|      0|	UNPROTECT(2); /* newdims, dnn */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  452|      0|    }
  453|  2.37k|    UNPROTECT(2); /* dimnames, x */
  ------------------
  |  |  358|  2.37k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  454|  2.37k|    return x;
  455|  2.37k|}
do_length:
  480|  1.93M|{
  481|  1.93M|    checkArity(op, args);
  ------------------
  |  | 1788|  1.93M|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  482|  1.93M|    check1arg(args, call, "x");
  ------------------
  |  | 1867|  1.93M|# define check1arg		Rf_check1arg
  ------------------
  483|       |
  484|  1.93M|    SEXP x = CAR(args), ans;
  485|       |
  486|       |    /* DispatchOrEval internal generic: length */
  487|  1.93M|    if (isObject(x) &&
  ------------------
  |  |  959|  1.93M|#define isObject		Rf_isObject
  ------------------
  |  Branch (487:9): [True: 20, False: 1.93M]
  ------------------
  488|     20|       DispatchOrEval(call, op, "length", args, rho, &ans, 0, 1)) {
  ------------------
  |  | 1887|     20|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (488:8): [True: 0, False: 20]
  ------------------
  489|      0|	if (length(ans) == 1 && TYPEOF(ans) == REALSXP) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
              	if (length(ans) == 1 && TYPEOF(ans) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (489:6): [True: 0, False: 0]
  |  Branch (489:26): [True: 0, False: 0]
  ------------------
  490|      0|	    double d = REAL(ans)[0];
  491|      0|	    if (R_FINITE(d) && d >= 0. && d <= INT_MAX && floor(d) == d) {
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (491:10): [True: 0, False: 0]
  |  Branch (491:25): [True: 0, False: 0]
  |  Branch (491:36): [True: 0, False: 0]
  |  Branch (491:52): [True: 0, False: 0]
  ------------------
  492|      0|                PROTECT(ans);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  493|      0|                ans = coerceVector(ans, INTSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
                              ans = coerceVector(ans, INTSXP);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  494|      0|                UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  495|      0|                return(ans);
  496|      0|            }
  497|      0|	}
  498|      0|	return(ans);
  499|      0|    }
  500|       |
  501|       |
  502|  1.93M|#ifdef LONG_VECTOR_SUPPORT
  503|       |    // or use IS_LONG_VEC
  504|  1.93M|    R_xlen_t len = xlength(x);
  ------------------
  |  | 1049|  1.93M|#define xlength(x)		Rf_xlength(x)
  ------------------
  505|  1.93M|    if (len > INT_MAX) return ScalarReal((double) len);
  ------------------
  |  | 1024|      0|#define ScalarReal		Rf_ScalarReal
  ------------------
  |  Branch (505:9): [True: 0, False: 1.93M]
  ------------------
  506|  1.93M|#endif
  507|  1.93M|    return ScalarInteger(length(x));
  ------------------
  |  | 1022|  1.93M|#define ScalarInteger		Rf_ScalarInteger
  ------------------
                  return ScalarInteger(length(x));
  ------------------
  |  |  987|  1.93M|#define length(x)		Rf_length(x)
  ------------------
  508|  1.93M|}
dispatch_xlength:
  518|  3.15k|attribute_hidden R_xlen_t dispatch_xlength(SEXP x, SEXP call, SEXP rho) {
  519|  3.15k|    static SEXP length_op = NULL;
  520|  3.15k|    if (isObject(x)) {
  ------------------
  |  |  959|  3.15k|#define isObject		Rf_isObject
  ------------------
  |  Branch (520:9): [True: 0, False: 3.15k]
  ------------------
  521|      0|        SEXP len, args;
  522|      0|        if (length_op == NULL)
  ------------------
  |  Branch (522:13): [True: 0, False: 0]
  ------------------
  523|      0|            length_op = R_Primitive("length");
  524|      0|        PROTECT(args = list1(x));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  525|       |	/* DispatchOrEval internal generic: length */
  526|      0|        if (DispatchOrEval(call, length_op, "length", args, rho, &len, 0, 1)) {
  ------------------
  |  | 1887|      0|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (526:13): [True: 0, False: 0]
  ------------------
  527|      0|            UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  528|      0|            return (R_xlen_t)
  529|      0|                (TYPEOF(len) == REALSXP ? REAL(len)[0] : asInteger(len));
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
                              (TYPEOF(len) == REALSXP ? REAL(len)[0] : asInteger(len));
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
  |  Branch (529:18): [True: 0, False: 0]
  ------------------
  530|      0|        }
  531|      0|        UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  532|      0|    }
  533|  3.15k|    return(xlength(x));
  ------------------
  |  | 1049|  3.15k|#define xlength(x)		Rf_xlength(x)
  ------------------
  534|  3.15k|}
do_lengths:
  564|     42|{
  565|     42|    checkArity(op, args);
  ------------------
  |  | 1788|     42|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  566|     42|    SEXP x = CAR(args), ans;
  567|     42|    R_xlen_t x_len, i;
  568|     42|    int *ans_elt;
  569|     42|    int useNames = asLogical(CADR(args));
  ------------------
  |  |  886|     42|#define asLogical		Rf_asLogical
  ------------------
  570|     42|    if (useNames == NA_LOGICAL)
  ------------------
  |  |   55|     42|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (570:9): [True: 0, False: 42]
  ------------------
  571|      0|	error(_("invalid '%s' value"), "use.names");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' value"), "use.names");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  572|       |
  573|       |    /* DispatchOrEval internal generic: lengths */
  574|     42|    if (DispatchOrEval(call, op, "lengths", args, rho, &ans, 0, 1))
  ------------------
  |  | 1887|     42|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (574:9): [True: 0, False: 42]
  ------------------
  575|      0|      return(ans);
  576|       |
  577|     42|    bool isList = isVectorList(x) || isS4(x);
  ------------------
  |  |  977|     42|#define isVectorList		Rf_isVectorList
  ------------------
                  bool isList = isVectorList(x) || isS4(x);
  ------------------
  |  |  964|      0|#define isS4			Rf_isS4
  ------------------
  |  Branch (577:19): [True: 42, False: 0]
  |  Branch (577:38): [True: 0, False: 0]
  ------------------
  578|     42|    if(!isList) switch(TYPEOF(x)) {
  ------------------
  |  |  951|     42|#define isList			Rf_isList
  ------------------
  |  Branch (578:8): [True: 0, False: 42]
  ------------------
  579|      0|	case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (579:2): [True: 0, False: 0]
  ------------------
  580|      0|	case CHARSXP:
  ------------------
  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (580:2): [True: 0, False: 0]
  ------------------
  581|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (581:2): [True: 0, False: 0]
  ------------------
  582|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (582:2): [True: 0, False: 0]
  ------------------
  583|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (583:2): [True: 0, False: 0]
  ------------------
  584|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (584:2): [True: 0, False: 0]
  ------------------
  585|      0|	case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (585:2): [True: 0, False: 0]
  ------------------
  586|      0|	case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (586:2): [True: 0, False: 0]
  ------------------
  587|      0|	    break;
  588|      0|	default:
  ------------------
  |  Branch (588:2): [True: 0, False: 0]
  ------------------
  589|      0|	    error(_("'%s' must be a list or atomic vector"), "x");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("'%s' must be a list or atomic vector"), "x");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  590|      0|    }
  591|     42|    x_len = dispatch_xlength(x, call, rho);
  592|     42|    PROTECT(ans = allocVector(INTSXP, x_len));
  ------------------
  |  |  357|     42|#define PROTECT(s)	Rf_protect(s)
  ------------------
  593|     42|    if(isList) {
  ------------------
  |  |  951|     42|#define isList			Rf_isList
  |  |  ------------------
  |  |  |  Branch (951:18): [True: 42, False: 0]
  |  |  ------------------
  ------------------
  594|  3.15k|	for (i = 0, ans_elt = INTEGER(ans); i < x_len; i++, ans_elt++) {
  ------------------
  |  Branch (594:38): [True: 3.11k, False: 42]
  ------------------
  595|  3.11k|	    R_xlen_t x_elt_len = getElementLength(x, i, call, rho);
  596|  3.11k|#ifdef LONG_VECTOR_SUPPORT
  597|  3.11k|	    if (x_elt_len > INT_MAX) {
  ------------------
  |  Branch (597:10): [True: 0, False: 3.11k]
  ------------------
  598|      0|		ans = do_lengths_long(x, call, rho);
  599|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  600|      0|		PROTECT(ans);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  601|      0|		break;
  602|      0|	    }
  603|  3.11k|#endif
  604|  3.11k|	    *ans_elt = (int)x_elt_len;
  605|  3.11k|	}
  606|     42|    } else { // atomic: every element has length 1
  607|      0|	for (i = 0, ans_elt = INTEGER(ans); i < x_len; i++, ans_elt++)
  ------------------
  |  Branch (607:38): [True: 0, False: 0]
  ------------------
  608|      0|	    *ans_elt = 1;
  609|      0|    }
  610|     42|    SEXP dim = getAttrib(x, R_DimSymbol);
  ------------------
  |  |  924|     42|#define getAttrib		Rf_getAttrib
  ------------------
  611|     42|    if(!isNull(dim)) {
  ------------------
  |  |  956|     42|#define isNull			Rf_isNull
  ------------------
  |  Branch (611:8): [True: 0, False: 42]
  ------------------
  612|      0|        setAttrib(ans, R_DimSymbol, dim);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  613|      0|    }
  614|     42|    if(useNames) {
  ------------------
  |  Branch (614:8): [True: 42, False: 0]
  ------------------
  615|     42|	SEXP names = getAttrib(x, R_NamesSymbol);
  ------------------
  |  |  924|     42|#define getAttrib		Rf_getAttrib
  ------------------
  616|     42|	if(!isNull(names)) setAttrib(ans, R_NamesSymbol, names);
  ------------------
  |  |  956|     42|#define isNull			Rf_isNull
  ------------------
              	if(!isNull(names)) setAttrib(ans, R_NamesSymbol, names);
  ------------------
  |  | 1027|     40|#define setAttrib		Rf_setAttrib
  ------------------
  |  Branch (616:5): [True: 40, False: 2]
  ------------------
  617|     42|        SEXP dimnames = getAttrib(x, R_DimNamesSymbol);
  ------------------
  |  |  924|     42|#define getAttrib		Rf_getAttrib
  ------------------
  618|     42|        if(!isNull(dimnames)) setAttrib(ans, R_DimNamesSymbol, dimnames);
  ------------------
  |  |  956|     42|#define isNull			Rf_isNull
  ------------------
                      if(!isNull(dimnames)) setAttrib(ans, R_DimNamesSymbol, dimnames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  |  Branch (618:12): [True: 0, False: 42]
  ------------------
  619|     42|    }
  620|     42|    UNPROTECT(1);
  ------------------
  |  |  358|     42|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  621|     42|    return ans;
  622|     42|}
array.c:getElementLength:
  537|  3.11k|static R_xlen_t getElementLength(SEXP x, R_xlen_t i, SEXP call, SEXP rho) {
  538|  3.11k|    SEXP x_elt;
  539|  3.11k|    R_xlen_t ans;
  540|       |
  541|  3.11k|    PROTECT(x_elt = dispatch_subset2(x, i, call, rho));
  ------------------
  |  |  357|  3.11k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  542|  3.11k|    ans = dispatch_xlength(x_elt, call, rho);
  543|  3.11k|    UNPROTECT(1); /* x_elt */
  ------------------
  |  |  358|  3.11k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  544|  3.11k|    return ans;
  545|  3.11k|}

getAttrib0:
  130|  15.5M|{
  131|  15.5M|    SEXP s;
  132|  15.5M|    if (name == R_NamesSymbol) {
  ------------------
  |  Branch (132:9): [True: 6.57M, False: 8.93M]
  ------------------
  133|  6.57M|	if(isOneDimensionalArray(vec)) {
  ------------------
  |  Branch (133:5): [True: 0, False: 6.57M]
  ------------------
  134|      0|	    s = getAttrib(vec, R_DimNamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  135|      0|	    if(!isNull(s)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (135:9): [True: 0, False: 0]
  ------------------
  136|      0|		MARK_NOT_MUTABLE(VECTOR_ELT(s, 0));
  137|      0|		return VECTOR_ELT(s, 0);
  138|      0|	    }
  139|      0|	}
  140|  6.57M|	if (isList(vec) || isLanguage(vec) || TYPEOF(vec) == DOTSXP) {
  ------------------
  |  |  951|  6.57M|#define isList			Rf_isList
  ------------------
              	if (isList(vec) || isLanguage(vec) || TYPEOF(vec) == DOTSXP) {
  ------------------
  |  |  950|  6.57M|#define isLanguage		Rf_isLanguage
  ------------------
              	if (isList(vec) || isLanguage(vec) || TYPEOF(vec) == DOTSXP) {
  ------------------
  |  |  127|  6.57M|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (140:6): [True: 45, False: 6.57M]
  |  Branch (140:21): [True: 550, False: 6.57M]
  |  Branch (140:40): [True: 0, False: 6.57M]
  ------------------
  141|    595|	    int len = length(vec);
  ------------------
  |  |  987|    595|#define length(x)		Rf_length(x)
  ------------------
  142|    595|	    PROTECT(s = allocVector(STRSXP, len));
  ------------------
  |  |  357|    595|#define PROTECT(s)	Rf_protect(s)
  ------------------
  143|    595|	    int i = 0;
  144|    595|	    bool any = false;
  145|  2.65k|	    for ( ; vec != R_NilValue; vec = CDR(vec), i++) {
  ------------------
  |  Branch (145:14): [True: 2.06k, False: 595]
  ------------------
  146|  2.06k|		if (TAG(vec) == R_NilValue)
  ------------------
  |  Branch (146:7): [True: 1.47k, False: 588]
  ------------------
  147|  1.47k|		{
  148|  1.47k|		    SET_STRING_ELT(s, i, R_BlankString);
  149|  1.47k|		}
  150|    588|		else if (isSymbol(TAG(vec))) {
  ------------------
  |  |  953|    588|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (150:12): [True: 588, False: 0]
  ------------------
  151|    588|		    any = TRUE;
  152|    588|		    SET_STRING_ELT(s, i, PRINTNAME(TAG(vec)));
  153|    588|		}
  154|      0|		else
  155|      0|		    error(_("getAttrib: invalid type (%s) for TAG"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("getAttrib: invalid type (%s) for TAG"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  156|      0|			  R_typeToChar(TAG(vec)));
  157|  2.06k|	    }
  158|    595|	    UNPROTECT(1);
  ------------------
  |  |  358|    595|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  159|    595|	    if (any) {
  ------------------
  |  Branch (159:10): [True: 133, False: 462]
  ------------------
  160|    133|		if (!isNull(s)) MARK_NOT_MUTABLE(s);
  ------------------
  |  |  956|    133|#define isNull			Rf_isNull
  ------------------
  |  Branch (160:7): [True: 133, False: 0]
  ------------------
  161|    133|		return (s);
  162|    133|	    } else
  163|    462|		return R_NilValue;
  164|    595|	}
  165|  6.57M|    }
  166|  24.8M|    for (s = ATTRIB(vec); s != R_NilValue; s = CDR(s))
  ------------------
  |  Branch (166:27): [True: 17.4M, False: 7.35M]
  ------------------
  167|  17.4M|	if (TAG(s) == name) {
  ------------------
  |  Branch (167:6): [True: 8.15M, False: 9.31M]
  ------------------
  168|  8.15M|	    if (name == R_DimNamesSymbol && TYPEOF(CAR(s)) == LISTSXP)
  ------------------
  |  |  113|  4.69k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (168:10): [True: 4.69k, False: 8.14M]
  |  Branch (168:38): [True: 0, False: 4.69k]
  ------------------
  169|      0|		error("old list is no longer allowed for dimnames attribute");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  170|       |	    /**** this could be dropped for REFCNT or be less
  171|       |		  stringent for NAMED for attributes where the setter
  172|       |		  does not have a consistency check that could fail
  173|       |		  after mutation in a complex assignment LT */
  174|  8.15M|	    MARK_NOT_MUTABLE(CAR(s));
  175|  8.15M|	    return CAR(s);
  176|  8.15M|	}
  177|  7.35M|    return R_NilValue;
  178|  15.5M|}
Rf_getAttrib:
  181|  32.6M|{
  182|  32.6M|    if(TYPEOF(vec) == CHARSXP)
  ------------------
  |  |  120|  32.6M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (182:8): [True: 0, False: 32.6M]
  ------------------
  183|      0|	error("cannot have attributes on a CHARSXP");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  184|       |    /* pre-test to avoid expensive operations if clearly not needed -- LT */
  185|  32.6M|    if (ATTRIB(vec) == R_NilValue &&
  ------------------
  |  Branch (185:9): [True: 17.0M, False: 15.5M]
  ------------------
  186|  17.0M|	! (TYPEOF(vec) == LISTSXP || TYPEOF(vec) == LANGSXP|| TYPEOF(vec) == DOTSXP))
  ------------------
  |  |  113|  34.1M|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
              	! (TYPEOF(vec) == LISTSXP || TYPEOF(vec) == LANGSXP|| TYPEOF(vec) == DOTSXP))
  ------------------
  |  |  117|  34.1M|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
              	! (TYPEOF(vec) == LISTSXP || TYPEOF(vec) == LANGSXP|| TYPEOF(vec) == DOTSXP))
  ------------------
  |  |  127|  17.0M|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (186:5): [True: 126, False: 17.0M]
  |  Branch (186:31): [True: 3.70k, False: 17.0M]
  |  Branch (186:56): [True: 0, False: 17.0M]
  ------------------
  187|  17.0M|	return R_NilValue;
  188|       |
  189|  15.5M|    if (isScalarString(name)) name = installTrChar(STRING_ELT(name, 0));
  ------------------
  |  |  965|  15.5M|#define isScalarString		Rf_isScalarString
  ------------------
                  if (isScalarString(name)) name = installTrChar(STRING_ELT(name, 0));
  ------------------
  |  |  937|      0|#define installTrChar		Rf_installTrChar
  ------------------
  |  Branch (189:9): [True: 0, False: 15.5M]
  ------------------
  190|  15.5M|    if (! isSymbol(name))
  ------------------
  |  |  953|  15.5M|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (190:9): [True: 0, False: 15.5M]
  ------------------
  191|      0|	error(_("'name' is not a symbol or a scalar string"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'name' is not a symbol or a scalar string"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  192|       |
  193|       |    /* special test for c(NA, n) rownames of data frames: */
  194|  15.5M|    if (name == R_RowNamesSymbol) {
  ------------------
  |  Branch (194:9): [True: 4, False: 15.5M]
  ------------------
  195|      4|	SEXP s = getAttrib0(vec, R_RowNamesSymbol);
  196|      4|	if (ALTREP(s))
  ------------------
  |  Branch (196:6): [True: 0, False: 4]
  ------------------
  197|       |	    // to allow for special row.names attributes in packages
  198|      0|	    return s;
  199|      4|	if(isInteger(s) && LENGTH(s) == 2 && INTEGER(s)[0] == NA_INTEGER) {
  ------------------
  |  |  949|      4|#define isInteger		Rf_isInteger
  ------------------
              	if(isInteger(s) && LENGTH(s) == 2 && INTEGER(s)[0] == NA_INTEGER) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (199:5): [True: 0, False: 4]
  |  Branch (199:21): [True: 0, False: 0]
  |  Branch (199:39): [True: 0, False: 0]
  ------------------
  200|      0|	    int n = abs(INTEGER(s)[1]);
  201|      0|	    if (n > 0)
  ------------------
  |  Branch (201:10): [True: 0, False: 0]
  ------------------
  202|      0|		s = R_compact_intrange(1, n);
  203|      0|	    else
  204|      0|		s = allocVector(INTSXP, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              		s = allocVector(INTSXP, 0);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  205|      0|	}
  206|      4|	return s;
  207|      4|    } else
  208|  15.5M|	return getAttrib0(vec, name);
  209|  15.5M|}
do_shortRowNames:
  214|      2|{
  215|       |    /* return  n if the data frame 'vec' has c(NA, n) rownames;
  216|       |     *	       nrow(.) otherwise;  note that data frames with nrow(.) == 0
  217|       |     *		have no row.names.
  218|       |     ==> is also used in dim.data.frame() */
  219|       |
  220|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  221|      2|    SEXP s = getAttrib0(CAR(args), R_RowNamesSymbol), ans = s;
  222|      2|    int type = asInteger(CADR(args));
  ------------------
  |  |  885|      2|#define asInteger		Rf_asInteger
  ------------------
  223|       |
  224|      2|    if( type < 0 || type > 2)
  ------------------
  |  Branch (224:9): [True: 0, False: 2]
  |  Branch (224:21): [True: 0, False: 2]
  ------------------
  225|      0|	error(_("invalid '%s' argument"), "type");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "type");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  226|       |
  227|      2|    if(type >= 1) {
  ------------------
  |  Branch (227:8): [True: 2, False: 0]
  ------------------
  228|      2|	int n = (isInteger(s) && LENGTH(s) == 2 && INTEGER(s)[0] == NA_INTEGER)
  ------------------
  |  |  949|      2|#define isInteger		Rf_isInteger
  ------------------
              	int n = (isInteger(s) && LENGTH(s) == 2 && INTEGER(s)[0] == NA_INTEGER)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (228:11): [True: 0, False: 2]
  |  Branch (228:27): [True: 0, False: 0]
  |  Branch (228:45): [True: 0, False: 0]
  ------------------
  229|      2|	    ? INTEGER(s)[1] : (isNull(s) ? 0 : LENGTH(s));
  ------------------
  |  |  956|      2|#define isNull			Rf_isNull
  ------------------
  |  Branch (229:25): [True: 0, False: 2]
  ------------------
  230|      2|	ans = ScalarInteger((type == 1) ? n : abs(n));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  |  Branch (230:22): [True: 0, False: 2]
  ------------------
  231|      2|    }
  232|      2|    return ans;
  233|      2|}
do_copyDFattr:
  238|      2|{
  239|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  240|      2|    SEXP in = CAR(args), out = CADR(args);
  241|      2|    SET_ATTRIB(out, shallow_duplicate(ATTRIB(in)));
  ------------------
  |  | 1030|      2|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
  242|      2|    IS_S4_OBJECT(in) ?  SET_S4_OBJECT(out) : UNSET_S4_OBJECT(out);
  ------------------
  |  Branch (242:5): [True: 0, False: 2]
  ------------------
  243|      2|    SET_OBJECT(out, OBJECT(in));
  244|      2|    return out;
  245|      2|}
Rf_setAttrib:
  250|  5.04M|{
  251|  5.04M|    PROTECT(vec);
  ------------------
  |  |  357|  5.04M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  252|  5.04M|    PROTECT(name);
  ------------------
  |  |  357|  5.04M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  253|       |
  254|  5.04M|    if (isScalarString(name)) {
  ------------------
  |  |  965|  5.04M|#define isScalarString		Rf_isScalarString
  ------------------
  |  Branch (254:9): [True: 54, False: 5.04M]
  ------------------
  255|     54|	PROTECT(val);
  ------------------
  |  |  357|     54|#define PROTECT(s)	Rf_protect(s)
  ------------------
  256|     54|	name = installTrChar(STRING_ELT(name, 0));
  ------------------
  |  |  937|     54|#define installTrChar		Rf_installTrChar
  ------------------
  257|     54|	UNPROTECT(1);
  ------------------
  |  |  358|     54|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  258|     54|    }
  259|  5.04M|    if (val == R_NilValue) {
  ------------------
  |  Branch (259:9): [True: 13.8k, False: 5.03M]
  ------------------
  260|       |	/* FIXME: see do_namesgets().
  261|       |	if (name == R_NamesSymbol && isOneDimensionalArray(vec)) {
  262|       |	    UNPROTECT(2);
  263|       |	    return removeAttrib(vec, R_DimNamesSymbol);
  264|       |	}
  265|       |	*/
  266|  13.8k|	UNPROTECT(2);
  ------------------
  |  |  358|  13.8k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  267|  13.8k|	return removeAttrib(vec, name);
  268|  13.8k|    }
  269|  5.03M|    if (! isSymbol(name))
  ------------------
  |  |  953|  5.03M|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (269:9): [True: 0, False: 5.03M]
  ------------------
  270|      0|	error(_("'name' is not a symbol or a scalar string"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'name' is not a symbol or a scalar string"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  271|       |
  272|       |    /* We allow attempting to remove names from NULL */
  273|  5.03M|    if (vec == R_NilValue)
  ------------------
  |  Branch (273:9): [True: 0, False: 5.03M]
  ------------------
  274|      0|	error(_("attempt to set an attribute on NULL"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt to set an attribute on NULL"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  275|       |
  276|  5.03M|    UNPROTECT(2);
  ------------------
  |  |  358|  5.03M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  277|       |
  278|  5.03M|    if (name == R_NamesSymbol)
  ------------------
  |  Branch (278:9): [True: 4.24M, False: 782k]
  ------------------
  279|  4.24M|	return namesgets(vec, val);
  ------------------
  |  | 1004|  4.24M|#define namesgets		Rf_namesgets
  ------------------
  280|   782k|    else if (name == R_DimSymbol)
  ------------------
  |  Branch (280:14): [True: 3.45k, False: 778k]
  ------------------
  281|  3.45k|	return dimgets(vec, val);
  ------------------
  |  |  906|  3.45k|#define dimgets			Rf_dimgets
  ------------------
  282|   778k|    else if (name == R_DimNamesSymbol)
  ------------------
  |  Branch (282:14): [True: 2.37k, False: 776k]
  ------------------
  283|  2.37k|	return dimnamesgets(vec, val);
  ------------------
  |  |  907|  2.37k|#define dimnamesgets		Rf_dimnamesgets
  ------------------
  284|   776k|    else if (name == R_ClassSymbol)
  ------------------
  |  Branch (284:14): [True: 775k, False: 400]
  ------------------
  285|   775k|	return classgets(vec, val);
  ------------------
  |  |  894|   775k|#define classgets		Rf_classgets
  ------------------
  286|    400|    else if (name == R_TspSymbol)
  ------------------
  |  Branch (286:14): [True: 0, False: 400]
  ------------------
  287|      0|	return tspgets(vec, val);
  ------------------
  |  | 2002|      0|# define tspgets		Rf_tspgets
  ------------------
  288|    400|    else if (name == R_CommentSymbol)
  ------------------
  |  Branch (288:14): [True: 0, False: 400]
  ------------------
  289|      0|	return commentgets(vec, val);
  290|    400|    else if (name == R_RowNamesSymbol) // "row.names" -> care for data frames
  ------------------
  |  Branch (290:14): [True: 6, False: 394]
  ------------------
  291|      6|	return row_names_gets(vec, val);
  292|    394|    else
  293|    394|	return installAttrib(vec, name, val);
  294|  5.03M|}
Rf_copyMostAttrib:
  302|    176|{
  303|    176|    SEXP s;
  304|       |
  305|    176|    if (ans == R_NilValue)
  ------------------
  |  Branch (305:9): [True: 0, False: 176]
  ------------------
  306|      0|	error(_("attempt to set an attribute on NULL"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt to set an attribute on NULL"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  307|       |
  308|    176|    PROTECT(ans);
  ------------------
  |  |  357|    176|#define PROTECT(s)	Rf_protect(s)
  ------------------
  309|    176|    PROTECT(inp);
  ------------------
  |  |  357|    176|#define PROTECT(s)	Rf_protect(s)
  ------------------
  310|    236|    for (s = ATTRIB(inp); s != R_NilValue; s = CDR(s)) {
  ------------------
  |  Branch (310:27): [True: 60, False: 176]
  ------------------
  311|     60|	if ((TAG(s) != R_NamesSymbol) &&
  ------------------
  |  Branch (311:6): [True: 0, False: 60]
  ------------------
  312|      0|	    (TAG(s) != R_DimSymbol) &&
  ------------------
  |  Branch (312:6): [True: 0, False: 0]
  ------------------
  313|      0|	    (TAG(s) != R_DimNamesSymbol)) { // << for matrix, array ..
  ------------------
  |  Branch (313:6): [True: 0, False: 0]
  ------------------
  314|      0|	    installAttrib(ans, TAG(s), CAR(s));
  315|      0|	}
  316|     60|    }
  317|    176|    if (OBJECT(inp)) SET_OBJECT(ans, 1);
  ------------------
  |  Branch (317:9): [True: 0, False: 176]
  ------------------
  318|    176|    IS_S4_OBJECT(inp) ?  SET_S4_OBJECT(ans) : UNSET_S4_OBJECT(ans);
  ------------------
  |  Branch (318:5): [True: 0, False: 176]
  ------------------
  319|    176|    UNPROTECT(2);
  ------------------
  |  |  358|    176|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  320|    176|}
Rf_classgets:
  542|   776k|{
  543|   776k|    if (isNull(klass) || isString(klass)) {
  ------------------
  |  |  956|   776k|#define isNull			Rf_isNull
  ------------------
                  if (isNull(klass) || isString(klass)) {
  ------------------
  |  |  966|   776k|#define isString		Rf_isString
  ------------------
  |  Branch (543:9): [True: 0, False: 776k]
  |  Branch (543:26): [True: 776k, False: 0]
  ------------------
  544|   776k|	int ncl = length(klass);
  ------------------
  |  |  987|   776k|#define length(x)		Rf_length(x)
  ------------------
  545|   776k|	if (ncl <= 0) {
  ------------------
  |  Branch (545:6): [True: 0, False: 776k]
  ------------------
  546|      0|	    SET_ATTRIB(vec, stripAttrib(R_ClassSymbol, ATTRIB(vec)));
  547|      0|	    SET_OBJECT(vec, 0);
  548|       |	    // problems when package building:  UNSET_S4_OBJECT(vec);
  549|      0|	}
  550|   776k|	else {
  551|       |	    /* When data frames were a special data type */
  552|       |	    /* we had more exhaustive checks here.  Now that */
  553|       |	    /* use JMCs interpreted code, we don't need this */
  554|       |	    /* FIXME : The whole "classgets" may as well die. */
  555|       |
  556|       |	    /* HOWEVER, it is the way that the object bit gets set/unset */
  557|       |
  558|   776k|	    bool isfactor = false;
  559|       |
  560|   776k|	    if (vec == R_NilValue)
  ------------------
  |  Branch (560:10): [True: 0, False: 776k]
  ------------------
  561|      0|		error(_("attempt to set an attribute on NULL"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("attempt to set an attribute on NULL"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  562|       |
  563|  2.32M|	    for(int i = 0; i < ncl; i++)
  ------------------
  |  Branch (563:21): [True: 1.55M, False: 776k]
  ------------------
  564|  1.55M|		if(streql(CHAR(STRING_ELT(klass, i)), "factor")) { /* ASCII */
  ------------------
  |  | 1498|  1.55M|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 1.55M]
  |  |  ------------------
  ------------------
  565|      0|		    isfactor = TRUE;
  566|      0|		    break;
  567|      0|		}
  568|   776k|	    if(isfactor && TYPEOF(vec) != INTSXP) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (568:9): [True: 0, False: 776k]
  |  Branch (568:21): [True: 0, False: 0]
  ------------------
  569|       |		/* we cannot coerce vec here, so just fail */
  570|      0|		error(_("adding class \"factor\" to an invalid object"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("adding class \"factor\" to an invalid object"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  571|      0|	    }
  572|       |
  573|   776k|	    installAttrib(vec, R_ClassSymbol, klass);
  574|   776k|	    SET_OBJECT(vec, 1);
  575|       |
  576|       |#ifdef R_classgets_copy_S4
  577|       |// not ok -- fails at installation around byte-compiling methods
  578|       |	    if(ncl == 1 && R_has_methods_attached()) { // methods: do not act too early
  579|       |		SEXP cld = R_getClassDef_R(klass);
  580|       |		if(!isNull(cld)) {
  581|       |		    PROTECT(cld);
  582|       |		    /* More efficient? can we protect? -- rather *assign* in method-ns?
  583|       |		       static SEXP oldCl = NULL;
  584|       |		       if(!oldCl) oldCl = R_getClassDef("oldClass");
  585|       |		       if(!oldCl) oldCl = mkString("oldClass");
  586|       |		       PROTECT(oldCl);
  587|       |		    */
  588|       |		    if(!R_isVirtualClass(cld, R_MethodsNamespace) &&
  589|       |		       !R_extends(cld, mkString("oldClass"), R_MethodsNamespace)) // set S4 bit :
  590|       |			// !R_extends(cld, oldCl, R_MethodsNamespace)) // set S4 bit :
  591|       |
  592|       |			SET_S4_OBJECT(vec);
  593|       |
  594|       |		    UNPROTECT(1); // UNPROTECT(2);
  595|       |		}
  596|       |	    }
  597|       |#endif
  598|   776k|	}
  599|   776k|    }
  600|      0|    else
  601|      0|	error(_("attempt to set invalid 'class' attribute"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt to set invalid 'class' attribute"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  602|   776k|    return R_NilValue;
  603|   776k|}
do_classgets:
  607|      4|{
  608|      4|    checkArity(op, args);
  ------------------
  |  | 1788|      4|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  609|       |    // have 2 args: check1arg(args, call, "x");
  610|       |
  611|      4|    if (MAYBE_SHARED(CAR(args)) ||
  ------------------
  |  Branch (611:9): [True: 0, False: 4]
  ------------------
  612|      4|	((! IS_ASSIGNMENT_CALL(call)) && MAYBE_REFERENCED(CAR(args))))
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (612:3): [True: 0, False: 4]
  ------------------
  613|      0|	SETCAR(args, shallow_duplicate(CAR(args)));
  ------------------
  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
  614|      4|    if (length(CADR(args)) == 0) SETCADR(args, R_NilValue);
  ------------------
  |  |  987|      4|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (614:9): [True: 2, False: 2]
  ------------------
  615|      4|    if(IS_S4_OBJECT(CAR(args)))
  ------------------
  |  Branch (615:8): [True: 0, False: 4]
  ------------------
  616|      0|      UNSET_S4_OBJECT(CAR(args));
  617|      4|    setAttrib(CAR(args), R_ClassSymbol, CADR(args));
  ------------------
  |  | 1027|      4|#define setAttrib		Rf_setAttrib
  ------------------
  618|      4|    SETTER_CLEAR_NAMED(CAR(args));
  619|      4|    return CAR(args);
  620|      4|}
do_class:
  624|      4|{
  625|      4|    checkArity(op, args);
  ------------------
  |  | 1788|      4|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  626|      4|    check1arg(args, call, "x");
  ------------------
  |  | 1867|      4|# define check1arg		Rf_check1arg
  ------------------
  627|      4|    SEXP x = CAR(args), s3class;
  628|      4|    if(IS_S4_OBJECT(x)) {
  ------------------
  |  Branch (628:8): [True: 0, False: 4]
  ------------------
  629|      0|      if((s3class = S3Class(x)) != R_NilValue) {
  ------------------
  |  | 1020|      0|#define S3Class                 Rf_S3Class
  ------------------
  |  Branch (629:10): [True: 0, False: 0]
  ------------------
  630|      0|	return s3class;
  631|      0|      }
  632|      0|    } /* else */
  633|      4|    return getAttrib(x, R_ClassSymbol);
  ------------------
  |  |  924|      4|#define getAttrib		Rf_getAttrib
  ------------------
  634|      4|}
R_data_class:
  668|  4.67k|{
  669|  4.67k|    SEXP value, klass = getAttrib(obj, R_ClassSymbol);
  ------------------
  |  |  924|  4.67k|#define getAttrib		Rf_getAttrib
  ------------------
  670|  4.67k|    int n = length(klass);
  ------------------
  |  |  987|  4.67k|#define length(x)		Rf_length(x)
  ------------------
  671|  4.67k|    if(n == 1 || (n > 0 && !singleString))
  ------------------
  |  Branch (671:8): [True: 994, False: 3.67k]
  |  Branch (671:19): [True: 1.23k, False: 2.44k]
  |  Branch (671:28): [True: 1.23k, False: 0]
  ------------------
  672|  2.23k|	return(klass);
  673|  2.44k|    if(n == 0) {
  ------------------
  |  Branch (673:8): [True: 2.44k, False: 0]
  ------------------
  674|  2.44k|	SEXP dim = getAttrib(obj, R_DimSymbol);
  ------------------
  |  |  924|  2.44k|#define getAttrib		Rf_getAttrib
  ------------------
  675|  2.44k|	int nd = length(dim);
  ------------------
  |  |  987|  2.44k|#define length(x)		Rf_length(x)
  ------------------
  676|  2.44k|	if(nd > 0) {
  ------------------
  |  Branch (676:5): [True: 0, False: 2.44k]
  ------------------
  677|      0|	    if(nd == 2) {
  ------------------
  |  Branch (677:9): [True: 0, False: 0]
  ------------------
  678|      0|		if(singleString)
  ------------------
  |  Branch (678:6): [True: 0, False: 0]
  ------------------
  679|      0|		    klass = mkChar("matrix");
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  680|      0|		else { // R >= 4.0.0 :  class(<matrix>) |->  c("matrix", "array")
  681|      0|		    PROTECT(klass = allocVector(STRSXP, 2));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  682|      0|		    SET_STRING_ELT(klass, 0, mkChar("matrix"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  683|      0|		    SET_STRING_ELT(klass, 1, mkChar("array"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  684|      0|		    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  685|      0|		    return klass;
  686|      0|		}
  687|      0|	    }
  688|      0|	    else
  689|      0|		klass = mkChar("array");
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  690|      0|	}
  691|  2.44k|	else {
  692|  2.44k|	  SEXPTYPE t = TYPEOF(obj);
  693|  2.44k|	  switch(t) {
  694|    952|	  case CLOSXP: case SPECIALSXP: case BUILTINSXP:
  ------------------
  |  |  114|    886|#define CLOSXP	     3	  /* closures */
  ------------------
              	  case CLOSXP: case SPECIALSXP: case BUILTINSXP:
  ------------------
  |  |  118|    942|#define SPECIALSXP   7	  /* special forms */
  ------------------
              	  case CLOSXP: case SPECIALSXP: case BUILTINSXP:
  ------------------
  |  |  119|    952|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (694:4): [True: 886, False: 1.55k]
  |  Branch (694:17): [True: 56, False: 2.38k]
  |  Branch (694:34): [True: 10, False: 2.43k]
  ------------------
  695|    952|	    klass = mkChar("function");
  ------------------
  |  |  998|    952|#define mkChar			Rf_mkChar
  ------------------
  696|    952|	    break;
  697|      0|	  case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (697:4): [True: 0, False: 2.44k]
  ------------------
  698|      0|	    klass = mkChar("numeric");
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  699|      0|	    break;
  700|      0|	  case SYMSXP:
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (700:4): [True: 0, False: 2.44k]
  ------------------
  701|      0|	    klass = mkChar("name");
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  702|      0|	    break;
  703|      0|	  case LANGSXP:
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (703:4): [True: 0, False: 2.44k]
  ------------------
  704|      0|	    klass = lang2str(obj);
  705|      0|	    break;
  706|      0|	  case OBJSXP:
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (706:4): [True: 0, False: 2.44k]
  ------------------
  707|      0|	    klass = mkChar(IS_S4_OBJECT(obj) ? "S4" : "object");
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  |  Branch (707:21): [True: 0, False: 0]
  ------------------
  708|      0|	    break;
  709|  1.48k|	  default:
  ------------------
  |  Branch (709:4): [True: 1.48k, False: 952]
  ------------------
  710|  1.48k|	    klass = type2str(t);
  ------------------
  |  | 1042|  1.48k|#define type2str		Rf_type2str
  ------------------
  711|  2.44k|	  }
  712|  2.44k|	}
  713|  2.44k|    }
  714|      0|    else
  715|      0|	klass = asChar(klass);
  ------------------
  |  |  882|      0|#define asChar			Rf_asChar
  ------------------
  716|  2.44k|    PROTECT(klass);
  ------------------
  |  |  357|  2.44k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  717|  2.44k|    value = ScalarString(klass);
  ------------------
  |  | 1025|  2.44k|#define ScalarString		Rf_ScalarString
  ------------------
  718|  2.44k|    UNPROTECT(1);
  ------------------
  |  |  358|  2.44k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  719|  2.44k|    return value;
  720|  2.44k|}
Rf_InitS3DefaultTypes:
  814|      2|{
  815|     66|    for(int type = 0; type < MAX_NUM_SEXPTYPE; type++) {
  ------------------
  |  |  184|     66|#define MAX_NUM_SEXPTYPE (1<<TYPE_BITS)
  |  |  ------------------
  |  |  |  |  183|     66|#define TYPE_BITS 5
  |  |  ------------------
  ------------------
  |  Branch (815:23): [True: 64, False: 2]
  ------------------
  816|     64|	SEXP part3 = R_NilValue;
  817|     64|	SEXP part4 = R_NilValue;
  818|     64|	int nprotected = 0;
  819|       |
  820|     64|	switch(type) {
  821|      2|	    case CLOSXP:
  ------------------
  |  |  114|      2|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (821:6): [True: 2, False: 62]
  ------------------
  822|      4|	    case SPECIALSXP:
  ------------------
  |  |  118|      4|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (822:6): [True: 2, False: 62]
  ------------------
  823|      6|	    case BUILTINSXP:
  ------------------
  |  |  119|      6|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (823:6): [True: 2, False: 62]
  ------------------
  824|      6|		part3 = PROTECT(mkChar("function"));
  ------------------
  |  |  357|      6|#define PROTECT(s)	Rf_protect(s)
  ------------------
  825|      6|		nprotected++;
  826|      6|		break;
  827|      2|	    case INTSXP:
  ------------------
  |  |  123|      2|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (827:6): [True: 2, False: 62]
  ------------------
  828|      4|	    case REALSXP:
  ------------------
  |  |  124|      4|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (828:6): [True: 2, False: 62]
  ------------------
  829|      4|		part3 = PROTECT(type2str_nowarn(type));
  ------------------
  |  |  357|      4|#define PROTECT(s)	Rf_protect(s)
  ------------------
  830|      4|		part4 = PROTECT(mkChar("numeric"));
  ------------------
  |  |  357|      4|#define PROTECT(s)	Rf_protect(s)
  ------------------
  831|      4|		nprotected += 2;
  832|      4|		break;
  833|      2|	    case LANGSXP:
  ------------------
  |  |  117|      2|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (833:6): [True: 2, False: 62]
  ------------------
  834|       |		/* part3 remains R_NilValue: default type cannot be
  835|       |		   pre-allocated, as it depends on the object value */
  836|      2|		break;
  837|      2|	    case SYMSXP:
  ------------------
  |  |  112|      2|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (837:6): [True: 2, False: 62]
  ------------------
  838|      2|		part3 = PROTECT(mkChar("name"));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
  839|      2|		nprotected++;
  840|      2|		break;
  841|     50|	    default:
  ------------------
  |  Branch (841:6): [True: 50, False: 14]
  ------------------
  842|     50|		part3 = PROTECT(type2str_nowarn(type));
  ------------------
  |  |  357|     50|#define PROTECT(s)	Rf_protect(s)
  ------------------
  843|     50|		nprotected++;
  844|     64|	}
  845|       |
  846|     64|	Type2DefaultClass[type].vector =
  847|     64|	    createDefaultClass(R_NilValue, R_NilValue, part3, part4);
  848|       |
  849|     64|	SEXP part2 = PROTECT(mkChar("array"));
  ------------------
  |  |  357|     64|#define PROTECT(s)	Rf_protect(s)
  ------------------
  850|     64|	SEXP part1 = PROTECT(mkChar("matrix"));
  ------------------
  |  |  357|     64|#define PROTECT(s)	Rf_protect(s)
  ------------------
  851|     64|	nprotected += 2;
  852|     64|	Type2DefaultClass[type].matrix =
  853|     64|	    createDefaultClass(part1,      part2, part3, part4);
  854|     64|	Type2DefaultClass[type].array =
  855|     64|	    createDefaultClass(R_NilValue, part2, part3, part4);
  856|     64|	UNPROTECT(nprotected);
  ------------------
  |  |  358|     64|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  857|     64|    }
  858|      2|}
R_data_class2:
  862|   776k|{
  863|   776k|    SEXP klass = getAttrib(obj, R_ClassSymbol);
  ------------------
  |  |  924|   776k|#define getAttrib		Rf_getAttrib
  ------------------
  864|   776k|    if(length(klass) > 0) {
  ------------------
  |  |  987|   776k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (864:8): [True: 776k, False: 207]
  ------------------
  865|   776k|	if(IS_S4_OBJECT(obj))
  ------------------
  |  Branch (865:5): [True: 0, False: 776k]
  ------------------
  866|      0|	    return S4_extends(klass, TRUE);
  867|   776k|	else
  868|   776k|	    return klass;
  869|   776k|    }
  870|    207|    else { // length(klass) == 0 , i.e., no class *attribute*: attr(obj, "class") is NULL
  871|       |
  872|    207|	SEXP dim = getAttrib(obj, R_DimSymbol);
  ------------------
  |  |  924|    207|#define getAttrib		Rf_getAttrib
  ------------------
  873|    207|	int n = length(dim);
  ------------------
  |  |  987|    207|#define length(x)		Rf_length(x)
  ------------------
  874|    207|	SEXPTYPE t = TYPEOF(obj);
  875|    207|	SEXP defaultClass;
  876|       |
  877|    207|	switch(n) {
  878|    207|	case 0:  defaultClass = Type2DefaultClass[t].vector; break;
  ------------------
  |  Branch (878:2): [True: 207, False: 0]
  ------------------
  879|      0|	case 2:  defaultClass = Type2DefaultClass[t].matrix; break;
  ------------------
  |  Branch (879:2): [True: 0, False: 207]
  ------------------
  880|      0|	default: defaultClass = Type2DefaultClass[t].array;  break;
  ------------------
  |  Branch (880:2): [True: 0, False: 207]
  ------------------
  881|    207|	}
  882|       |
  883|    207|	if (defaultClass != R_NilValue) {
  ------------------
  |  Branch (883:6): [True: 123, False: 84]
  ------------------
  884|    123|	    return defaultClass;
  885|    123|	}
  886|       |
  887|       |	/* now t == LANGSXP, but check to make sure */
  888|     84|	if (t != LANGSXP)
  ------------------
  |  |  117|     84|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (888:6): [True: 0, False: 84]
  ------------------
  889|      0|	    error("type must be LANGSXP at this point");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  890|     84|	if (n == 0) {
  ------------------
  |  Branch (890:6): [True: 84, False: 0]
  ------------------
  891|     84|	    return ScalarString(lang2str(obj));
  ------------------
  |  | 1025|     84|#define ScalarString		Rf_ScalarString
  ------------------
  892|     84|	}
  893|       |	/* Where on earth is this ever needed ??
  894|       |	 * __FIXME / TODO__ ??
  895|       |	 * warning("R_data_class2(<LANGSXP with \"dim\" attribute>) .. please report!");
  896|       |	 */
  897|      0|	int I_mat = (n == 2) ? 1 : 0,
  ------------------
  |  Branch (897:14): [True: 0, False: 0]
  ------------------
  898|      0|	    nprot = 2;  /* part1, defaultClass */
  899|      0|	defaultClass = PROTECT(allocVector(STRSXP, 2 + I_mat));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  900|      0|	SEXP part1 = PROTECT(mkChar("array")), part2;
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  901|      0|	SET_STRING_ELT(defaultClass, 0, part1);
  902|      0|	if (n == 2) {
  ------------------
  |  Branch (902:6): [True: 0, False: 0]
  ------------------
  903|      0|	    part2 = PROTECT(mkChar("matrix")); nprot++;
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  904|      0|	    SET_STRING_ELT(defaultClass, 1, part2);
  905|      0|	}
  906|      0|	SET_STRING_ELT(defaultClass, 1+I_mat, lang2str(obj));
  907|      0|	UNPROTECT(nprot);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  908|      0|	return defaultClass;
  909|     84|    }
  910|   776k|}
R_do_data_class:
  914|  1.93k|{
  915|  1.93k|  checkArity(op, args);
  ------------------
  |  | 1788|  1.93k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  916|  1.93k|  if(PRIMVAL(op) == 1) { // .cache_class() - typically re-defining existing cache
  ------------------
  |  | 1347|  1.93k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (916:6): [True: 0, False: 1.93k]
  ------------------
  917|      0|      check1arg(args, call, "class");
  ------------------
  |  | 1867|      0|# define check1arg		Rf_check1arg
  ------------------
  918|      0|      SEXP klass = CAR(args);
  919|      0|      if(TYPEOF(klass) != STRSXP || LENGTH(klass) < 1)
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (919:10): [True: 0, False: 0]
  |  Branch (919:37): [True: 0, False: 0]
  ------------------
  920|      0|	  error("invalid class argument to internal .class_cache");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  921|      0|      const char *class = translateChar(STRING_ELT(klass, 0));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  922|      0|      return cache_class(class, CADR(args));
  923|      0|  }
  924|  1.93k|  check1arg(args, call, "x");
  ------------------
  |  | 1867|  1.93k|# define check1arg		Rf_check1arg
  ------------------
  925|  1.93k|  if(PRIMVAL(op) == 2)
  ------------------
  |  | 1347|  1.93k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (925:6): [True: 0, False: 1.93k]
  ------------------
  926|       |      // .class2()
  927|      0|      return R_data_class2(CAR(args));
  928|       |  // class():
  929|  1.93k|  return R_data_class(CAR(args), FALSE);
  930|  1.93k|}
do_namesgets:
  937|    164|{
  938|    164|    SEXP ans;
  939|    164|    checkArity(op, args);
  ------------------
  |  | 1788|    164|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  940|       |    // 2 args ("x", "value")
  941|       |
  942|       |    /* DispatchOrEval internal generic: names<- */
  943|    164|    if (DispatchOrEval(call, op, "names<-", args, env, &ans, 0, 1))
  ------------------
  |  | 1887|    164|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (943:9): [True: 0, False: 164]
  ------------------
  944|      0|	return(ans);
  945|       |    /* Special case: removing non-existent names, to avoid a copy */
  946|    164|    if (CADR(args) == R_NilValue &&
  ------------------
  |  Branch (946:9): [True: 48, False: 116]
  ------------------
  947|     48|	getAttrib(CAR(args), R_NamesSymbol) == R_NilValue)
  ------------------
  |  |  924|     48|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (947:2): [True: 46, False: 2]
  ------------------
  948|     46|	return CAR(args);
  949|    118|    PROTECT(args = ans);
  ------------------
  |  |  357|    118|#define PROTECT(s)	Rf_protect(s)
  ------------------
  950|    118|    if (MAYBE_SHARED(CAR(args)) ||
  ------------------
  |  Branch (950:9): [True: 0, False: 118]
  ------------------
  951|    118|	((! IS_ASSIGNMENT_CALL(call)) && MAYBE_REFERENCED(CAR(args))))
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (951:3): [True: 0, False: 118]
  ------------------
  952|      0|	SETCAR(args, R_shallow_duplicate_attr(CAR(args)));
  953|    118|    if (TYPEOF(CAR(args)) == OBJSXP) {
  ------------------
  |  |  137|    118|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (953:9): [True: 0, False: 118]
  ------------------
  954|      0|	const char *klass = CHAR(STRING_ELT(R_data_class(CAR(args), FALSE), 0));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  955|      0|	error(_("invalid to use names()<- on an S4 object of class '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid to use names()<- on an S4 object of class '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  956|      0|	      klass);
  957|      0|    }
  958|    118|    SEXP names = CADR(args);
  959|    118|    if (names != R_NilValue &&
  ------------------
  |  Branch (959:9): [True: 116, False: 2]
  ------------------
  960|    116|	! (TYPEOF(names) == STRSXP && ATTRIB(names) == R_NilValue)) {
  ------------------
  |  |  126|    232|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (960:5): [True: 116, False: 0]
  |  Branch (960:32): [True: 114, False: 2]
  ------------------
  961|      2|	PROTECT(call = allocLang(2));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
  962|      2|	SETCAR(call, R_AsCharacterSymbol);
  963|      2|	SETCADR(call, names);
  964|      2|	names = eval(call, env);
  ------------------
  |  |  913|      2|#define eval			Rf_eval
  ------------------
  965|      2|	SETCADR(call, R_NilValue); /* decrements REFCNT on names */
  966|      2|	UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  967|      2|    }
  968|       |    /* FIXME:
  969|       |       Need to special-case names(x) <- NULL for 1-d arrays to perform
  970|       |         setAttrib(x, R_DimNamesSymbol, R_NilValue)
  971|       |       (and remove the dimnames) here if we want
  972|       |         setAttrib(x, R_NamesSymbol, R_NilValue)
  973|       |       to actually remove the names, as needed in subset.c.
  974|       |    */
  975|    118|    if(names == R_NilValue && isOneDimensionalArray(CAR(args)))
  ------------------
  |  Branch (975:8): [True: 2, False: 116]
  |  Branch (975:31): [True: 0, False: 2]
  ------------------
  976|      0|	setAttrib(CAR(args), R_DimNamesSymbol, names);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  977|    118|    else
  978|    118|	setAttrib(CAR(args), R_NamesSymbol, names);
  ------------------
  |  | 1027|    118|#define setAttrib		Rf_setAttrib
  ------------------
  979|    118|    UNPROTECT(1);
  ------------------
  |  |  358|    118|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  980|    118|    SETTER_CLEAR_NAMED(CAR(args));
  981|    118|    return CAR(args);
  982|    164|}
Rf_namesgets:
  985|  4.24M|{
  986|  4.24M|    int i;
  987|  4.24M|    SEXP s, rval, tval;
  988|       |
  989|  4.24M|    PROTECT(vec);
  ------------------
  |  |  357|  4.24M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  990|  4.24M|    PROTECT(val);
  ------------------
  |  |  357|  4.24M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  991|       |
  992|       |    /* Ensure that the labels are indeed */
  993|       |    /* a vector of character strings */
  994|       |
  995|  4.24M|    if (isList(val)) {
  ------------------
  |  |  951|  4.24M|#define isList			Rf_isList
  ------------------
  |  Branch (995:9): [True: 0, False: 4.24M]
  ------------------
  996|      0|	if (!isVectorizable(val))
  ------------------
  |  |  976|      0|#define isVectorizable		Rf_isVectorizable
  ------------------
  |  Branch (996:6): [True: 0, False: 0]
  ------------------
  997|      0|	    error(_("incompatible 'names' argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("incompatible 'names' argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  998|      0|	else {
  999|      0|	    rval = allocVector(STRSXP, length(vec));
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	    rval = allocVector(STRSXP, length(vec));
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
              	    rval = allocVector(STRSXP, length(vec));
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 1000|      0|	    PROTECT(rval);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1001|       |	    /* See PR#10807 */
 1002|      0|	    for (i = 0, tval = val;
 1003|      0|		 i < length(vec) && tval != R_NilValue;
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1003:4): [True: 0, False: 0]
  |  Branch (1003:23): [True: 0, False: 0]
  ------------------
 1004|      0|		 i++, tval = CDR(tval)) {
 1005|      0|		s = coerceVector(CAR(tval), STRSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              		s = coerceVector(CAR(tval), STRSXP);
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
 1006|      0|		SET_STRING_ELT(rval, i, STRING_ELT(s, 0));
 1007|      0|	    }
 1008|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1009|      0|	    val = rval;
 1010|      0|	}
 1011|  4.24M|    } else val = coerceVector(val, STRSXP);
  ------------------
  |  |  895|  4.24M|#define coerceVector		Rf_coerceVector
  ------------------
                  } else val = coerceVector(val, STRSXP);
  ------------------
  |  |  126|  4.24M|#define STRSXP	    16	  /* string vectors */
  ------------------
 1012|  4.24M|    UNPROTECT(1);
  ------------------
  |  |  358|  4.24M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1013|  4.24M|    PROTECT(val);
  ------------------
  |  |  357|  4.24M|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1014|       |
 1015|       |    /* Check that the lengths and types are compatible */
 1016|  4.24M|    if (xlength(val) < xlength(vec)) { // recycle
  ------------------
  |  | 1049|  4.24M|#define xlength(x)		Rf_xlength(x)
  ------------------
                  if (xlength(val) < xlength(vec)) { // recycle
  ------------------
  |  | 1049|  4.24M|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (1016:9): [True: 0, False: 4.24M]
  ------------------
 1017|      0|	val = xlengthgets(val, xlength(vec));
  ------------------
  |  | 1050|      0|#define xlengthgets		Rf_xlengthgets
  ------------------
              	val = xlengthgets(val, xlength(vec));
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
 1018|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1019|      0|	PROTECT(val);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1020|      0|    }
 1021|       |
 1022|  4.24M|    checkNames(vec, val);
 1023|       |
 1024|       |    /* Special treatment for one dimensional arrays */
 1025|  4.24M|    if(isOneDimensionalArray(vec)) {
  ------------------
  |  Branch (1025:8): [True: 0, False: 4.24M]
  ------------------
 1026|      0|	PROTECT(val = CONS(val, R_NilValue));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1027|      0|	setAttrib(vec, R_DimNamesSymbol, val);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 1028|      0|	UNPROTECT(3);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1029|      0|	return vec;
 1030|      0|    }
 1031|       |
 1032|  4.24M|    if (isList(vec) || isLanguage(vec)) {
  ------------------
  |  |  951|  4.24M|#define isList			Rf_isList
  ------------------
                  if (isList(vec) || isLanguage(vec)) {
  ------------------
  |  |  950|  4.24M|#define isLanguage		Rf_isLanguage
  ------------------
  |  Branch (1032:9): [True: 0, False: 4.24M]
  |  Branch (1032:24): [True: 20, False: 4.24M]
  ------------------
 1033|       |	/* Cons-cell based objects */
 1034|     20|	i = 0;
 1035|     76|	for (s = vec; s != R_NilValue; s = CDR(s), i++)
  ------------------
  |  Branch (1035:16): [True: 56, False: 20]
  ------------------
 1036|     56|	    if (STRING_ELT(val, i) != R_NilValue
  ------------------
  |  Branch (1036:10): [True: 56, False: 0]
  ------------------
 1037|     56|		&& STRING_ELT(val, i) != R_NaString
  ------------------
  |  Branch (1037:6): [True: 56, False: 0]
  ------------------
 1038|     56|		&& *CHAR(STRING_ELT(val, i)) != 0) /* test of length */
  ------------------
  |  |  203|     56|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1038:6): [True: 24, False: 32]
  ------------------
 1039|     24|		SET_TAG(s, installTrChar(STRING_ELT(val, i)));
  ------------------
  |  |  937|     24|#define installTrChar		Rf_installTrChar
  ------------------
 1040|     32|	    else
 1041|     32|		SET_TAG(s, R_NilValue);
 1042|     20|    }
 1043|  4.24M|    else if (isVector(vec) || IS_S4_OBJECT(vec))
  ------------------
  |  |  974|  4.24M|#define isVector		Rf_isVector
  ------------------
  |  Branch (1043:14): [True: 4.24M, False: 0]
  |  Branch (1043:31): [True: 0, False: 0]
  ------------------
 1044|       |	/* Normal case */
 1045|  4.24M|	installAttrib(vec, R_NamesSymbol, val);
 1046|      0|    else
 1047|      0|	error(_("invalid type (%s) to set 'names' attribute"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid type (%s) to set 'names' attribute"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1048|      0|	      R_typeToChar(vec));
 1049|  4.24M|    UNPROTECT(2);
  ------------------
  |  |  358|  4.24M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1050|  4.24M|    return vec;
 1051|  4.24M|}
do_names:
 1057|  1.15M|{
 1058|  1.15M|    SEXP ans;
 1059|  1.15M|    checkArity(op, args);
  ------------------
  |  | 1788|  1.15M|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1060|  1.15M|    check1arg(args, call, "x");
  ------------------
  |  | 1867|  1.15M|# define check1arg		Rf_check1arg
  ------------------
 1061|       |    /* DispatchOrEval internal generic: names */
 1062|  1.15M|    if (DispatchOrEval(call, op, "names", args, env, &ans, 0, 1))
  ------------------
  |  | 1887|  1.15M|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (1062:9): [True: 0, False: 1.15M]
  ------------------
 1063|      0|	return(ans);
 1064|  1.15M|    PROTECT(args = ans);
  ------------------
  |  |  357|  1.15M|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1065|  1.15M|    ans = CAR(args);
 1066|  1.15M|    if (isEnvironment(ans) || isS4Environment(ans))
  ------------------
  |  |  944|  1.15M|#define isEnvironment		Rf_isEnvironment
  ------------------
                  if (isEnvironment(ans) || isS4Environment(ans))
  ------------------
  |  | 1053|  1.15M|#define isS4Environment(x) (TYPEOF(x) == OBJSXP &&	\
  |  |  ------------------
  |  |  |  |  137|  2.31M|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |  |  Branch (1053:29): [True: 0, False: 1.15M]
  |  |  ------------------
  |  | 1054|  1.15M|			    isEnvironment(R_getS4DataSlot(x, ENVSXP)))
  |  |  ------------------
  |  |  |  |  944|      0|#define isEnvironment		Rf_isEnvironment
  |  |  ------------------
  |  |               			    isEnvironment(R_getS4DataSlot(x, ENVSXP)))
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (1054:8): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1066:9): [True: 166, False: 1.15M]
  ------------------
 1067|    166|	ans = R_lsInternal3(ans, TRUE, FALSE);
 1068|  1.15M|    else if (isVector(ans) || isList(ans) || isLanguage(ans) || IS_S4_OBJECT(ans) || TYPEOF(ans) == DOTSXP)
  ------------------
  |  |  974|  1.15M|#define isVector		Rf_isVector
  ------------------
                  else if (isVector(ans) || isList(ans) || isLanguage(ans) || IS_S4_OBJECT(ans) || TYPEOF(ans) == DOTSXP)
  ------------------
  |  |  951|     58|#define isList			Rf_isList
  ------------------
                  else if (isVector(ans) || isList(ans) || isLanguage(ans) || IS_S4_OBJECT(ans) || TYPEOF(ans) == DOTSXP)
  ------------------
  |  |  950|     39|#define isLanguage		Rf_isLanguage
  ------------------
                  else if (isVector(ans) || isList(ans) || isLanguage(ans) || IS_S4_OBJECT(ans) || TYPEOF(ans) == DOTSXP)
  ------------------
  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (1068:14): [True: 1.15M, False: 58]
  |  Branch (1068:31): [True: 19, False: 39]
  |  Branch (1068:46): [True: 39, False: 0]
  |  Branch (1068:65): [True: 0, False: 0]
  |  Branch (1068:86): [True: 0, False: 0]
  ------------------
 1069|  1.15M|	ans = getAttrib(ans, R_NamesSymbol);
  ------------------
  |  |  924|  1.15M|#define getAttrib		Rf_getAttrib
  ------------------
 1070|      0|    else ans = R_NilValue;
 1071|  1.15M|    UNPROTECT(1);
  ------------------
  |  |  358|  1.15M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1072|  1.15M|    return ans;
 1073|  1.15M|}
Rf_dimnamesgets:
 1115|  2.37k|{
 1116|  2.37k|    PROTECT(vec);
  ------------------
  |  |  357|  2.37k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1117|  2.37k|    PROTECT(val);
  ------------------
  |  |  357|  2.37k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1118|       |
 1119|  2.37k|    if (!isArray(vec) && !isList(vec))
  ------------------
  |  |  940|  2.37k|#define isArray			Rf_isArray
  ------------------
                  if (!isArray(vec) && !isList(vec))
  ------------------
  |  |  951|      0|#define isList			Rf_isList
  ------------------
  |  Branch (1119:9): [True: 0, False: 2.37k]
  |  Branch (1119:26): [True: 0, False: 0]
  ------------------
 1120|      0|	error(_("'dimnames' applied to non-array"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'dimnames' applied to non-array"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1121|       |    /* This is probably overkill, but you never know; */
 1122|       |    /* there may be old pair-lists out there */
 1123|       |    /* There are, when this gets used as names<- for 1-d arrays */
 1124|  2.37k|    if (!isList(val) && !isNewList(val))
  ------------------
  |  |  951|  2.37k|#define isList			Rf_isList
  ------------------
                  if (!isList(val) && !isNewList(val))
  ------------------
  |  |  955|  2.37k|#define isNewList		Rf_isNewList
  ------------------
  |  Branch (1124:9): [True: 2.37k, False: 0]
  |  Branch (1124:25): [True: 0, False: 2.37k]
  ------------------
 1125|      0|	error(_("'%s' must be a list"), "dimnames");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'%s' must be a list"), "dimnames");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1126|  2.37k|    SEXP dims = getAttrib(vec, R_DimSymbol);
  ------------------
  |  |  924|  2.37k|#define getAttrib		Rf_getAttrib
  ------------------
 1127|  2.37k|    int k = LENGTH(dims);
 1128|  2.37k|    if (k < length(val))
  ------------------
  |  |  987|  2.37k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1128:9): [True: 0, False: 2.37k]
  ------------------
 1129|      0|	error(_("length of 'dimnames' [%d] must match that of 'dims' [%d]"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("length of 'dimnames' [%d] must match that of 'dims' [%d]"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1130|      0|	      length(val), k);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 1131|  2.37k|    if (length(val) == 0) {
  ------------------
  |  |  987|  2.37k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1131:9): [True: 0, False: 2.37k]
  ------------------
 1132|      0|	removeAttrib(vec, R_DimNamesSymbol);
 1133|      0|	UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1134|      0|	return vec;
 1135|      0|    }
 1136|       |    /* Old list to new list */
 1137|  2.37k|    SEXP newval;
 1138|  2.37k|    if (isList(val)) {
  ------------------
  |  |  951|  2.37k|#define isList			Rf_isList
  ------------------
  |  Branch (1138:9): [True: 0, False: 2.37k]
  ------------------
 1139|      0|	newval = allocVector(VECSXP, k);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	newval = allocVector(VECSXP, k);
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
 1140|      0|	for (int i = 0; i < k; i++) {
  ------------------
  |  Branch (1140:18): [True: 0, False: 0]
  ------------------
 1141|      0|	    SET_VECTOR_ELT(newval, i, CAR(val));
 1142|      0|	    val = CDR(val);
 1143|      0|	}
 1144|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1145|      0|	PROTECT(val = newval);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1146|      0|    }
 1147|  2.37k|    if (length(val) > 0 && length(val) < k) {
  ------------------
  |  |  987|  2.37k|#define length(x)		Rf_length(x)
  ------------------
                  if (length(val) > 0 && length(val) < k) {
  ------------------
  |  |  987|  2.37k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1147:9): [True: 2.37k, False: 0]
  |  Branch (1147:28): [True: 0, False: 2.37k]
  ------------------
 1148|      0|	newval = lengthgets(val, k);
  ------------------
  |  |  988|      0|#define lengthgets		Rf_lengthgets
  ------------------
 1149|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1150|      0|	PROTECT(val = newval);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1151|      0|    }
 1152|  2.37k|    if (MAYBE_REFERENCED(val)) {
  ------------------
  |  |  251|  2.37k|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 2.37k]
  |  |  ------------------
  ------------------
 1153|      0|	newval = shallow_duplicate(val);
  ------------------
  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 1154|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1155|      0|	PROTECT(val = newval);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1156|      0|    }
 1157|  2.37k|    if (k != length(val))
  ------------------
  |  |  987|  2.37k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1157:9): [True: 0, False: 2.37k]
  ------------------
 1158|      0|	error(_("length of 'dimnames' [%d] must match that of 'dims' [%d]"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("length of 'dimnames' [%d] must match that of 'dims' [%d]"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1159|      0|	      length(val), k);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 1160|  7.11k|    for (int i = 0; i < k; i++) {
  ------------------
  |  Branch (1160:21): [True: 4.74k, False: 2.37k]
  ------------------
 1161|  4.74k|	SEXP _this = VECTOR_ELT(val, i);
 1162|  4.74k|	if (_this != R_NilValue) {
  ------------------
  |  Branch (1162:6): [True: 2.37k, False: 2.37k]
  ------------------
 1163|  2.37k|	    if (!isVector(_this))
  ------------------
  |  |  974|  2.37k|#define isVector		Rf_isVector
  ------------------
  |  Branch (1163:10): [True: 0, False: 2.37k]
  ------------------
 1164|      0|		error(_("invalid type (%s) for 'dimnames' (must be a vector)"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("invalid type (%s) for 'dimnames' (must be a vector)"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1165|      0|		      R_typeToChar(_this));
 1166|  2.37k|	    if (INTEGER(dims)[i] != LENGTH(_this) && LENGTH(_this) != 0)
  ------------------
  |  Branch (1166:10): [True: 0, False: 2.37k]
  |  Branch (1166:47): [True: 0, False: 0]
  ------------------
 1167|      0|		error(_("length of 'dimnames' [%d] not equal to array extent"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("length of 'dimnames' [%d] not equal to array extent"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1168|      0|		      i+1);
 1169|  2.37k|	    SET_VECTOR_ELT(val, i, as_char_simpl(_this));
 1170|  2.37k|	}
 1171|  4.74k|    }
 1172|  2.37k|    installAttrib(vec, R_DimNamesSymbol, val);
 1173|  2.37k|    if (isList(vec) && k == 1) {
  ------------------
  |  |  951|  2.37k|#define isList			Rf_isList
  ------------------
  |  Branch (1173:9): [True: 0, False: 2.37k]
  |  Branch (1173:24): [True: 0, False: 0]
  ------------------
 1174|      0|	SEXP top = VECTOR_ELT(val, 0);
 1175|      0|	int i = 0;
 1176|      0|	for (val = vec; !isNull(val); val = CDR(val))
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (1176:18): [True: 0, False: 0]
  ------------------
 1177|      0|	    SET_TAG(val, installTrChar(STRING_ELT(top, i++)));
  ------------------
  |  |  937|      0|#define installTrChar		Rf_installTrChar
  ------------------
 1178|      0|    }
 1179|  2.37k|    UNPROTECT(2);
  ------------------
  |  |  358|  2.37k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1180|       |
 1181|       |    /* Mark as immutable so nested complex assignment can't make the
 1182|       |       dimnames attribute inconsistent with the length */
 1183|  2.37k|    MARK_NOT_MUTABLE(val);
 1184|       |
 1185|  2.37k|    return vec;
 1186|  2.37k|}
do_dim:
 1203|     80|{
 1204|     80|    checkArity(op, args);
  ------------------
  |  | 1788|     80|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1205|     80|    check1arg(args, call, "x");
  ------------------
  |  | 1867|     80|# define check1arg		Rf_check1arg
  ------------------
 1206|       |
 1207|     80|    SEXP ans;
 1208|       |    /* DispatchOrEval internal generic: dim */
 1209|     80|    if (DispatchOrEval(call, op, "dim", args, env, &ans, 0, /* argsevald: */ 1))
  ------------------
  |  | 1887|     80|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (1209:9): [True: 0, False: 80]
  ------------------
 1210|      0|	return(ans);
 1211|     80|    PROTECT(args = ans);
  ------------------
  |  |  357|     80|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1212|     80|    ans = getAttrib(CAR(args), R_DimSymbol);
  ------------------
  |  |  924|     80|#define getAttrib		Rf_getAttrib
  ------------------
 1213|     80|    UNPROTECT(1);
  ------------------
  |  |  358|     80|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1214|     80|    return ans;
 1215|     80|}
Rf_dimgets:
 1245|  3.45k|{
 1246|  3.45k|    PROTECT(vec);
  ------------------
  |  |  357|  3.45k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1247|  3.45k|    PROTECT(val);
  ------------------
  |  |  357|  3.45k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1248|  3.45k|    if (!isVector(vec) && !isList(vec))
  ------------------
  |  |  974|  3.45k|#define isVector		Rf_isVector
  ------------------
                  if (!isVector(vec) && !isList(vec))
  ------------------
  |  |  951|      0|#define isList			Rf_isList
  ------------------
  |  Branch (1248:9): [True: 0, False: 3.45k]
  |  Branch (1248:27): [True: 0, False: 0]
  ------------------
 1249|      0|	error(_("invalid first argument, must be %s"), "vector (list or atomic)");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid first argument, must be %s"), "vector (list or atomic)");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1250|  3.45k|    if (val != R_NilValue && !isVectorAtomic(val))
  ------------------
  |  |  975|  3.45k|#define isVectorAtomic		Rf_isVectorAtomic
  ------------------
  |  Branch (1250:9): [True: 3.45k, False: 0]
  |  Branch (1250:30): [True: 0, False: 3.45k]
  ------------------
 1251|      0|	error(_("invalid second argument, must be %s"), "vector or NULL");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid second argument, must be %s"), "vector or NULL");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1252|  3.45k|    val = coerceVector(val, INTSXP);
  ------------------
  |  |  895|  3.45k|#define coerceVector		Rf_coerceVector
  ------------------
                  val = coerceVector(val, INTSXP);
  ------------------
  |  |  123|  3.45k|#define INTSXP	    13	  /* integer vectors */
  ------------------
 1253|  3.45k|    UNPROTECT(1);
  ------------------
  |  |  358|  3.45k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1254|  3.45k|    PROTECT(val);
  ------------------
  |  |  357|  3.45k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1255|       |
 1256|  3.45k|    bool err;
 1257|  3.45k|    R_xlen_t total = dim2total(val, &err);
 1258|  3.45k|    if(err) error(_("too many elements specified"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if(err) error(_("too many elements specified"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (1258:8): [True: 0, False: 3.45k]
  ------------------
 1259|  3.45k|    R_xlen_t len = xlength(vec);
  ------------------
  |  | 1049|  3.45k|#define xlength(x)		Rf_xlength(x)
  ------------------
 1260|  3.45k|    if (total != len) {
  ------------------
  |  Branch (1260:9): [True: 0, False: 3.45k]
  ------------------
 1261|      0|	error(_("dims [product %lld] do not match the length of object [%lld]"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("dims [product %lld] do not match the length of object [%lld]"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1262|      0|	      (long long)total, (long long)len);
 1263|      0|    }
 1264|       |#if 0
 1265|       |// currently it is documented that `dim<-` removes dimnames() .. but ..
 1266|       |    int ndim = LENGTH(val);
 1267|       |    SEXP odim = getAttrib0(vec, R_DimSymbol); // keep dimnames(.) if dim() entries are unchanged
 1268|       |    if((LENGTH(odim) != ndim) || memcmp((void *)INTEGER(odim),
 1269|       |					(void *)INTEGER(val), ndim * sizeof(int)))
 1270|       |#endif
 1271|  3.45k|	removeAttrib(vec, R_DimNamesSymbol);
 1272|  3.45k|    installAttrib(vec, R_DimSymbol, val);
 1273|       |
 1274|       |    /* Mark as immutable so nested complex assignment can't make the
 1275|       |       dim attribute inconsistent with the length */
 1276|  3.45k|    MARK_NOT_MUTABLE(val);
 1277|       |
 1278|  3.45k|    UNPROTECT(2);
  ------------------
  |  |  358|  3.45k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1279|  3.45k|    return vec;
 1280|  3.45k|}
R_getAttributes:
 1283|   770k|{
 1284|   770k|    if (TYPEOF(x) == ENVSXP)
  ------------------
  |  |  115|   770k|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (1284:9): [True: 0, False: 770k]
  ------------------
 1285|      0|	R_CheckStack(); /* in case attributes might lead to a cycle */
 1286|       |
 1287|   770k|    SEXP attrs = ATTRIB(x), namesattr;
 1288|   770k|    int nvalues = length(attrs);
  ------------------
  |  |  987|   770k|#define length(x)		Rf_length(x)
  ------------------
 1289|   770k|    if (isList(x)) {
  ------------------
  |  |  951|   770k|#define isList			Rf_isList
  ------------------
  |  Branch (1289:9): [True: 0, False: 770k]
  ------------------
 1290|      0|	namesattr = getAttrib(x, R_NamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 1291|      0|	if (namesattr != R_NilValue)
  ------------------
  |  Branch (1291:6): [True: 0, False: 0]
  ------------------
 1292|      0|	    nvalues++;
 1293|      0|    } else
 1294|   770k|	namesattr = R_NilValue;
 1295|       |    /* FIXME */
 1296|   770k|    if (nvalues <= 0)
  ------------------
  |  Branch (1296:9): [True: 9, False: 770k]
  ------------------
 1297|      9|	return R_NilValue;
 1298|       |    /* FIXME */
 1299|   770k|    SEXP value, names;
 1300|   770k|    PROTECT(namesattr);
  ------------------
  |  |  357|   770k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1301|   770k|    PROTECT(value = allocVector(VECSXP, nvalues));
  ------------------
  |  |  357|   770k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1302|   770k|    PROTECT(names = allocVector(STRSXP, nvalues));
  ------------------
  |  |  357|   770k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1303|   770k|    nvalues = 0;
 1304|   770k|    if (namesattr != R_NilValue) {
  ------------------
  |  Branch (1304:9): [True: 0, False: 770k]
  ------------------
 1305|      0|	SET_VECTOR_ELT(value, nvalues, namesattr);
 1306|      0|	SET_STRING_ELT(names, nvalues, PRINTNAME(R_NamesSymbol));
 1307|      0|	nvalues++;
 1308|      0|    }
 1309|  1.54M|    while (attrs != R_NilValue) {
  ------------------
  |  Branch (1309:12): [True: 770k, False: 770k]
  ------------------
 1310|   770k|	SEXP tag = TAG(attrs);
 1311|   770k|	if (TYPEOF(tag) == SYMSXP) {
  ------------------
  |  |  112|   770k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1311:6): [True: 770k, False: 0]
  ------------------
 1312|   770k|	    SET_VECTOR_ELT(value, nvalues, getAttrib(x, tag));
  ------------------
  |  |  924|   770k|#define getAttrib		Rf_getAttrib
  ------------------
 1313|   770k|	    SET_STRING_ELT(names, nvalues, PRINTNAME(tag));
 1314|   770k|	}
 1315|      0|	else { // empty tag, hence name = ""
 1316|      0|	    MARK_NOT_MUTABLE(CAR(attrs));
 1317|      0|	    SET_VECTOR_ELT(value, nvalues, CAR(attrs));
 1318|      0|	    SET_STRING_ELT(names, nvalues, R_BlankString);
 1319|      0|	}
 1320|   770k|	attrs = CDR(attrs);
 1321|   770k|	nvalues++;
 1322|   770k|    }
 1323|   770k|    setAttrib(value, R_NamesSymbol, names);
  ------------------
  |  | 1027|   770k|#define setAttrib		Rf_setAttrib
  ------------------
 1324|   770k|    UNPROTECT(3);
  ------------------
  |  |  358|   770k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1325|   770k|    return value;
 1326|   770k|}
do_attributes:
 1329|   770k|{
 1330|   770k|    checkArity(op, args);
  ------------------
  |  | 1788|   770k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1331|   770k|    check1arg(args, call, "x");
  ------------------
  |  | 1867|   770k|# define check1arg		Rf_check1arg
  ------------------
 1332|   770k|    return R_getAttributes(CAR(args));
 1333|   770k|}
do_attributesgets:
 1361|   770k|{
 1362|       |/* NOTE: The following code ensures that when an attribute list */
 1363|       |/* is attached to an object, that the "dim" attribute is always */
 1364|       |/* brought to the front of the list.  This ensures that when both */
 1365|       |/* "dim" and "dimnames" are set that the "dim" is attached first. */
 1366|       |
 1367|       |    /* Extract the arguments from the argument list */
 1368|       |
 1369|   770k|    checkArity(op, args);
  ------------------
  |  | 1788|   770k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1370|       |
 1371|   770k|    SEXP object = CAR(args),
 1372|   770k|	attrs = CADR(args), names;
 1373|       |
 1374|       |    /* Do checks before duplication */
 1375|   770k|    if (!isNewList(attrs))
  ------------------
  |  |  955|   770k|#define isNewList		Rf_isNewList
  ------------------
  |  Branch (1375:9): [True: 0, False: 770k]
  ------------------
 1376|      0|	error(_("attributes must be a list or NULL"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attributes must be a list or NULL"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1377|   770k|    int i, nattrs = length(attrs);
  ------------------
  |  |  987|   770k|#define length(x)		Rf_length(x)
  ------------------
 1378|   770k|    if (nattrs > 0) {
  ------------------
  |  Branch (1378:9): [True: 770k, False: 0]
  ------------------
 1379|   770k|	names = getAttrib(attrs, R_NamesSymbol);
  ------------------
  |  |  924|   770k|#define getAttrib		Rf_getAttrib
  ------------------
 1380|   770k|	if (names == R_NilValue)
  ------------------
  |  Branch (1380:6): [True: 0, False: 770k]
  ------------------
 1381|      0|	    error(_("attributes must be named"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("attributes must be named"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1382|  1.54M|	for (i = 1; i < nattrs; i++) {
  ------------------
  |  Branch (1382:14): [True: 770k, False: 770k]
  ------------------
 1383|   770k|	    if (STRING_ELT(names, i) == R_NilValue ||
  ------------------
  |  Branch (1383:10): [True: 0, False: 770k]
  ------------------
 1384|   770k|		CHAR(STRING_ELT(names, i))[0] == '\0') { /* all ASCII tests */
  ------------------
  |  |  203|   770k|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1384:3): [True: 0, False: 770k]
  ------------------
 1385|      0|		error(_("all attributes must have names [%d does not]"), i+1);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("all attributes must have names [%d does not]"), i+1);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1386|      0|	    }
 1387|   770k|	}
 1388|   770k|    } else
 1389|      0|	names = R_NilValue; // -Wall
 1390|       |
 1391|   770k|    PROTECT(names);
  ------------------
  |  |  357|   770k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1392|   770k|    if (object == R_NilValue) {
  ------------------
  |  Branch (1392:9): [True: 0, False: 770k]
  ------------------
 1393|      0|	if (attrs == R_NilValue) {
  ------------------
  |  Branch (1393:6): [True: 0, False: 0]
  ------------------
 1394|      0|	    UNPROTECT(1); /* names */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1395|      0|	    return R_NilValue;
 1396|      0|	} else
 1397|      0|	    PROTECT(object = allocVector(VECSXP, 0));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1398|   770k|    } else {
 1399|       |	/* Unlikely to have NAMED == 0 here.
 1400|       |	   As from R 2.7.0 we don't optimize NAMED == 1 _if_ we are
 1401|       |	   setting any attributes as an error later on would leave
 1402|       |	   'obj' changed */
 1403|   770k|	if (MAYBE_SHARED(object) || (MAYBE_REFERENCED(object) && nattrs) ||
  ------------------
  |  |  251|  1.54M|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 770k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1403:6): [True: 0, False: 770k]
  |  Branch (1403:59): [True: 770k, False: 0]
  ------------------
 1404|      0|	    ((! IS_ASSIGNMENT_CALL(call)) && MAYBE_REFERENCED(object)))
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1404:7): [True: 0, False: 0]
  ------------------
 1405|   770k|	    object = R_shallow_duplicate_attr(object);
 1406|   770k|	PROTECT(object);
  ------------------
  |  |  357|   770k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1407|   770k|    }
 1408|       |
 1409|       |
 1410|       |    /* Empty the existing attribute list */
 1411|       |
 1412|       |    /* FIXME: the code below treats pair-based structures */
 1413|       |    /* in a special way.  This can probably be dropped down */
 1414|       |    /* the road (users should never encounter pair-based lists). */
 1415|       |    /* Of course, if we want backward compatibility we can't */
 1416|       |    /* make the change. :-( */
 1417|       |
 1418|   770k|    if (isList(object))
  ------------------
  |  |  951|   770k|#define isList			Rf_isList
  ------------------
  |  Branch (1418:9): [True: 0, False: 770k]
  ------------------
 1419|      0|	setAttrib(object, R_NamesSymbol, R_NilValue);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 1420|   770k|    SET_ATTRIB(object, R_NilValue);
 1421|       |    /* We have just removed the class, but might reset it later */
 1422|   770k|    SET_OBJECT(object, 0);
 1423|       |    /* Probably need to fix up S4 bit in other cases, but
 1424|       |       definitely in this one */
 1425|   770k|    if(nattrs == 0) UNSET_S4_OBJECT(object);
  ------------------
  |  Branch (1425:8): [True: 0, False: 770k]
  ------------------
 1426|       |
 1427|       |    /* We do two passes through the attributes; the first */
 1428|       |    /* finding and transferring "dim" and the second */
 1429|       |    /* transferring the rest.  This is to ensure that */
 1430|       |    /* "dim" occurs in the attribute list before "dimnames". */
 1431|       |
 1432|   770k|    if (nattrs > 0) {
  ------------------
  |  Branch (1432:9): [True: 770k, False: 0]
  ------------------
 1433|   770k|	int i0 = -1;
 1434|  2.31M|	for (i = 0; i < nattrs; i++) {
  ------------------
  |  Branch (1434:14): [True: 1.54M, False: 770k]
  ------------------
 1435|  1.54M|	    if (!strcmp(CHAR(STRING_ELT(names, i)), "dim")) {
  ------------------
  |  |  203|  1.54M|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1435:10): [True: 0, False: 1.54M]
  ------------------
 1436|      0|		i0 = i;
 1437|      0|		setAttrib(object, R_DimSymbol, VECTOR_ELT(attrs, i));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 1438|      0|		break;
 1439|      0|	    }
 1440|  1.54M|	}
 1441|  2.31M|	for (i = 0; i < nattrs; i++) {
  ------------------
  |  Branch (1441:14): [True: 1.54M, False: 770k]
  ------------------
 1442|  1.54M|	    if (i == i0) continue;
  ------------------
  |  Branch (1442:10): [True: 0, False: 1.54M]
  ------------------
 1443|  1.54M|	    setAttrib(object, installTrChar(STRING_ELT(names, i)),
  ------------------
  |  | 1027|  1.54M|#define setAttrib		Rf_setAttrib
  ------------------
              	    setAttrib(object, installTrChar(STRING_ELT(names, i)),
  ------------------
  |  |  937|  1.54M|#define installTrChar		Rf_installTrChar
  ------------------
 1444|  1.54M|		      VECTOR_ELT(attrs, i));
 1445|  1.54M|	}
 1446|   770k|    }
 1447|   770k|    UNPROTECT(2); /* names, object */
  ------------------
  |  |  358|   770k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1448|   770k|    return object;
 1449|   770k|}
do_attr:
 1469|     45|{
 1470|     45|    SEXP argList, s, t, tag = R_NilValue, alist, ans;
 1471|     45|    const char *str;
 1472|     45|    int nargs = length(args), exact = 0;
  ------------------
  |  |  987|     45|#define length(x)		Rf_length(x)
  ------------------
 1473|     45|    enum { NONE, PARTIAL, PARTIAL2, FULL } match = NONE;
 1474|     45|    static SEXP do_attr_formals = NULL;
 1475|       |
 1476|     45|    if (do_attr_formals == NULL)
  ------------------
  |  Branch (1476:9): [True: 2, False: 43]
  ------------------
 1477|      2|	do_attr_formals = allocFormalsList3(install("x"), install("which"),
  ------------------
  |  |  866|      2|#define allocFormalsList3	Rf_allocFormalsList3
  ------------------
              	do_attr_formals = allocFormalsList3(install("x"), install("which"),
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
              	do_attr_formals = allocFormalsList3(install("x"), install("which"),
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1478|      2|					    R_ExactSymbol);
 1479|       |
 1480|     45|    argList = matchArgs_NR(do_attr_formals, args, call);
  ------------------
  |  | 1946|     45|# define matchArgs_NR		Rf_matchArgs_NR
  ------------------
 1481|       |
 1482|     45|    if (nargs < 2 || nargs > 3)
  ------------------
  |  Branch (1482:9): [True: 0, False: 45]
  |  Branch (1482:22): [True: 0, False: 45]
  ------------------
 1483|      0|	errorcall(call, "either 2 or 3 arguments are required");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 1484|       |
 1485|       |    /* argument matching */
 1486|     45|    PROTECT(argList);
  ------------------
  |  |  357|     45|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1487|     45|    s = CAR(argList);
 1488|     45|    t = CADR(argList);
 1489|     45|    if (!isString(t))
  ------------------
  |  |  966|     45|#define isString		Rf_isString
  ------------------
  |  Branch (1489:9): [True: 0, False: 45]
  ------------------
 1490|      0|	errorcall(call, _("'which' must be of mode character"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("'which' must be of mode character"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1491|     45|    if (length(t) != 1)
  ------------------
  |  |  987|     45|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1491:9): [True: 0, False: 45]
  ------------------
 1492|      0|	errorcall(call, _("exactly one attribute 'which' must be given"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("exactly one attribute 'which' must be given"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1493|       |
 1494|     45|    if (TYPEOF(s) == ENVSXP)
  ------------------
  |  |  115|     45|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (1494:9): [True: 39, False: 6]
  ------------------
 1495|     39|	R_CheckStack(); /* in case attributes might lead to a cycle */
 1496|       |
 1497|     45|    if(nargs == 3) {
  ------------------
  |  Branch (1497:8): [True: 0, False: 45]
  ------------------
 1498|      0|	exact = asLogical(CADDR(argList));
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
 1499|      0|	if(exact == NA_LOGICAL) exact = 0;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1499:5): [True: 0, False: 0]
  ------------------
 1500|      0|    }
 1501|       |
 1502|       |
 1503|     45|    if(STRING_ELT(t, 0) == NA_STRING) {
  ------------------
  |  |  433|     45|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1503:8): [True: 0, False: 45]
  ------------------
 1504|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1505|      0|	return R_NilValue;
 1506|      0|    }
 1507|     45|    str = translateChar(STRING_ELT(t, 0));
  ------------------
  |  | 1037|     45|#define translateChar		Rf_translateChar
  ------------------
 1508|     45|    size_t n = strlen(str);
 1509|       |
 1510|       |    /* try to find a match among the attributes list */
 1511|     49|    for (alist = ATTRIB(s); alist != R_NilValue; alist = CDR(alist)) {
  ------------------
  |  Branch (1511:29): [True: 8, False: 41]
  ------------------
 1512|      8|	SEXP tmp = TAG(alist);
 1513|      8|	const char *s = CHAR(PRINTNAME(tmp));
  ------------------
  |  |  203|      8|#define CHAR(x) R_CHAR(x)
  ------------------
 1514|      8|	if (! strncmp(s, str, n)) {
  ------------------
  |  Branch (1514:6): [True: 4, False: 4]
  ------------------
 1515|      4|	    if (strlen(s) == n) {
  ------------------
  |  Branch (1515:10): [True: 4, False: 0]
  ------------------
 1516|      4|		tag = tmp;
 1517|      4|		match = FULL;
  ------------------
  |  |  996|      4|#define match			Rf_match
  ------------------
 1518|      4|		break;
 1519|      4|	    }
 1520|      0|	    else if (match == PARTIAL || match == PARTIAL2) {
  ------------------
  |  |  996|      0|#define match			Rf_match
  ------------------
              	    else if (match == PARTIAL || match == PARTIAL2) {
  ------------------
  |  |  996|      0|#define match			Rf_match
  ------------------
  |  Branch (1520:15): [True: 0, False: 0]
  |  Branch (1520:35): [True: 0, False: 0]
  ------------------
 1521|       |		/* this match is partial and we already have a partial match,
 1522|       |		   so the query is ambiguous and we will return R_NilValue
 1523|       |		   unless a full match comes up.
 1524|       |		*/
 1525|      0|		match = PARTIAL2;
  ------------------
  |  |  996|      0|#define match			Rf_match
  ------------------
 1526|      0|	    } else {
 1527|      0|		tag = tmp;
 1528|      0|		match = PARTIAL;
  ------------------
  |  |  996|      0|#define match			Rf_match
  ------------------
 1529|      0|	    }
 1530|      4|	}
 1531|      8|    }
 1532|     45|    if (match == PARTIAL2) {
  ------------------
  |  |  996|     45|#define match			Rf_match
  ------------------
  |  Branch (1532:9): [True: 0, False: 45]
  ------------------
 1533|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1534|      0|	return R_NilValue;
 1535|      0|    }
 1536|       |
 1537|       |    /* Unless a full match has been found, check for a "names" attribute.
 1538|       |       This is stored via TAGs on pairlists, and via rownames on 1D arrays.
 1539|       |    */
 1540|     45|    if (match != FULL && strncmp("names", str, n) == 0) {
  ------------------
  |  |  996|     45|#define match			Rf_match
  ------------------
  |  Branch (1540:9): [True: 41, False: 4]
  |  Branch (1540:26): [True: 39, False: 2]
  ------------------
 1541|     39|	if (strlen("names") == n) {
  ------------------
  |  Branch (1541:6): [True: 0, False: 39]
  ------------------
 1542|       |	    /* we have a full match on "names", if there is such an
 1543|       |	       attribute */
 1544|      0|	    tag = R_NamesSymbol;
 1545|      0|	    match = FULL;
  ------------------
  |  |  996|      0|#define match			Rf_match
  ------------------
 1546|      0|	}
 1547|     39|	else if (match == NONE && !exact) {
  ------------------
  |  |  996|     39|#define match			Rf_match
  ------------------
  |  Branch (1547:11): [True: 39, False: 0]
  |  Branch (1547:28): [True: 39, False: 0]
  ------------------
 1548|       |	    /* no match on other attributes and a possible
 1549|       |	       partial match on "names" */
 1550|     39|	    tag = R_NamesSymbol;
 1551|     39|	    PROTECT(t = getAttrib(s, tag));
  ------------------
  |  |  357|     39|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1552|     39|	    if(t != R_NilValue && R_warn_partial_match_attr) {
  ------------------
  |  Branch (1552:9): [True: 0, False: 39]
  |  Branch (1552:28): [True: 0, False: 0]
  ------------------
 1553|      0|		SEXP cond =
 1554|      0|		    R_makePartialMatchWarningCondition(call, install(str), tag);
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 1555|      0|		PROTECT(cond);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1556|      0|		R_signalWarningCondition(cond);
 1557|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1558|      0|	    }
 1559|     39|	    UNPROTECT(2);
  ------------------
  |  |  358|     39|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1560|     39|	    return t;
 1561|     39|	}
 1562|      0|	else if (match == PARTIAL && strcmp(CHAR(PRINTNAME(tag)), "names")) {
  ------------------
  |  |  996|      0|#define match			Rf_match
  ------------------
              	else if (match == PARTIAL && strcmp(CHAR(PRINTNAME(tag)), "names")) {
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1562:11): [True: 0, False: 0]
  |  Branch (1562:31): [True: 0, False: 0]
  ------------------
 1563|       |	    /* There is a possible partial match on "names" and on another
 1564|       |	       attribute. If there really is a "names" attribute, then the
 1565|       |	       query is ambiguous and we return R_NilValue.  If there is no
 1566|       |	       "names" attribute, then the partially matched one, which is
 1567|       |	       the current value of tag, can be used. */
 1568|      0|	    if (getAttrib(s, R_NamesSymbol) != R_NilValue) {
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (1568:10): [True: 0, False: 0]
  ------------------
 1569|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1570|      0|		return R_NilValue;
 1571|      0|	    }
 1572|      0|	}
 1573|     39|    }
 1574|       |
 1575|      6|    if (match == NONE  || (exact && match != FULL)) {
  ------------------
  |  |  996|      6|#define match			Rf_match
  ------------------
                  if (match == NONE  || (exact && match != FULL)) {
  ------------------
  |  |  996|      0|#define match			Rf_match
  ------------------
  |  Branch (1575:9): [True: 2, False: 4]
  |  Branch (1575:28): [True: 0, False: 4]
  |  Branch (1575:37): [True: 0, False: 0]
  ------------------
 1576|      2|	UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1577|      2|	return R_NilValue;
 1578|      2|    }
 1579|      4|    if (match == PARTIAL && R_warn_partial_match_attr) {
  ------------------
  |  |  996|      4|#define match			Rf_match
  ------------------
  |  Branch (1579:9): [True: 0, False: 4]
  |  Branch (1579:29): [True: 0, False: 0]
  ------------------
 1580|      0|	SEXP cond =
 1581|      0|	    R_makePartialMatchWarningCondition(call, install(str), tag);
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 1582|      0|	PROTECT(cond);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1583|      0|	R_signalWarningCondition(cond);
 1584|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1585|      0|    }
 1586|       |
 1587|      4|    ans =  getAttrib(s, tag);
  ------------------
  |  |  924|      4|#define getAttrib		Rf_getAttrib
  ------------------
 1588|      4|    UNPROTECT(1);
  ------------------
  |  |  358|      4|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1589|      4|    return ans;
 1590|      6|}
do_attrgets:
 1616|     54|{
 1617|     54|    SEXP obj;
 1618|     54|    checkArity(op, args);
  ------------------
  |  | 1788|     54|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1619|       |
 1620|     54|    if(PRIMVAL(op)) { /* @<- */
  ------------------
  |  | 1347|     54|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (1347:20): [True: 0, False: 54]
  |  |  ------------------
  ------------------
 1621|      0|	SEXP input, nlist, ans, value;
 1622|      0|	PROTECT(input = allocVector(STRSXP, 1));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1623|       |
 1624|      0|	nlist = CADR(args);
 1625|      0|	if (isSymbol(nlist))
  ------------------
  |  |  953|      0|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1625:6): [True: 0, False: 0]
  ------------------
 1626|      0|	    SET_STRING_ELT(input, 0, PRINTNAME(nlist));
 1627|      0|	else if(isString(nlist) ) {
  ------------------
  |  |  966|      0|#define isString		Rf_isString
  ------------------
  |  Branch (1627:10): [True: 0, False: 0]
  ------------------
 1628|      0|	    if (LENGTH(nlist) != 1)
  ------------------
  |  Branch (1628:10): [True: 0, False: 0]
  ------------------
 1629|      0|		error(_("invalid slot name length"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("invalid slot name length"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1630|      0|	    SET_STRING_ELT(input, 0, STRING_ELT(nlist, 0));
 1631|      0|	}
 1632|      0|	else {
 1633|      0|	    error(_("invalid type '%s' for slot name"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid type '%s' for slot name"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1634|      0|		  R_typeToChar(nlist));
 1635|      0|	    return R_NilValue; /*-Wall*/
 1636|      0|	}
 1637|       |
 1638|       |	/* replace the second argument with a string */
 1639|      0|	SETCADR(args, input);
 1640|      0|	UNPROTECT(1); // 'input' is now protected
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1641|       |
 1642|       |	/* DispatchOrEval internal generic: @<- */
 1643|      0|	if(DispatchOrEval(call, op, "@<-", args, env, &ans, 0, 0))
  ------------------
  |  | 1887|      0|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (1643:5): [True: 0, False: 0]
  ------------------
 1644|      0|	    return(ans);
 1645|       |
 1646|      0|	PROTECT(value = CADDR(ans));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1647|      0|	obj = CAR(ans);
 1648|      0|	if (MAYBE_SHARED(obj) ||
  ------------------
  |  Branch (1648:6): [True: 0, False: 0]
  ------------------
 1649|      0|	    ((! IS_ASSIGNMENT_CALL(call)) && MAYBE_REFERENCED(obj)))
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1649:7): [True: 0, False: 0]
  ------------------
 1650|      0|	    PROTECT(obj = shallow_duplicate(obj));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1651|      0|	else
 1652|      0|	    PROTECT(obj);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1653|      0|	check_slot_assign(obj, input, value, env);
 1654|      0|	obj = R_do_slot_assign(obj, input, value);
 1655|      0|	UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1656|      0|	SETTER_CLEAR_NAMED(obj);
 1657|      0|	return obj;
 1658|      0|    }
 1659|     54|    else { // attr(obj, "name") <- value :
 1660|     54|	static SEXP do_attrgets_formals = NULL;
 1661|     54|	obj = CAR(args);
 1662|     54|	if (MAYBE_SHARED(obj) ||
  ------------------
  |  Branch (1662:6): [True: 12, False: 42]
  ------------------
 1663|     42|	    ((! IS_ASSIGNMENT_CALL(call)) && MAYBE_REFERENCED(obj)))
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1663:7): [True: 0, False: 42]
  ------------------
 1664|     12|	    PROTECT(obj = shallow_duplicate(obj));
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1665|     42|	else
 1666|     42|	    PROTECT(obj);
  ------------------
  |  |  357|     42|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1667|       |
 1668|       |	/* argument matching */
 1669|     54|	if (do_attrgets_formals == NULL)
  ------------------
  |  Branch (1669:6): [True: 2, False: 52]
  ------------------
 1670|      2|	    do_attrgets_formals = allocFormalsList3(install("x"), install("which"),
  ------------------
  |  |  866|      2|#define allocFormalsList3	Rf_allocFormalsList3
  ------------------
              	    do_attrgets_formals = allocFormalsList3(install("x"), install("which"),
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
              	    do_attrgets_formals = allocFormalsList3(install("x"), install("which"),
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1671|      2|						    install("value"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1672|     54|	SEXP argList = matchArgs_NR(do_attrgets_formals, args, call);
  ------------------
  |  | 1946|     54|# define matchArgs_NR		Rf_matchArgs_NR
  ------------------
 1673|     54|	PROTECT(argList);
  ------------------
  |  |  357|     54|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1674|     54|	SEXP name = CADR(argList);
 1675|     54|	SEXP val = CADDR(argList);
 1676|     54|	if (!isValidString(name) || STRING_ELT(name, 0) == NA_STRING)
  ------------------
  |  |  972|     54|#define isValidString		Rf_isValidString
  ------------------
              	if (!isValidString(name) || STRING_ELT(name, 0) == NA_STRING)
  ------------------
  |  |  433|     54|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1676:6): [True: 0, False: 54]
  |  Branch (1676:30): [True: 0, False: 54]
  ------------------
 1677|      0|	    error(_("'name' must be non-null character string"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("'name' must be non-null character string"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1678|     54|	if (XLENGTH(name) > 1)
  ------------------
  |  Branch (1678:6): [True: 0, False: 54]
  ------------------
 1679|      0|	    error(_("'name' must be a scalar string"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("'name' must be a scalar string"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1680|       |
 1681|       |	/* TODO?  if (isFactor(obj) && !strcmp(asChar(name), "levels"))
 1682|       |	 * ---         if(any_duplicated(val))
 1683|       |	 *                  error(.....)
 1684|       |	 */
 1685|     54|	setAttrib(obj, name, val);
  ------------------
  |  | 1027|     54|#define setAttrib		Rf_setAttrib
  ------------------
 1686|     54|	UNPROTECT(2);
  ------------------
  |  |  358|     54|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1687|     54|	SETTER_CLEAR_NAMED(obj);
 1688|     54|	return obj;
 1689|     54|    }
 1690|     54|}
R_do_slot:
 1822|  1.90k|SEXP R_do_slot(SEXP obj, SEXP name) {
 1823|  1.90k|    R_SLOT_INIT;
  ------------------
  |  | 1805|  1.90k|    if(!(isSymbol(name) || isScalarString(name)))			\
  |  |  ------------------
  |  |  |  |  953|  1.90k|#define isSymbol		Rf_isSymbol
  |  |  ------------------
  |  |                   if(!(isSymbol(name) || isScalarString(name)))			\
  |  |  ------------------
  |  |  |  |  965|      0|#define isScalarString		Rf_isScalarString
  |  |  ------------------
  |  |  |  Branch (1805:10): [True: 1.90k, False: 0]
  |  |  |  Branch (1805:28): [True: 0, False: 0]
  |  |  ------------------
  |  | 1806|  1.90k|	error(_("invalid type or length for slot name"));		\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("invalid type or length for slot name"));		\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 1807|  1.90k|    if(!s_dot_Data)							\
  |  |  ------------------
  |  |  |  Branch (1807:8): [True: 0, False: 1.90k]
  |  |  ------------------
  |  | 1808|  1.90k|	init_slot_handling();						\
  |  | 1809|  1.90k|    if(isString(name)) name = installTrChar(STRING_ELT(name, 0))
  |  |  ------------------
  |  |  |  |  966|  1.90k|#define isString		Rf_isString
  |  |  ------------------
  |  |                   if(isString(name)) name = installTrChar(STRING_ELT(name, 0))
  |  |  ------------------
  |  |  |  |  937|      0|#define installTrChar		Rf_installTrChar
  |  |  ------------------
  |  |  |  Branch (1809:8): [True: 0, False: 1.90k]
  |  |  ------------------
  ------------------
 1824|  1.90k|    if(name == s_dot_Data)
  ------------------
  |  Branch (1824:8): [True: 0, False: 1.90k]
  ------------------
 1825|      0|	return data_part(obj);
 1826|  1.90k|    else {
 1827|  1.90k|	SEXP value = getAttrib(obj, name);
  ------------------
  |  |  924|  1.90k|#define getAttrib		Rf_getAttrib
  ------------------
 1828|  1.90k|	if(value == R_NilValue) {
  ------------------
  |  Branch (1828:5): [True: 0, False: 1.90k]
  ------------------
 1829|      0|	    SEXP input = name, classString;
 1830|      0|	    if(name == s_dot_S3Class) /* defaults to class(obj) */
  ------------------
  |  Branch (1830:9): [True: 0, False: 0]
  ------------------
 1831|      0|		return R_data_class(obj, FALSE);
 1832|      0|	    else if(name == R_NamesSymbol &&
  ------------------
  |  Branch (1832:14): [True: 0, False: 0]
  ------------------
 1833|      0|		    TYPEOF(obj) == VECSXP) /* needed for namedList class */
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1833:7): [True: 0, False: 0]
  ------------------
 1834|      0|		return value;
 1835|      0|	    if(isSymbol(name) ) {
  ------------------
  |  |  953|      0|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1835:9): [True: 0, False: 0]
  ------------------
 1836|      0|		input = PROTECT(ScalarString(PRINTNAME(name)));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1837|      0|		classString = getAttrib(obj, R_ClassSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 1838|      0|		if(isNull(classString)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (1838:6): [True: 0, False: 0]
  ------------------
 1839|      0|		    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1840|      0|		    error(_("cannot get a slot (\"%s\") from an object of type \"%s\""),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("cannot get a slot (\"%s\") from an object of type \"%s\""),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1841|      0|			  translateChar(asChar(input)),
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
              			  translateChar(asChar(input)),
  ------------------
  |  |  882|      0|#define asChar			Rf_asChar
  ------------------
 1842|      0|			  CHAR(type2str(TYPEOF(obj))));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1843|      0|		}
 1844|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1845|      0|	    }
 1846|      0|	    else classString = R_NilValue; /* make sure it is initialized */
 1847|       |	    /* not there.  But since even NULL really does get stored, this
 1848|       |	       implies that there is no slot of this name.  Or somebody
 1849|       |	       screwed up by using attr(..) <- NULL */
 1850|       |
 1851|      0|	    error(_("no slot of name \"%s\" for this object of class \"%s\""),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("no slot of name \"%s\" for this object of class \"%s\""),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1852|      0|		  translateChar(asChar(input)),
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
              		  translateChar(asChar(input)),
  ------------------
  |  |  882|      0|#define asChar			Rf_asChar
  ------------------
 1853|      0|		  translateChar(asChar(classString)));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
              		  translateChar(asChar(classString)));
  ------------------
  |  |  882|      0|#define asChar			Rf_asChar
  ------------------
 1854|      0|	}
 1855|  1.90k|	else if(value == pseudo_NULL)
  ------------------
  |  Branch (1855:10): [True: 0, False: 1.90k]
  ------------------
 1856|      0|	    value = R_NilValue;
 1857|  1.90k|	return value;
 1858|  1.90k|    }
 1859|  1.90k|}
do_AT:
 1901|  1.90k|{
 1902|  1.90k|    SEXP  nlist, object, ans;
 1903|       |
 1904|  1.90k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.90k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1905|       |
 1906|  1.90k|    PROTECT(object = eval(CAR(args), env));
  ------------------
  |  |  357|  1.90k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1907|       |
 1908|  1.90k|    if (OBJECT(object) && ! IS_S4_OBJECT(object)) {
  ------------------
  |  Branch (1908:9): [True: 1.90k, False: 0]
  |  Branch (1908:27): [True: 0, False: 1.90k]
  ------------------
 1909|       |	//**** could modify fixSubset3Args to provide abetter error message
 1910|       |	// could also use in more places, e.g. for @<-
 1911|      0|	PROTECT(args = fixSubset3Args(call, args, env, NULL));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1912|      0|	SETCAR(args, R_mkEVPROMISE_NR(CAR(args), object));
 1913|       |	/* DispatchOrEval internal generic: @ */
 1914|      0|	if (DispatchOrEval(call, op, "@", args, env, &ans, 0, 0)) {
  ------------------
  |  | 1887|      0|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (1914:6): [True: 0, False: 0]
  ------------------
 1915|      0|	    UNPROTECT(2); /* object, args */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1916|      0|	    return ans;
 1917|      0|	}
 1918|      0|	UNPROTECT(1); /* args */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1919|       |
 1920|       |	/* fall through to handle @.Data or signal an error */
 1921|      0|    }
 1922|       |
 1923|  1.90k|    if(!isMethodsDispatchOn())
  ------------------
  |  Branch (1923:8): [True: 0, False: 1.90k]
  ------------------
 1924|      0|	error(_("formal classes cannot be used without the 'methods' package"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("formal classes cannot be used without the 'methods' package"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1925|  1.90k|    nlist = CADR(args);
 1926|       |    /* Do some checks here -- repeated in R_do_slot, but on repeat the
 1927|       |     * test expression should kick out on the first element. */
 1928|  1.90k|    if(!(isSymbol(nlist) || isScalarString(nlist)))
  ------------------
  |  |  953|  1.90k|#define isSymbol		Rf_isSymbol
  ------------------
                  if(!(isSymbol(nlist) || isScalarString(nlist)))
  ------------------
  |  |  965|      0|#define isScalarString		Rf_isScalarString
  ------------------
  |  Branch (1928:10): [True: 1.90k, False: 0]
  |  Branch (1928:29): [True: 0, False: 0]
  ------------------
 1929|      0|	error(_("invalid type or length for slot name"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid type or length for slot name"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1930|  1.90k|    if(isString(nlist)) nlist = installTrChar(STRING_ELT(nlist, 0));
  ------------------
  |  |  966|  1.90k|#define isString		Rf_isString
  ------------------
                  if(isString(nlist)) nlist = installTrChar(STRING_ELT(nlist, 0));
  ------------------
  |  |  937|      0|#define installTrChar		Rf_installTrChar
  ------------------
  |  Branch (1930:8): [True: 0, False: 1.90k]
  ------------------
 1931|  1.90k|    if(!s_dot_Data) init_slot_handling();
  ------------------
  |  Branch (1931:8): [True: 2, False: 1.90k]
  ------------------
 1932|  1.90k|    if(nlist != s_dot_Data && !IS_S4_OBJECT(object)) {
  ------------------
  |  Branch (1932:8): [True: 1.90k, False: 0]
  |  Branch (1932:31): [True: 0, False: 1.90k]
  ------------------
 1933|      0|	SEXP klass = getAttrib(object, R_ClassSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 1934|      0|	errorcall(call, _("no applicable method for `@` "
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("no applicable method for `@` "
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1935|      0|			  "applied to an object of class \"%s\""),
 1936|      0|		  length(klass) == 0 ?
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1936:5): [True: 0, False: 0]
  ------------------
 1937|      0|		  CHAR(STRING_ELT(R_data_class(object, FALSE), 0)) :
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1938|      0|		  translateChar(STRING_ELT(klass, 0)));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
 1939|      0|    }
 1940|       |
 1941|  1.90k|    ans = R_do_slot(object, nlist);
 1942|  1.90k|    UNPROTECT(1); /* object */
  ------------------
  |  |  358|  1.90k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1943|  1.90k|    return ans;
 1944|  1.90k|}
attrib.c:isOneDimensionalArray:
  114|  10.8M|{
  115|  10.8M|    if(isVector(vec) || isList(vec) || isLanguage(vec)) {
  ------------------
  |  |  974|  10.8M|#define isVector		Rf_isVector
  ------------------
                  if(isVector(vec) || isList(vec) || isLanguage(vec)) {
  ------------------
  |  |  951|    615|#define isList			Rf_isList
  ------------------
                  if(isVector(vec) || isList(vec) || isLanguage(vec)) {
  ------------------
  |  |  950|    570|#define isLanguage		Rf_isLanguage
  ------------------
  |  Branch (115:8): [True: 10.8M, False: 615]
  |  Branch (115:25): [True: 45, False: 570]
  |  Branch (115:40): [True: 570, False: 0]
  ------------------
  116|  10.8M|	SEXP s = getAttrib(vec, R_DimSymbol);
  ------------------
  |  |  924|  10.8M|#define getAttrib		Rf_getAttrib
  ------------------
  117|  10.8M|	if(TYPEOF(s) == INTSXP && LENGTH(s) == 1)
  ------------------
  |  |  123|  21.6M|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (117:5): [True: 0, False: 10.8M]
  |  Branch (117:28): [True: 0, False: 0]
  ------------------
  118|      0|	    return TRUE;
  119|  10.8M|    }
  120|  10.8M|    return false;
  121|  10.8M|}
attrib.c:row_names_gets:
   40|      6|{
   41|      6|    SEXP ans;
   42|       |
   43|      6|    if (vec == R_NilValue)
  ------------------
  |  Branch (43:9): [True: 0, False: 6]
  ------------------
   44|      0|	error(_("attempt to set an attribute on NULL"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt to set an attribute on NULL"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   45|       |
   46|      6|    if(isReal(val) && LENGTH(val) == 2 && ISNAN(REAL(val)[0]) ) {
  ------------------
  |  |  963|      6|#define isReal			Rf_isReal
  ------------------
                  if(isReal(val) && LENGTH(val) == 2 && ISNAN(REAL(val)[0]) ) {
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (46:8): [True: 0, False: 6]
  |  Branch (46:23): [True: 0, False: 0]
  ------------------
   47|       |	/* This should not happen, but if a careless user dput()s a
   48|       |	   data frame and sources the result, it will */
   49|      0|	PROTECT(vec);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
   50|      0|	PROTECT(val);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
   51|      0|	val = coerceVector(val, INTSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              	val = coerceVector(val, INTSXP);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
   52|      0|	UNPROTECT(1); /* val */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
   53|      0|	PROTECT(val);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
   54|      0|	ans =  installAttrib(vec, R_RowNamesSymbol, val);
   55|      0|	UNPROTECT(2); /* vec, val */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
   56|      0|	return ans;
   57|      0|    }
   58|      6|    if(isInteger(val)) {
  ------------------
  |  |  949|      6|#define isInteger		Rf_isInteger
  ------------------
  |  Branch (58:8): [True: 0, False: 6]
  ------------------
   59|      0|	if (ALTREP(val) && ! R_is_compact_intseq(val)) {
  ------------------
  |  Branch (59:6): [True: 0, False: 0]
  |  Branch (59:21): [True: 0, False: 0]
  ------------------
   60|       |	    // accept an ALTREP as is, but for now still allow compact
   61|       |	    // 1:n to be converted to internal compact form
   62|      0|	    PROTECT(vec);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
   63|      0|	    PROTECT(val);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
   64|      0|	    ans =  installAttrib(vec, R_RowNamesSymbol, val);
   65|      0|	    UNPROTECT(2); /* vec, val */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
   66|      0|	    return ans;
   67|      0|	}
   68|      0|	bool OK_compact = TRUE;
   69|      0|	int i, n = LENGTH(val);
   70|      0|	if(n == 2 && INTEGER_ELT(val, 0) == NA_INTEGER) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (70:5): [True: 0, False: 0]
  |  Branch (70:15): [True: 0, False: 0]
  ------------------
   71|      0|	    n = INTEGER_ELT(val, 1);
   72|      0|	} else if (n > 2) {
  ------------------
  |  Branch (72:13): [True: 0, False: 0]
  ------------------
   73|       |	    // convert an ALTREP 1:n sequence to the traditional compact form
   74|       |	    // might make sense to just keep the ALTREP sequence
   75|      0|	    if (! (R_is_compact_intseq(val) &&
  ------------------
  |  Branch (75:13): [True: 0, False: 0]
  ------------------
   76|      0|		   INTEGER_ELT(val, 0) == 1 &&
  ------------------
  |  Branch (76:6): [True: 0, False: 0]
  ------------------
   77|      0|		   INTEGER_ELT(val, n - 1) == n))
  ------------------
  |  Branch (77:6): [True: 0, False: 0]
  ------------------
   78|      0|		for(i = 0; i < n; i++)
  ------------------
  |  Branch (78:14): [True: 0, False: 0]
  ------------------
   79|      0|		    if(INTEGER_ELT(val, i) != i+1) {
  ------------------
  |  Branch (79:10): [True: 0, False: 0]
  ------------------
   80|      0|			OK_compact = false;
   81|      0|			break;
   82|      0|		    }
   83|      0|	} else OK_compact = false;
   84|      0|	if(OK_compact) {
  ------------------
  |  Branch (84:5): [True: 0, False: 0]
  ------------------
   85|       |	    /* we hide the length in an impossible integer vector */
   86|      0|	    PROTECT(vec);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
   87|      0|	    PROTECT(val = allocVector(INTSXP, 2));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
   88|      0|	    INTEGER(val)[0] = NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
   89|      0|	    INTEGER(val)[1] = n; // +n:  compacted *and* automatic row names
   90|      0|	    ans =  installAttrib(vec, R_RowNamesSymbol, val);
   91|      0|	    UNPROTECT(2); /* vec, val */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
   92|      0|	    return ans;
   93|      0|	}
   94|      6|    } else if(!isString(val))
  ------------------
  |  |  966|      6|#define isString		Rf_isString
  ------------------
  |  Branch (94:15): [True: 0, False: 6]
  ------------------
   95|      0|	error(_("row names must be 'character' or 'integer', not '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("row names must be 'character' or 'integer', not '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   96|      0|	      R_typeToChar(val));
   97|      6|    PROTECT(vec);
  ------------------
  |  |  357|      6|#define PROTECT(s)	Rf_protect(s)
  ------------------
   98|      6|    PROTECT(val);
  ------------------
  |  |  357|      6|#define PROTECT(s)	Rf_protect(s)
  ------------------
   99|      6|    ans =  installAttrib(vec, R_RowNamesSymbol, val);
  100|      6|    UNPROTECT(2); /* vec, val */
  ------------------
  |  |  358|      6|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  101|      6|    return ans;
  102|      6|}
attrib.c:installAttrib:
  374|  5.03M|{
  375|  5.03M|    SEXP t = R_NilValue; /* -Wall */
  376|       |
  377|  5.03M|    switch(TYPEOF(vec)) {
  378|      0|    case CHARSXP:
  ------------------
  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (378:5): [True: 0, False: 5.03M]
  ------------------
  379|      0|	error("cannot set an attribute on a CHARSXP");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  380|      0|	break;
  381|      0|    case SYMSXP:
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (381:5): [True: 0, False: 5.03M]
  ------------------
  382|      0|    case BUILTINSXP:
  ------------------
  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (382:5): [True: 0, False: 5.03M]
  ------------------
  383|      0|    case SPECIALSXP:
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (383:5): [True: 0, False: 5.03M]
  ------------------
  384|      0|	error(_("cannot set an attribute on a '%s'"), R_typeToChar(vec));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot set an attribute on a '%s'"), R_typeToChar(vec));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  385|  5.03M|    default:
  ------------------
  |  Branch (385:5): [True: 5.03M, False: 0]
  ------------------
  386|  5.03M|	break;
  387|  5.03M|    }
  388|       |
  389|       |    /* this does no allocation */
  390|  5.80M|    for (SEXP s = ATTRIB(vec); s != R_NilValue; s = CDR(s)) {
  ------------------
  |  Branch (390:32): [True: 776k, False: 5.03M]
  ------------------
  391|   776k|	if (TAG(s) == name) {
  ------------------
  |  Branch (391:6): [True: 78, False: 776k]
  ------------------
  392|     78|	    if (MAYBE_REFERENCED(val) && val != CAR(s))
  ------------------
  |  |  251|    156|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 2, False: 76]
  |  |  ------------------
  ------------------
  |  Branch (392:35): [True: 2, False: 0]
  ------------------
  393|      2|		val = R_FixupRHS(vec, val);
  394|     78|	    SETCAR(s, val);
  395|     78|	    return val;
  396|     78|	}
  397|   776k|	t = s; // record last attribute, if any
  398|   776k|    }
  399|       |
  400|       |    /* The usual convention is that the caller protects,
  401|       |       but a lot of existing code depends assume that
  402|       |       setAttrib/installAttrib protects its arguments */
  403|  5.03M|    PROTECT(vec); PROTECT(name); PROTECT(val);
  ------------------
  |  |  357|  5.03M|#define PROTECT(s)	Rf_protect(s)
  ------------------
                  PROTECT(vec); PROTECT(name); PROTECT(val);
  ------------------
  |  |  357|  5.03M|#define PROTECT(s)	Rf_protect(s)
  ------------------
                  PROTECT(vec); PROTECT(name); PROTECT(val);
  ------------------
  |  |  357|  5.03M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  404|  5.03M|    if (MAYBE_REFERENCED(val)) ENSURE_NAMEDMAX(val);
  ------------------
  |  |  251|  5.03M|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 1.54M, False: 3.48M]
  |  |  ------------------
  ------------------
  405|  5.03M|    SEXP s = CONS(val, R_NilValue);
  ------------------
  |  |  309|  5.03M|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  406|  5.03M|    SET_TAG(s, name);
  407|  5.03M|    if (ATTRIB(vec) == R_NilValue) SET_ATTRIB(vec, s); else SETCDR(t, s);
  ------------------
  |  Branch (407:9): [True: 4.25M, False: 776k]
  ------------------
  408|  5.03M|    UNPROTECT(3);
  ------------------
  |  |  358|  5.03M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  409|  5.03M|    return val;
  410|  5.03M|}
attrib.c:removeAttrib:
  413|  17.2k|{
  414|  17.2k|    SEXP t;
  415|  17.2k|    if(TYPEOF(vec) == CHARSXP)
  ------------------
  |  |  120|  17.2k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (415:8): [True: 0, False: 17.2k]
  ------------------
  416|      0|	error("cannot set an attribute on a CHARSXP");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  417|  17.2k|    if (name == R_NamesSymbol && isPairList(vec)) {
  ------------------
  |  |  961|  2.64k|#define isPairList		Rf_isPairList
  ------------------
  |  Branch (417:9): [True: 2.64k, False: 14.6k]
  |  Branch (417:34): [True: 102, False: 2.54k]
  ------------------
  418|    289|	for (t = vec; t != R_NilValue; t = CDR(t))
  ------------------
  |  Branch (418:16): [True: 187, False: 102]
  ------------------
  419|    187|	    SET_TAG(t, R_NilValue);
  420|    102|	return R_NilValue;
  421|    102|    }
  422|  17.1k|    else {
  423|  17.1k|	if (name == R_DimSymbol)
  ------------------
  |  Branch (423:6): [True: 2.49k, False: 14.6k]
  ------------------
  424|  2.49k|	    SET_ATTRIB(vec, stripAttrib(R_DimNamesSymbol, ATTRIB(vec)));
  425|  17.1k|	SET_ATTRIB(vec, stripAttrib(name, ATTRIB(vec)));
  426|  17.1k|	if (name == R_ClassSymbol)
  ------------------
  |  Branch (426:6): [True: 3.08k, False: 14.0k]
  ------------------
  427|  3.08k|	    SET_OBJECT(vec, 0);
  428|  17.1k|    }
  429|  17.1k|    return R_NilValue;
  430|  17.2k|}
attrib.c:stripAttrib:
  106|  35.3k|{
  107|  35.3k|    if(lst == R_NilValue) return lst;
  ------------------
  |  Branch (107:8): [True: 19.6k, False: 15.7k]
  ------------------
  108|  15.7k|    if(tag == TAG(lst)) return stripAttrib(tag, CDR(lst));
  ------------------
  |  Branch (108:8): [True: 4.71k, False: 10.9k]
  ------------------
  109|  10.9k|    SETCDR(lst, stripAttrib(tag, CDR(lst)));
  110|  10.9k|    return lst;
  111|  15.7k|}
attrib.c:lang2str:
  639|     84|{
  640|     84|  SEXP symb = CAR(obj);
  641|     84|  static SEXP if_sym = 0, while_sym, for_sym, eq_sym, gets_sym,
  642|     84|    lpar_sym, lbrace_sym, call_sym;
  643|     84|  if(!if_sym) {
  ------------------
  |  Branch (643:6): [True: 1, False: 83]
  ------------------
  644|       |    /* initialize:  another place for a hash table */
  645|      1|    if_sym = install("if");
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
  646|      1|    while_sym = install("while");
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
  647|      1|    for_sym = install("for");
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
  648|      1|    eq_sym = install("=");
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
  649|      1|    gets_sym = install("<-");
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
  650|      1|    lpar_sym = install("(");
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
  651|      1|    lbrace_sym = install("{");
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
  652|      1|    call_sym = install("call");
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
  653|      1|  }
  654|     84|  if(isSymbol(symb)) {
  ------------------
  |  |  953|     84|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (654:6): [True: 46, False: 38]
  ------------------
  655|     46|    if(symb == if_sym || symb == for_sym || symb == while_sym ||
  ------------------
  |  Branch (655:8): [True: 0, False: 46]
  |  Branch (655:26): [True: 0, False: 46]
  |  Branch (655:45): [True: 0, False: 46]
  ------------------
  656|     46|       symb == lpar_sym || symb == lbrace_sym ||
  ------------------
  |  Branch (656:8): [True: 0, False: 46]
  |  Branch (656:28): [True: 0, False: 46]
  ------------------
  657|     46|       symb == eq_sym || symb == gets_sym)
  ------------------
  |  Branch (657:8): [True: 0, False: 46]
  |  Branch (657:26): [True: 0, False: 46]
  ------------------
  658|      0|      return PRINTNAME(symb);
  659|     46|  }
  660|     84|  return PRINTNAME(call_sym);
  661|     84|}
attrib.c:createDefaultClass:
  788|    192|{
  789|    192|    int size = 0;
  790|    192|    if (part1 != R_NilValue) size++;
  ------------------
  |  Branch (790:9): [True: 64, False: 128]
  ------------------
  791|    192|    if (part2 != R_NilValue) size++;
  ------------------
  |  Branch (791:9): [True: 128, False: 64]
  ------------------
  792|    192|    if (part3 != R_NilValue) size++;
  ------------------
  |  Branch (792:9): [True: 138, False: 54]
  ------------------
  793|    192|    if (part4 != R_NilValue) size++;
  ------------------
  |  Branch (793:9): [True: 12, False: 180]
  ------------------
  794|       |
  795|    192|    if (size == 0 || part3 == R_NilValue) // .. ?
  ------------------
  |  Branch (795:9): [True: 18, False: 174]
  |  Branch (795:22): [True: 36, False: 138]
  ------------------
  796|     54|	return R_NilValue;
  797|       |
  798|    138|    SEXP res = allocVector(STRSXP, size);
  ------------------
  |  |  875|    138|#define allocVector		Rf_allocVector
  ------------------
                  SEXP res = allocVector(STRSXP, size);
  ------------------
  |  |  126|    138|#define STRSXP	    16	  /* string vectors */
  ------------------
  799|    138|    R_PreserveObject(res);
  800|       |
  801|    138|    int i = 0;
  802|    138|    if (part1 != R_NilValue) SET_STRING_ELT(res, i++, part1);
  ------------------
  |  Branch (802:9): [True: 46, False: 92]
  ------------------
  803|    138|    if (part2 != R_NilValue) SET_STRING_ELT(res, i++, part2);
  ------------------
  |  Branch (803:9): [True: 92, False: 46]
  ------------------
  804|    138|    if (part3 != R_NilValue) SET_STRING_ELT(res, i++, part3);
  ------------------
  |  Branch (804:9): [True: 138, False: 0]
  ------------------
  805|    138|    if (part4 != R_NilValue) SET_STRING_ELT(res, i, part4);
  ------------------
  |  Branch (805:9): [True: 12, False: 126]
  ------------------
  806|       |
  807|    138|    MARK_NOT_MUTABLE(res);
  808|    138|    return res;
  809|    192|}
attrib.c:checkNames:
  433|  4.24M|{
  434|  4.24M|    if (isVector(x) || isList(x) || isLanguage(x)) {
  ------------------
  |  |  974|  4.24M|#define isVector		Rf_isVector
  ------------------
                  if (isVector(x) || isList(x) || isLanguage(x)) {
  ------------------
  |  |  951|     20|#define isList			Rf_isList
  ------------------
                  if (isVector(x) || isList(x) || isLanguage(x)) {
  ------------------
  |  |  950|     20|#define isLanguage		Rf_isLanguage
  ------------------
  |  Branch (434:9): [True: 4.24M, False: 20]
  |  Branch (434:24): [True: 0, False: 20]
  |  Branch (434:37): [True: 20, False: 0]
  ------------------
  435|  4.24M|	if (!isVector(s) && !isList(s))
  ------------------
  |  |  974|  4.24M|#define isVector		Rf_isVector
  ------------------
              	if (!isVector(s) && !isList(s))
  ------------------
  |  |  951|      0|#define isList			Rf_isList
  ------------------
  |  Branch (435:6): [True: 0, False: 4.24M]
  |  Branch (435:22): [True: 0, False: 0]
  ------------------
  436|      0|	    error(_("invalid type (%s) for 'names': must be vector or NULL"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid type (%s) for 'names': must be vector or NULL"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  437|      0|		  R_typeToChar(s));
  438|  4.24M|	if (xlength(x) != xlength(s))
  ------------------
  |  | 1049|  4.24M|#define xlength(x)		Rf_xlength(x)
  ------------------
              	if (xlength(x) != xlength(s))
  ------------------
  |  | 1049|  4.24M|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (438:6): [True: 0, False: 4.24M]
  ------------------
  439|      0|	    error(_("'names' attribute [%lld] must be the same length as the vector [%lld]"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("'names' attribute [%lld] must be the same length as the vector [%lld]"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  440|      0|		  (long long)xlength(s), (long long)xlength(x));
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
              		  (long long)xlength(s), (long long)xlength(x));
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
  441|  4.24M|    }
  442|      0|    else if(IS_S4_OBJECT(x)) {
  ------------------
  |  Branch (442:13): [True: 0, False: 0]
  ------------------
  443|       |      /* leave validity checks to S4 code */
  444|      0|    }
  445|      0|    else error(_("names() applied to a non-vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  else error(_("names() applied to a non-vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  446|  4.24M|}
attrib.c:as_char_simpl:
 1096|  2.37k|{
 1097|  2.37k|    if (LENGTH(val1) == 0) return R_NilValue;
  ------------------
  |  Branch (1097:9): [True: 0, False: 2.37k]
  ------------------
 1098|       |    /* if (isObject(val1)) dispatch on as.character.foo, but we don't
 1099|       |       have the context at this point to do so */
 1100|       |
 1101|  2.37k|    if (inherits(val1, "factor"))  /* mimic as.character.factor */
  ------------------
  |  |  933|  2.37k|#define inherits		Rf_inherits
  ------------------
  |  Branch (1101:9): [True: 0, False: 2.37k]
  ------------------
 1102|      0|	return asCharacterFactor(val1);
  ------------------
  |  |  883|      0|#define asCharacterFactor	Rf_asCharacterFactor
  ------------------
 1103|  2.37k|    if (isString(val1))
  ------------------
  |  |  966|  2.37k|#define isString		Rf_isString
  ------------------
  |  Branch (1103:9): [True: 2.37k, False: 0]
  ------------------
 1104|  2.37k|	return val1;
 1105|       |    // else  mimic as.character.default :
 1106|      0|    SEXP this2 = PROTECT(coerceVector(val1, STRSXP));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1107|      0|    SET_ATTRIB(this2, R_NilValue);
 1108|      0|    SET_OBJECT(this2, 0);
 1109|      0|    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1110|      0|    return this2;
 1111|  2.37k|}
attrib.c:init_slot_handling:
 1742|      2|static void init_slot_handling(void) {
 1743|      2|    s_dot_Data = install(".Data");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1744|      2|    s_dot_S3Class = install(".S3Class");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1745|      2|    s_getDataPart = install("getDataPart");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1746|      2|    s_setDataPart = install("setDataPart");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1747|       |    /* create and preserve an object that is NOT R_NilValue, and is used
 1748|       |       to represent slots that are NULL (which an attribute can not
 1749|       |       be).  The point is not just to store NULL as a slot, but also to
 1750|       |       provide a check on invalid slot names (see get_slot below).
 1751|       |
 1752|       |       The object has to be a symbol if we're going to check identity by
 1753|       |       just looking at referential equality. */
 1754|      2|    pseudo_NULL = install("\001NULL\001");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1755|      2|}

Rf_ItemName:
  571|  1.54M|{
  572|       |  /* return  names[i]  if it is a character (>= 1 char), or NULL otherwise */
  573|  1.54M|    if (names != R_NilValue &&
  ------------------
  |  Branch (573:9): [True: 1.54M, False: 3.13k]
  ------------------
  574|  1.54M|	STRING_ELT(names, i) != R_NilValue &&
  ------------------
  |  Branch (574:2): [True: 1.54M, False: 0]
  ------------------
  575|  1.54M|	CHAR(STRING_ELT(names, i))[0] != '\0') /* length test */
  ------------------
  |  |  203|  1.54M|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (575:2): [True: 1.54M, False: 10]
  ------------------
  576|  1.54M|	return STRING_ELT(names, i);
  577|  3.14k|    else
  578|  3.14k|	return R_NilValue;
  579|  1.54M|}
do_c:
  778|   773k|{
  779|   773k|    SEXP ans;
  780|       |
  781|   773k|    checkArity(op, args);
  ------------------
  |  | 1788|   773k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  782|       |
  783|       |    /* Remove any NULL elements before dispatch so
  784|       |       they never influence the method implementation. */
  785|   773k|    args = R_listCompact(args, /* keep_first */ TRUE);
  786|       |
  787|       |    /* Attempt method dispatch. */
  788|       |
  789|       |    /* DispatchOrEval internal generic: c */
  790|   773k|    if (DispatchAnyOrEval(call, op, "c", args, env, &ans, 1, 1))
  ------------------
  |  | 1888|   773k|# define DispatchAnyOrEval      Rf_DispatchAnyOrEval
  ------------------
  |  Branch (790:9): [True: 0, False: 773k]
  ------------------
  791|       |	//      ^^^ "Any" => all args are eval()ed and checked => correct multi-arg dispatch
  792|      0|	return(ans);
  793|   773k|    PROTECT(ans);
  ------------------
  |  |  357|   773k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  794|   773k|    SEXP res = do_c_dflt(call, op, ans, env);
  795|   773k|    UNPROTECT(1);
  ------------------
  |  |  358|   773k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  796|   773k|    return res;
  797|   773k|}
do_c_dflt:
  800|   773k|{
  801|       |    /* Method dispatch has failed; run the default code. */
  802|       |    /* By default we do not recurse, but this can be over-ridden */
  803|       |    /* by an optional "recursive" argument. */
  804|       |
  805|   773k|    bool
  806|   773k|	usenames = true,
  807|   773k|	recurse = false;
  808|       |    /* this was only done for length(args) > 1 prior to 1.5.0,
  809|       |       _but_ `recursive' might be the only argument */
  810|   773k|    PROTECT(args = c_Extract_opt(args, &recurse, &usenames, call));
  ------------------
  |  |  357|   773k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  811|       |
  812|       |    /* Determine the type of the returned value. */
  813|       |    /* The strategy here is appropriate because the */
  814|       |    /* object being operated on is a pair based list. */
  815|       |
  816|   773k|    struct BindData data;
  817|       |/*    data.deparse_level = 1;  Initialize this early. */
  818|   773k|    data.ans_flags  = 0;
  819|   773k|    data.ans_length = 0;
  820|   773k|    data.ans_nnames = 0;
  821|       |
  822|   773k|    SEXP t, ans;
  823|  2.32M|    for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (823:20): [True: 1.54M, False: 773k]
  ------------------
  824|  1.54M|	if (usenames && !data.ans_nnames) {
  ------------------
  |  Branch (824:6): [True: 1.54M, False: 0]
  |  Branch (824:18): [True: 776k, False: 770k]
  ------------------
  825|   776k|	    if (!isNull(TAG(t))) data.ans_nnames = 1;
  ------------------
  |  |  956|   776k|#define isNull			Rf_isNull
  ------------------
  |  Branch (825:10): [True: 14, False: 776k]
  ------------------
  826|   776k|	    else data.ans_nnames = HasNames(CAR(t));
  827|   776k|	}
  828|  1.54M|	AnswerType(CAR(t), recurse, usenames, &data, call);
  829|  1.54M|    }
  830|       |
  831|       |    /* If a non-vector argument was encountered (perhaps a list if */
  832|       |    /* recursive is FALSE) then we must return a list.	Otherwise, */
  833|       |    /* we use the natural coercion for vector types. */
  834|       |
  835|   773k|    int mode = NILSXP;
  ------------------
  |  |  111|   773k|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  836|   773k|    if      (data.ans_flags & 512) mode = EXPRSXP;
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (836:14): [True: 0, False: 773k]
  ------------------
  837|   773k|    else if (data.ans_flags & 256) mode = VECSXP;
  ------------------
  |  |  131|   770k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (837:14): [True: 770k, False: 2.14k]
  ------------------
  838|  2.14k|    else if (data.ans_flags & 128) mode = STRSXP;
  ------------------
  |  |  126|  2.08k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (838:14): [True: 2.08k, False: 69]
  ------------------
  839|     69|    else if (data.ans_flags &  64) mode = CPLXSXP;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (839:14): [True: 0, False: 69]
  ------------------
  840|     69|    else if (data.ans_flags &  32) mode = REALSXP;
  ------------------
  |  |  124|      1|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (840:14): [True: 1, False: 68]
  ------------------
  841|     68|    else if (data.ans_flags &  16) mode = INTSXP;
  ------------------
  |  |  123|     60|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (841:14): [True: 60, False: 8]
  ------------------
  842|      8|    else if (data.ans_flags &	2) mode = LGLSXP;
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (842:14): [True: 0, False: 8]
  ------------------
  843|      8|    else if (data.ans_flags &	1) mode = RAWSXP;
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (843:14): [True: 0, False: 8]
  ------------------
  844|       |
  845|       |    /* Allocate the return value and set up to pass through */
  846|       |    /* the arguments filling in values of the returned object. */
  847|       |
  848|   773k|    PROTECT(ans = allocVector(mode, data.ans_length));
  ------------------
  |  |  357|   773k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  849|   773k|    data.ans_ptr = ans;
  850|   773k|    data.ans_length = 0;
  851|   773k|    t = args;
  852|       |
  853|   773k|    if (mode == VECSXP || mode == EXPRSXP) {
  ------------------
  |  |  131|  1.54M|#define VECSXP	    19	  /* generic vectors */
  ------------------
                  if (mode == VECSXP || mode == EXPRSXP) {
  ------------------
  |  |  132|  2.14k|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (853:9): [True: 770k, False: 2.14k]
  |  Branch (853:27): [True: 0, False: 2.14k]
  ------------------
  854|   770k|	if (!recurse) {
  ------------------
  |  Branch (854:6): [True: 770k, False: 0]
  ------------------
  855|  2.31M|	    while (args != R_NilValue) {
  ------------------
  |  Branch (855:13): [True: 1.54M, False: 770k]
  ------------------
  856|  1.54M|		ListAnswer(CAR(args), 0, &data, call);
  857|  1.54M|		args = CDR(args);
  858|  1.54M|	    }
  859|   770k|	}
  860|      0|	else ListAnswer(args, recurse, &data, call);
  861|   770k|	data.ans_length = xlength(ans);
  ------------------
  |  | 1049|   770k|#define xlength(x)		Rf_xlength(x)
  ------------------
  862|   770k|    }
  863|  2.14k|    else if (mode == STRSXP)
  ------------------
  |  |  126|  2.14k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (863:14): [True: 2.08k, False: 69]
  ------------------
  864|  2.08k|	StringAnswer(args, &data, call);
  865|     69|    else if (mode == CPLXSXP)
  ------------------
  |  |  125|     69|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (865:14): [True: 0, False: 69]
  ------------------
  866|      0|	ComplexAnswer(args, &data, call);
  867|     69|    else if (mode == REALSXP)
  ------------------
  |  |  124|     69|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (867:14): [True: 1, False: 68]
  ------------------
  868|      1|	RealAnswer(args, &data, call);
  869|     68|    else if (mode == RAWSXP)
  ------------------
  |  |  136|     68|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (869:14): [True: 0, False: 68]
  ------------------
  870|      0|	RawAnswer(args, &data, call);
  871|     68|    else if (mode == LGLSXP)
  ------------------
  |  |  121|     68|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (871:14): [True: 0, False: 68]
  ------------------
  872|      0|	LogicalAnswer(args, &data, call);
  873|     68|    else /* integer */
  874|     68|	IntegerAnswer(args, &data, call);
  875|   773k|    args = t;
  876|       |
  877|       |    /* Build and attach the names attribute for the returned object. */
  878|       |
  879|   773k|    if (data.ans_nnames && data.ans_length > 0) {
  ------------------
  |  Branch (879:9): [True: 770k, False: 2.14k]
  |  Branch (879:28): [True: 770k, False: 0]
  ------------------
  880|   770k|	PROTECT(data.ans_names = allocVector(STRSXP, data.ans_length));
  ------------------
  |  |  357|   770k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  881|   770k|	data.ans_nnames = 0;
  882|  2.31M|	while (args != R_NilValue) {
  ------------------
  |  Branch (882:9): [True: 1.54M, False: 770k]
  ------------------
  883|  1.54M|	    struct NameData nameData;
  884|  1.54M|	    nameData.seqno = 0;
  885|  1.54M|	    nameData.count = 0;
  886|  1.54M|	    NewExtractNames(CAR(args), R_NilValue, TAG(args), recurse, &data, &nameData);
  887|  1.54M|	    args = CDR(args);
  888|  1.54M|	}
  889|   770k|	setAttrib(ans, R_NamesSymbol, data.ans_names);
  ------------------
  |  | 1027|   770k|#define setAttrib		Rf_setAttrib
  ------------------
  890|   770k|	UNPROTECT(1);
  ------------------
  |  |  358|   770k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  891|   770k|    }
  892|   773k|    UNPROTECT(2);
  ------------------
  |  |  358|   773k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  893|   773k|    R_FreeStringBufferL(&cbuff);
  894|   773k|    return ans;
  895|   773k|} /* do_c */
do_unlist:
  899|     75|{
  900|     75|    SEXP ans, t;
  901|     75|    R_xlen_t i, n = 0;
  902|     75|    struct BindData data;
  903|       |
  904|       |/*    data.deparse_level = 1; */
  905|     75|    checkArity(op, args);
  ------------------
  |  | 1788|     75|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  906|       |
  907|       |    /* Attempt method dispatch. */
  908|       |
  909|       |    /* DispatchOrEval internal generic: unlist */
  910|     75|    if (DispatchOrEval(call, op, "unlist", args, env, &ans, 0, 1))
  ------------------
  |  | 1887|     75|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (910:9): [True: 0, False: 75]
  ------------------
  911|      0|	return(ans);
  912|       |
  913|       |    /* Method dispatch has failed; run the default code. */
  914|       |    /* By default we recurse, but this can be over-ridden */
  915|       |    /* by an optional "recursive" argument. */
  916|       |
  917|     75|    PROTECT(args = CAR(ans));
  ------------------
  |  |  357|     75|#define PROTECT(s)	Rf_protect(s)
  ------------------
  918|     75|    bool recurse = asBool2(CADR(ans), call);
  ------------------
  |  | 1860|     75|# define asBool2	       	Rf_asBool2
  ------------------
  919|     75|    bool usenames = asBool2(CADDR(ans), call);
  ------------------
  |  | 1860|     75|# define asBool2	       	Rf_asBool2
  ------------------
  920|     75|    bool lenient = true; // was (implicitly!) FALSE  up to R 3.0.1
  921|       |
  922|       |    /* Determine the type of the returned value. */
  923|       |    /* The strategy here is appropriate because the */
  924|       |    /* object being operated on is a generic vector. */
  925|       |
  926|     75|    data.ans_flags  = 0;
  927|     75|    data.ans_length = 0;
  928|     75|    data.ans_nnames = 0;
  929|       |
  930|     75|    if (isNewList(args)) {
  ------------------
  |  |  955|     75|#define isNewList		Rf_isNewList
  ------------------
  |  Branch (930:9): [True: 75, False: 0]
  ------------------
  931|     75|	n = xlength(args);
  ------------------
  |  | 1049|     75|#define xlength(x)		Rf_xlength(x)
  ------------------
  932|     75|	if (usenames && getAttrib(args, R_NamesSymbol) != R_NilValue)
  ------------------
  |  |  924|     75|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (932:6): [True: 75, False: 0]
  |  Branch (932:18): [True: 58, False: 17]
  ------------------
  933|     58|	    data.ans_nnames = 1;
  934|  3.20k|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (934:14): [True: 3.12k, False: 75]
  ------------------
  935|  3.12k|	    if (usenames && !data.ans_nnames)
  ------------------
  |  Branch (935:10): [True: 3.12k, False: 0]
  |  Branch (935:22): [True: 19, False: 3.10k]
  ------------------
  936|     19|		data.ans_nnames = HasNames(VECTOR_ELT(args, i));
  937|  3.12k|	    AnswerType(VECTOR_ELT(args, i), recurse, usenames, &data, call);
  938|  3.12k|	}
  939|     75|    }
  940|      0|    else if (isList(args)) {
  ------------------
  |  |  951|      0|#define isList			Rf_isList
  ------------------
  |  Branch (940:14): [True: 0, False: 0]
  ------------------
  941|      0|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (941:17): [True: 0, False: 0]
  ------------------
  942|      0|	    if (usenames && !data.ans_nnames) {
  ------------------
  |  Branch (942:10): [True: 0, False: 0]
  |  Branch (942:22): [True: 0, False: 0]
  ------------------
  943|      0|		if (!isNull(TAG(t))) data.ans_nnames = 1;
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (943:7): [True: 0, False: 0]
  ------------------
  944|      0|		else data.ans_nnames = HasNames(CAR(t));
  945|      0|	    }
  946|      0|	    AnswerType(CAR(t), recurse, usenames, &data, call);
  947|      0|	}
  948|      0|    }
  949|      0|    else {
  950|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  951|      0|	if (lenient || isVector(args)) return args;
  ------------------
  |  |  974|      0|#define isVector		Rf_isVector
  ------------------
  |  Branch (951:6): [True: 0, False: 0]
  |  Branch (951:17): [True: 0, False: 0]
  ------------------
  952|      0|	else error(_("argument not a list"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	else error(_("argument not a list"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  953|      0|    }
  954|       |
  955|       |    /* If a non-vector argument was encountered (perhaps a list if */
  956|       |    /* recursive is FALSE) then we must return a list.  Otherwise, */
  957|       |    /* we use the natural coercion for vector types. */
  958|       |
  959|     75|    int mode = NILSXP;
  ------------------
  |  |  111|     75|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  960|     75|    if      (data.ans_flags & 512) mode = EXPRSXP;
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (960:14): [True: 0, False: 75]
  ------------------
  961|     75|    else if (data.ans_flags & 256) mode = VECSXP;
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (961:14): [True: 0, False: 75]
  ------------------
  962|     75|    else if (data.ans_flags & 128) mode = STRSXP;
  ------------------
  |  |  126|     68|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (962:14): [True: 68, False: 7]
  ------------------
  963|      7|    else if (data.ans_flags &  64) mode = CPLXSXP;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (963:14): [True: 0, False: 7]
  ------------------
  964|      7|    else if (data.ans_flags &  32) mode = REALSXP;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (964:14): [True: 0, False: 7]
  ------------------
  965|      7|    else if (data.ans_flags &  16) mode = INTSXP;
  ------------------
  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (965:14): [True: 4, False: 3]
  ------------------
  966|      3|    else if (data.ans_flags &	2) mode = LGLSXP;
  ------------------
  |  |  121|      1|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (966:14): [True: 1, False: 2]
  ------------------
  967|      2|    else if (data.ans_flags &	1) mode = RAWSXP;
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (967:14): [True: 0, False: 2]
  ------------------
  968|       |
  969|       |    /* Allocate the return value and set up to pass through */
  970|       |    /* the arguments filling in values of the returned object. */
  971|       |
  972|     75|    PROTECT(ans = allocVector(mode, data.ans_length));
  ------------------
  |  |  357|     75|#define PROTECT(s)	Rf_protect(s)
  ------------------
  973|     75|    data.ans_ptr = ans;
  974|     75|    data.ans_length = 0;
  975|     75|    t = args;
  976|       |
  977|     75|    if (mode == VECSXP || mode == EXPRSXP) {
  ------------------
  |  |  131|    150|#define VECSXP	    19	  /* generic vectors */
  ------------------
                  if (mode == VECSXP || mode == EXPRSXP) {
  ------------------
  |  |  132|     75|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (977:9): [True: 0, False: 75]
  |  Branch (977:27): [True: 0, False: 75]
  ------------------
  978|      0|	if (!recurse) {
  ------------------
  |  Branch (978:6): [True: 0, False: 0]
  ------------------
  979|      0|	    if (TYPEOF(args) == VECSXP)
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (979:10): [True: 0, False: 0]
  ------------------
  980|      0|		for (i = 0; i < n; i++)
  ------------------
  |  Branch (980:15): [True: 0, False: 0]
  ------------------
  981|      0|		    ListAnswer(VECTOR_ELT(args, i), 0, &data, call);
  982|      0|	    else if (TYPEOF(args) == LISTSXP)
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (982:15): [True: 0, False: 0]
  ------------------
  983|      0|		for ( ; args != R_NilValue; args = CDR(args))
  ------------------
  |  Branch (983:11): [True: 0, False: 0]
  ------------------
  984|      0|		    ListAnswer(CAR(args), 0, &data, call);
  985|      0|	}
  986|      0|	else ListAnswer(args, recurse, &data, call);
  987|      0|	data.ans_length = xlength(ans);
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
  988|      0|    }
  989|     75|    else if (mode == STRSXP)
  ------------------
  |  |  126|     75|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (989:14): [True: 68, False: 7]
  ------------------
  990|     68|	StringAnswer(args, &data, call);
  991|      7|    else if (mode == CPLXSXP)
  ------------------
  |  |  125|      7|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (991:14): [True: 0, False: 7]
  ------------------
  992|      0|	ComplexAnswer(args, &data, call);
  993|      7|    else if (mode == REALSXP)
  ------------------
  |  |  124|      7|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (993:14): [True: 0, False: 7]
  ------------------
  994|      0|	RealAnswer(args, &data, call);
  995|      7|    else if (mode == RAWSXP)
  ------------------
  |  |  136|      7|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (995:14): [True: 0, False: 7]
  ------------------
  996|      0|	RawAnswer(args, &data, call);
  997|      7|    else if (mode == LGLSXP)
  ------------------
  |  |  121|      7|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (997:14): [True: 1, False: 6]
  ------------------
  998|      1|	LogicalAnswer(args, &data, call);
  999|      6|    else /* integer */
 1000|      6|	IntegerAnswer(args, &data, call);
 1001|     75|    args = t;
 1002|       |
 1003|       |    /* Build and attach the names attribute for the returned object. */
 1004|       |
 1005|     75|    if (data.ans_nnames && data.ans_length > 0) {
  ------------------
  |  Branch (1005:9): [True: 58, False: 17]
  |  Branch (1005:28): [True: 56, False: 2]
  ------------------
 1006|     56|	struct NameData nameData;
 1007|     56|	PROTECT(data.ans_names = allocVector(STRSXP, data.ans_length));
  ------------------
  |  |  357|     56|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1008|     56|	if (!recurse) {
  ------------------
  |  Branch (1008:6): [True: 26, False: 30]
  ------------------
 1009|     26|	    if (TYPEOF(args) == VECSXP) {
  ------------------
  |  |  131|     26|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1009:10): [True: 26, False: 0]
  ------------------
 1010|     26|		SEXP names = getAttrib(args, R_NamesSymbol);
  ------------------
  |  |  924|     26|#define getAttrib		Rf_getAttrib
  ------------------
 1011|     26|		data.ans_nnames = 0;
 1012|     26|		nameData.seqno = 0;
 1013|     26|		nameData.count = 0;
 1014|  3.10k|		for (i = 0; i < n; i++) {
  ------------------
  |  Branch (1014:15): [True: 3.07k, False: 26]
  ------------------
 1015|  3.07k|		    NewExtractNames(VECTOR_ELT(args, i), R_NilValue,
 1016|  3.07k|				    ItemName(names, i), recurse, &data, &nameData);
  ------------------
  |  | 1932|  3.07k|# define ItemName		Rf_ItemName
  ------------------
 1017|  3.07k|		}
 1018|     26|	    }
 1019|      0|	    else if (TYPEOF(args) == LISTSXP) {
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1019:15): [True: 0, False: 0]
  ------------------
 1020|      0|		data.ans_nnames = 0;
 1021|      0|		nameData.seqno = 0;
 1022|      0|		nameData.count = 0;
 1023|      0|		while (args != R_NilValue) {
  ------------------
  |  Branch (1023:10): [True: 0, False: 0]
  ------------------
 1024|      0|		    NewExtractNames(CAR(args), R_NilValue,
 1025|      0|				    TAG(args), recurse, &data, &nameData);
 1026|      0|		    args = CDR(args);
 1027|      0|		}
 1028|      0|	    }
 1029|     26|	}
 1030|     30|	else {
 1031|     30|	    data.ans_nnames = 0;
 1032|     30|	    nameData.seqno = 0;
 1033|     30|	    nameData.count = 0;
 1034|     30|	    NewExtractNames(args, R_NilValue, R_NilValue, recurse, &data, &nameData);
 1035|     30|	}
 1036|     56|	setAttrib(ans, R_NamesSymbol, data.ans_names);
  ------------------
  |  | 1027|     56|#define setAttrib		Rf_setAttrib
  ------------------
 1037|     56|	UNPROTECT(1);
  ------------------
  |  |  358|     56|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1038|     56|    }
 1039|     75|    UNPROTECT(2);
  ------------------
  |  |  358|     75|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1040|     75|    R_FreeStringBufferL(&cbuff);
 1041|     75|    return ans;
 1042|     75|} /* do_unlist */
do_bind:
 1048|     16|{
 1049|       |    // missing(deparse.level) :
 1050|     16|    bool missingDL = (isSymbol(CAR(args)) && R_missing(CAR(args), env));
  ------------------
  |  |  953|     16|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1050:23): [True: 16, False: 0]
  |  Branch (1050:46): [True: 16, False: 0]
  ------------------
 1051|       |    /* since R 2.2.0: first argument "deparse.level" */
 1052|     16|    int deparse_level = asInteger(eval(CAR(args), env));
  ------------------
  |  |  885|     16|#define asInteger		Rf_asInteger
  ------------------
                  int deparse_level = asInteger(eval(CAR(args), env));
  ------------------
  |  |  913|     16|#define eval			Rf_eval
  ------------------
 1053|     16|    bool tryS4 = deparse_level >= 0;
 1054|       |    /* NB: negative deparse_level should otherwise be equivalent to deparse_level == 0,
 1055|       |     * --  as cbind(), rbind() below only check for '== 1' and '== 2'
 1056|       |     * {FIXME: methods should do same} */
 1057|       |
 1058|       |    /* Lazy evaluation and method dispatch based on argument types are
 1059|       |     * fundamentally incompatible notions.  The results here are
 1060|       |     * ghastly.
 1061|       |     *
 1062|       |     * We build promises to evaluate the arguments and then force the
 1063|       |     * promises so that if we dispatch to a closure below, the closure
 1064|       |     * is still in a position to use "substitute" to get the actual
 1065|       |     * expressions which generated the argument (for naming purposes).
 1066|       |     *
 1067|       |     * The dispatch rule here is as follows:
 1068|       |     *
 1069|       |     * 1) For each argument we get the list of possible class
 1070|       |     *	  memberships from the class attribute.
 1071|       |     *
 1072|       |     * 2) We inspect each class in turn to see if there is an
 1073|       |     *	  applicable method.
 1074|       |     *
 1075|       |     * 3) If we find a method, we use it.  Otherwise, if there was an S4
 1076|       |     *    object among the arguments, we try S4 dispatch; otherwise, we
 1077|       |     *    use the default code.
 1078|       |     *
 1079|       |     * In versions of R up to 3.6.x, we used the following rule instead:
 1080|       |     *
 1081|       |     * 3) If we find an applicable method we make sure that it is
 1082|       |     *	  identical to any method determined for prior arguments.
 1083|       |     *	  If it is identical, we proceed, otherwise we immediately
 1084|       |     *	  drop through to the default code.
 1085|       |     */
 1086|       |
 1087|     16|    PROTECT(args = promiseArgs(args, env));
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1088|       |
 1089|     16|    const char *generic = ((PRIMVAL(op) == 1) ? "cbind" : "rbind");
  ------------------
  |  | 1347|     16|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1089:28): [True: 8, False: 8]
  ------------------
 1090|     16|    SEXP method = R_NilValue, a;
 1091|     16|    bool anyS4 = false;
 1092|     16|    char buf[512];
 1093|       |
 1094|     56|    for (a = CDR(args); a != R_NilValue && method == R_NilValue; a = CDR(a)) {
  ------------------
  |  Branch (1094:25): [True: 40, False: 16]
  |  Branch (1094:44): [True: 40, False: 0]
  ------------------
 1095|     40|	SEXP obj = PROTECT(eval(CAR(a), env));
  ------------------
  |  |  357|     40|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1096|     40|	if (tryS4 && !anyS4 && isS4(obj)) anyS4 = true;
  ------------------
  |  |  964|     40|#define isS4			Rf_isS4
  ------------------
  |  Branch (1096:6): [True: 40, False: 0]
  |  Branch (1096:15): [True: 40, False: 0]
  |  Branch (1096:25): [True: 0, False: 40]
  ------------------
 1097|     40|	if (isObject(obj)) {
  ------------------
  |  |  959|     40|#define isObject		Rf_isObject
  ------------------
  |  Branch (1097:6): [True: 0, False: 40]
  ------------------
 1098|      0|	    SEXP classlist = PROTECT(R_data_class2(obj));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1099|      0|	    for (int i = 0; i < length(classlist); i++) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1099:22): [True: 0, False: 0]
  ------------------
 1100|      0|		const char *s = translateChar(STRING_ELT(classlist, i));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
 1101|      0|		if(strlen(generic) + strlen(s) + 2 > 512)
  ------------------
  |  Branch (1101:6): [True: 0, False: 0]
  ------------------
 1102|      0|		    error(_("class name too long in '%s'"), generic);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("class name too long in '%s'"), generic);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1103|      0|		snprintf(buf, 512, "%s.%s", generic, s);
 1104|      0|		SEXP classmethod = R_LookupMethod(install(buf), env, env,
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 1105|      0|						  R_BaseNamespace);
 1106|      0|		if (classmethod != R_UnboundValue) {
  ------------------
  |  Branch (1106:7): [True: 0, False: 0]
  ------------------
 1107|      0|		    method = classmethod;
 1108|      0|		    break;
 1109|      0|		}
 1110|      0|	    }
 1111|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1112|      0|	}
 1113|     40|	UNPROTECT(1);
  ------------------
  |  |  358|     40|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1114|     40|    }
 1115|       |
 1116|     16|    tryS4 = anyS4 && (method == R_NilValue);
  ------------------
  |  Branch (1116:13): [True: 0, False: 16]
  |  Branch (1116:22): [True: 0, False: 0]
  ------------------
 1117|     16|    if (tryS4) {
  ------------------
  |  Branch (1117:9): [True: 0, False: 16]
  ------------------
 1118|       |	/* use methods:::cbind / rbind */
 1119|      0|	method = findFun(install(generic), R_MethodsNamespace);
  ------------------
  |  |  915|      0|#define findFun			Rf_findFun
  ------------------
              	method = findFun(install(generic), R_MethodsNamespace);
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 1120|      0|    }
 1121|     16|    if (method != R_NilValue) { // found an S3 or S4 method
  ------------------
  |  Branch (1121:9): [True: 0, False: 16]
  ------------------
 1122|      0|	PROTECT(method);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1123|      0|	if (missingDL)
  ------------------
  |  Branch (1123:6): [True: 0, False: 0]
  ------------------
 1124|      0|	    args = CDR(args); /* discard 'deparse.level' */
 1125|      0|	else
 1126|      0|	    SET_TAG(args, install("deparse.level")); /* tag 'deparse.level' */
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 1127|      0|	SEXP ans = applyClosure(call, method, args, env, R_NilValue, TRUE);
  ------------------
  |  |  879|      0|#define applyClosure		Rf_applyClosure
  ------------------
 1128|      0|	UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1129|      0|	return ans;
 1130|      0|    } else
 1131|     16|	args = CDR(args); /* discard 'deparse.level' */
 1132|       |
 1133|       |    /* Dispatch based on class membership has failed. */
 1134|       |    /* The default code for rbind/cbind.default follows */
 1135|       |    /* First, extract the evaluated arguments. */
 1136|     16|    SEXP rho = env;
 1137|     16|    struct BindData data;
 1138|     16|    data.ans_flags = 0;
 1139|     16|    data.ans_length = 0;
 1140|     16|    data.ans_nnames = 0;
 1141|     56|    for (SEXP t = args; t != R_NilValue; t = CDR(t))
  ------------------
  |  Branch (1141:25): [True: 40, False: 16]
  ------------------
 1142|     40|	AnswerType(PRVALUE(CAR(t)), 0, 0, &data, call);
 1143|       |
 1144|       |    /* zero-extent matrices shouldn't give NULL, but cbind(NULL) should: */
 1145|     16|    if (!data.ans_flags && !data.ans_length) {
  ------------------
  |  Branch (1145:9): [True: 0, False: 16]
  |  Branch (1145:28): [True: 0, False: 0]
  ------------------
 1146|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1147|      0|	return R_NilValue;
 1148|      0|    }
 1149|       |
 1150|     16|    int mode = NILSXP;
  ------------------
  |  |  111|     16|#define NILSXP	     0	  /* nil = NULL */
  ------------------
 1151|     16|    if      (data.ans_flags & 512) mode = EXPRSXP;
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1151:14): [True: 0, False: 16]
  ------------------
 1152|     16|    else if (data.ans_flags & 256) mode = VECSXP;
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1152:14): [True: 0, False: 16]
  ------------------
 1153|     16|    else if (data.ans_flags & 128) mode = STRSXP;
  ------------------
  |  |  126|     16|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1153:14): [True: 16, False: 0]
  ------------------
 1154|      0|    else if (data.ans_flags &  64) mode = CPLXSXP;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1154:14): [True: 0, False: 0]
  ------------------
 1155|      0|    else if (data.ans_flags &  32) mode = REALSXP;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1155:14): [True: 0, False: 0]
  ------------------
 1156|      0|    else if (data.ans_flags &  16) mode = INTSXP;
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1156:14): [True: 0, False: 0]
  ------------------
 1157|      0|    else if (data.ans_flags &	2) mode = LGLSXP;
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1157:14): [True: 0, False: 0]
  ------------------
 1158|      0|    else if (data.ans_flags &	1) mode = RAWSXP;
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1158:14): [True: 0, False: 0]
  ------------------
 1159|       |
 1160|     16|    switch(mode) {
 1161|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1161:5): [True: 0, False: 16]
  ------------------
 1162|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1162:5): [True: 0, False: 16]
  ------------------
 1163|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1163:5): [True: 0, False: 16]
  ------------------
 1164|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1164:5): [True: 0, False: 16]
  ------------------
 1165|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1165:5): [True: 0, False: 16]
  ------------------
 1166|     16|    case STRSXP:
  ------------------
  |  |  126|     16|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1166:5): [True: 16, False: 0]
  ------------------
 1167|     16|    case VECSXP:
  ------------------
  |  |  131|     16|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1167:5): [True: 0, False: 16]
  ------------------
 1168|     16|    case RAWSXP:
  ------------------
  |  |  136|     16|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1168:5): [True: 0, False: 16]
  ------------------
 1169|     16|	break;
 1170|       |	/* we don't handle expressions: we could, but coercion of a matrix
 1171|       |	   to an expression is not ideal.
 1172|       |	   FIXME?  had  cbind(y ~ x, 1) work using lists, before */
 1173|      0|    default:
  ------------------
  |  Branch (1173:5): [True: 0, False: 16]
  ------------------
 1174|      0|	error(_("cannot create a matrix from type '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot create a matrix from type '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1175|      0|	      type2char(mode)); /* mode can only be EXPRSXP here */
  ------------------
  |  | 1040|      0|#define type2char		Rf_type2char
  ------------------
 1176|     16|    }
 1177|       |
 1178|     16|    if (PRIMVAL(op) == 1)
  ------------------
  |  | 1347|     16|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1178:9): [True: 8, False: 8]
  ------------------
 1179|      8|	a = cbind(call, args, mode, rho, deparse_level);
 1180|      8|    else
 1181|      8|	a = rbind(call, args, mode, rho, deparse_level);
 1182|     16|    UNPROTECT(1);
  ------------------
  |  |  358|     16|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1183|     16|    return a;
 1184|     16|}
bind.c:c_Extract_opt:
  729|   773k|{
  730|   773k|    SEXP a, n, last = NULL, next = NULL;
  731|   773k|    int v, n_recurse = 0, n_usenames = 0;
  732|       |
  733|  2.32M|    for (a = ans; a != R_NilValue; a = next) {
  ------------------
  |  Branch (733:19): [True: 1.54M, False: 773k]
  ------------------
  734|  1.54M|	n = TAG(a);
  735|  1.54M|	next = CDR(a);
  736|  1.54M|	if (n != R_NilValue && pmatch(R_RecursiveSymbol, n, 1)) {
  ------------------
  |  | 1011|     28|#define pmatch			Rf_pmatch
  ------------------
  |  Branch (736:6): [True: 28, False: 1.54M]
  |  Branch (736:25): [True: 0, False: 28]
  ------------------
  737|      0|	    if (n_recurse++ == 1)
  ------------------
  |  Branch (737:10): [True: 0, False: 0]
  ------------------
  738|      0|		errorcall(call, _("repeated formal argument 'recursive'"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		errorcall(call, _("repeated formal argument 'recursive'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  739|      0|	    if ((v = asLogical(CAR(a))) != NA_INTEGER) {
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
              	    if ((v = asLogical(CAR(a))) != NA_INTEGER) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (739:10): [True: 0, False: 0]
  ------------------
  740|      0|		*recurse = (bool) v;
  741|      0|	    }
  742|      0|	    if (last == NULL)
  ------------------
  |  Branch (742:10): [True: 0, False: 0]
  ------------------
  743|      0|		ans = next;
  744|      0|	    else
  745|      0|		SETCDR(last, next);
  746|      0|	}
  747|  1.54M|	else if (n != R_NilValue && pmatch(R_UseNamesSymbol, n, 1)) {
  ------------------
  |  | 1011|     28|#define pmatch			Rf_pmatch
  ------------------
  |  Branch (747:11): [True: 28, False: 1.54M]
  |  Branch (747:30): [True: 0, False: 28]
  ------------------
  748|      0|	    if (n_usenames++ == 1)
  ------------------
  |  Branch (748:10): [True: 0, False: 0]
  ------------------
  749|      0|		errorcall(call, _("repeated formal argument 'use.names'"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		errorcall(call, _("repeated formal argument 'use.names'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  750|      0|	    if ((v = asLogical(CAR(a))) != NA_INTEGER) {
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
              	    if ((v = asLogical(CAR(a))) != NA_INTEGER) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (750:10): [True: 0, False: 0]
  ------------------
  751|      0|		*usenames = (bool) v;
  752|      0|	    }
  753|      0|	    if (last == NULL)
  ------------------
  |  Branch (753:10): [True: 0, False: 0]
  ------------------
  754|      0|		ans = next;
  755|      0|	    else
  756|      0|		SETCDR(last, next);
  757|      0|	}
  758|  1.54M|	else last = a;
  759|  1.54M|    }
  760|   773k|    return ans;
  761|   773k|}
bind.c:HasNames:
   57|   776k|{
   58|   776k|    if(isVector(x)) {
  ------------------
  |  |  974|   776k|#define isVector		Rf_isVector
  ------------------
  |  Branch (58:8): [True: 776k, False: 116]
  ------------------
   59|   776k|	if (!isNull(getAttrib(x, R_NamesSymbol)))
  ------------------
  |  |  956|   776k|#define isNull			Rf_isNull
  ------------------
              	if (!isNull(getAttrib(x, R_NamesSymbol)))
  ------------------
  |  |  924|   776k|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (59:6): [True: 770k, False: 5.29k]
  ------------------
   60|   770k|	    return 1;
   61|   776k|    }
   62|    116|    else if(isList(x)) {
  ------------------
  |  |  951|    116|#define isList			Rf_isList
  ------------------
  |  Branch (62:13): [True: 65, False: 51]
  ------------------
   63|     65|	while (!isNull(x)) {
  ------------------
  |  |  956|     65|#define isNull			Rf_isNull
  ------------------
  |  Branch (63:9): [True: 1, False: 64]
  ------------------
   64|      1|	    if (!isNull(TAG(x))) return 1;
  ------------------
  |  |  956|      1|#define isNull			Rf_isNull
  ------------------
  |  Branch (64:10): [True: 1, False: 0]
  ------------------
   65|      0|	    x = CDR(x);
   66|      0|	}
   67|     65|    }
   68|  5.40k|    return 0;
   69|   776k|}
bind.c:AnswerType:
   74|  1.55M|{
   75|  1.55M|    switch (TYPEOF(x)) {
   76|     64|    case NILSXP: // NULL entries are dropped
  ------------------
  |  |  111|     64|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (76:5): [True: 64, False: 1.55M]
  ------------------
   77|     64|	break;
   78|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (78:5): [True: 0, False: 1.55M]
  ------------------
   79|      0|	data->ans_flags |= 1;
   80|      0|	data->ans_length += XLENGTH(x);
   81|      0|	break;
   82|     14|    case LGLSXP:
  ------------------
  |  |  121|     14|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (82:5): [True: 14, False: 1.55M]
  ------------------
   83|     14|	data->ans_flags |= 2;
   84|     14|	data->ans_length += XLENGTH(x);
   85|     14|	break;
   86|    113|    case INTSXP:
  ------------------
  |  |  123|    113|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (86:5): [True: 113, False: 1.55M]
  ------------------
   87|    113|	data->ans_flags |= 16;
   88|    113|	data->ans_length += XLENGTH(x);
   89|    113|	break;
   90|      3|    case REALSXP:
  ------------------
  |  |  124|      3|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (90:5): [True: 3, False: 1.55M]
  ------------------
   91|      3|	data->ans_flags |= 32;
   92|      3|	data->ans_length += XLENGTH(x);
   93|      3|	break;
   94|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (94:5): [True: 0, False: 1.55M]
  ------------------
   95|      0|	data->ans_flags |= 64;
   96|      0|	data->ans_length += XLENGTH(x);
   97|      0|	break;
   98|  8.34k|    case STRSXP:
  ------------------
  |  |  126|  8.34k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (98:5): [True: 8.34k, False: 1.54M]
  ------------------
   99|  8.34k|	data->ans_flags |= 128;
  100|  8.34k|	data->ans_length += XLENGTH(x);
  101|  8.34k|	break;
  102|       |
  103|       |#ifdef DO_C_Symbol
  104|       |/* new case : */
  105|       |    case SYMSXP:
  106|       |    case LANGSXP:
  107|       |	data->ans_flags |= 512; /* as.expression() implicitly */
  108|       |	data->ans_length += 1;
  109|       |	break;
  110|       |#endif
  111|  1.54M|    case VECSXP:
  ------------------
  |  |  131|  1.54M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (111:5): [True: 1.54M, False: 8.59k]
  ------------------
  112|  1.54M|    case EXPRSXP:
  ------------------
  |  |  132|  1.54M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (112:5): [True: 0, False: 1.55M]
  ------------------
  113|  1.54M|	if (recurse) {
  ------------------
  |  Branch (113:6): [True: 0, False: 1.54M]
  ------------------
  114|      0|	    R_xlen_t i, n = XLENGTH(x);
  115|      0|	    if (usenames && !data->ans_nnames &&
  ------------------
  |  Branch (115:10): [True: 0, False: 0]
  |  Branch (115:22): [True: 0, False: 0]
  ------------------
  116|      0|		!isNull(getAttrib(x, R_NamesSymbol)))
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
              		!isNull(getAttrib(x, R_NamesSymbol)))
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (116:3): [True: 0, False: 0]
  ------------------
  117|      0|		data->ans_nnames = 1;
  118|      0|	    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (118:18): [True: 0, False: 0]
  ------------------
  119|      0|		if (usenames && !data->ans_nnames)
  ------------------
  |  Branch (119:7): [True: 0, False: 0]
  |  Branch (119:19): [True: 0, False: 0]
  ------------------
  120|      0|		    data->ans_nnames = HasNames(VECTOR_ELT(x, i));
  121|      0|		AnswerType(VECTOR_ELT(x, i), recurse, usenames, data, call);
  122|      0|	    }
  123|      0|	}
  124|  1.54M|	else {
  125|  1.54M|	    if (TYPEOF(x) == EXPRSXP)
  ------------------
  |  |  132|  1.54M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (125:10): [True: 0, False: 1.54M]
  ------------------
  126|      0|		data->ans_flags |= 512;
  127|  1.54M|	    else
  128|  1.54M|		data->ans_flags |= 256;
  129|  1.54M|	    data->ans_length += XLENGTH(x);
  130|  1.54M|	}
  131|  1.54M|	break;
  132|      2|    case LISTSXP:
  ------------------
  |  |  113|      2|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (132:5): [True: 2, False: 1.55M]
  ------------------
  133|      2|	if (recurse) {
  ------------------
  |  Branch (133:6): [True: 0, False: 2]
  ------------------
  134|      0|	    while (x != R_NilValue) {
  ------------------
  |  Branch (134:13): [True: 0, False: 0]
  ------------------
  135|      0|		if (usenames && !data->ans_nnames) {
  ------------------
  |  Branch (135:7): [True: 0, False: 0]
  |  Branch (135:19): [True: 0, False: 0]
  ------------------
  136|      0|		    if (!isNull(TAG(x))) data->ans_nnames = 1;
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (136:11): [True: 0, False: 0]
  ------------------
  137|      0|		    else data->ans_nnames = HasNames(CAR(x));
  138|      0|		}
  139|      0|		AnswerType(CAR(x), recurse, usenames, data, call);
  140|      0|		x = CDR(x);
  141|      0|	    }
  142|      0|	}
  143|      2|	else {
  144|      2|	    data->ans_flags |= 256;
  145|      2|	    data->ans_length += length(x);
  ------------------
  |  |  987|      2|#define length(x)		Rf_length(x)
  ------------------
  146|      2|	}
  147|      2|	break;
  148|     52|    default:
  ------------------
  |  Branch (148:5): [True: 52, False: 1.55M]
  ------------------
  149|     52|	data->ans_flags |= 256;
  150|     52|	data->ans_length += 1;
  151|     52|	break;
  152|  1.55M|    }
  153|       |
  154|       |    /* check for overflow in ans_length. Objects are added one at a
  155|       |       time for each call to AnswerType so it is safe to check here.
  156|       |       Since sizes are signed, positive numbers, the overflow will
  157|       |       manifest itself as a negative result (both numbers will be
  158|       |       31-bit so we cannot overflow across the 32-bit boundary). If
  159|       |       our assumption (all lengths are signed) is violated, this won't
  160|       |       work so check when switching length types! */
  161|       |
  162|       |#ifndef LONG_VECTOR_SUPPORT
  163|       |    if (data->ans_length < 0)
  164|       |	errorcall(call, _("resulting vector exceeds vector length limit in '%s'"), "AnswerType");
  165|       |#endif
  166|  1.55M|}
bind.c:ListAnswer:
  174|  1.54M|{
  175|  1.54M|    R_xlen_t i;
  176|       |
  177|  1.54M|    switch(TYPEOF(x)) {
  178|      8|    case NILSXP: // NULL entries are dropped
  ------------------
  |  |  111|      8|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (178:5): [True: 8, False: 1.54M]
  ------------------
  179|      8|	break;
  180|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (180:5): [True: 0, False: 1.54M]
  ------------------
  181|      0|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (181:14): [True: 0, False: 0]
  ------------------
  182|      0|	    LIST_ASSIGN(ScalarLogical(LOGICAL(x)[i]));
  ------------------
  |  |   38|      0|#define LIST_ASSIGN(x) {SET_VECTOR_ELT(data->ans_ptr, data->ans_length, x); data->ans_length++;}
  ------------------
  183|      0|	break;
  184|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (184:5): [True: 0, False: 1.54M]
  ------------------
  185|      0|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (185:14): [True: 0, False: 0]
  ------------------
  186|      0|	    LIST_ASSIGN(ScalarRaw(RAW(x)[i]));
  ------------------
  |  |   38|      0|#define LIST_ASSIGN(x) {SET_VECTOR_ELT(data->ans_ptr, data->ans_length, x); data->ans_length++;}
  ------------------
  187|      0|	break;
  188|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (188:5): [True: 0, False: 1.54M]
  ------------------
  189|      0|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (189:14): [True: 0, False: 0]
  ------------------
  190|      0|	    LIST_ASSIGN(ScalarInteger(INTEGER(x)[i]));
  ------------------
  |  |   38|      0|#define LIST_ASSIGN(x) {SET_VECTOR_ELT(data->ans_ptr, data->ans_length, x); data->ans_length++;}
  ------------------
  191|      0|	break;
  192|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (192:5): [True: 0, False: 1.54M]
  ------------------
  193|      0|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (193:14): [True: 0, False: 0]
  ------------------
  194|      0|	    LIST_ASSIGN(ScalarReal(REAL(x)[i]));
  ------------------
  |  |   38|      0|#define LIST_ASSIGN(x) {SET_VECTOR_ELT(data->ans_ptr, data->ans_length, x); data->ans_length++;}
  ------------------
  195|      0|	break;
  196|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (196:5): [True: 0, False: 1.54M]
  ------------------
  197|      0|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (197:14): [True: 0, False: 0]
  ------------------
  198|      0|	    LIST_ASSIGN(ScalarComplex(COMPLEX(x)[i]));
  ------------------
  |  |   38|      0|#define LIST_ASSIGN(x) {SET_VECTOR_ELT(data->ans_ptr, data->ans_length, x); data->ans_length++;}
  ------------------
  199|      0|	break;
  200|      0|    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (200:5): [True: 0, False: 1.54M]
  ------------------
  201|      0|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (201:14): [True: 0, False: 0]
  ------------------
  202|      0|	    LIST_ASSIGN(ScalarString(STRING_ELT(x, i)));
  ------------------
  |  |   38|      0|#define LIST_ASSIGN(x) {SET_VECTOR_ELT(data->ans_ptr, data->ans_length, x); data->ans_length++;}
  ------------------
  203|      0|	break;
  204|  1.54M|    case VECSXP:
  ------------------
  |  |  131|  1.54M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (204:5): [True: 1.54M, False: 62]
  ------------------
  205|  1.54M|    case EXPRSXP:
  ------------------
  |  |  132|  1.54M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (205:5): [True: 0, False: 1.54M]
  ------------------
  206|  1.54M|	if (recurse) {
  ------------------
  |  Branch (206:6): [True: 0, False: 1.54M]
  ------------------
  207|      0|	    for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (207:18): [True: 0, False: 0]
  ------------------
  208|      0|		ListAnswer(VECTOR_ELT(x, i), recurse, data, call);
  209|      0|	}
  210|  1.54M|	else {
  211|  3.08M|	    for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (211:18): [True: 1.54M, False: 1.54M]
  ------------------
  212|  1.54M|		LIST_ASSIGN(lazy_duplicate(VECTOR_ELT(x, i)));
  ------------------
  |  |   38|  1.54M|#define LIST_ASSIGN(x) {SET_VECTOR_ELT(data->ans_ptr, data->ans_length, x); data->ans_length++;}
  ------------------
  213|  1.54M|	}
  214|  1.54M|	break;
  215|      2|    case LISTSXP:
  ------------------
  |  |  113|      2|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (215:5): [True: 2, False: 1.54M]
  ------------------
  216|      2|	if (recurse) {
  ------------------
  |  Branch (216:6): [True: 0, False: 2]
  ------------------
  217|      0|	    while (x != R_NilValue) {
  ------------------
  |  Branch (217:13): [True: 0, False: 0]
  ------------------
  218|      0|		ListAnswer(CAR(x), recurse, data, call);
  219|      0|		x = CDR(x);
  220|      0|	    }
  221|      0|	}
  222|      2|	else
  223|      5|	    while (x != R_NilValue) {
  ------------------
  |  Branch (223:13): [True: 3, False: 2]
  ------------------
  224|      3|		LIST_ASSIGN(lazy_duplicate(CAR(x)));
  ------------------
  |  |   38|      3|#define LIST_ASSIGN(x) {SET_VECTOR_ELT(data->ans_ptr, data->ans_length, x); data->ans_length++;}
  ------------------
  225|      3|		x = CDR(x);
  226|      3|	    }
  227|      2|	break;
  228|     52|    default:
  ------------------
  |  Branch (228:5): [True: 52, False: 1.54M]
  ------------------
  229|     52|	LIST_ASSIGN(lazy_duplicate(x));
  ------------------
  |  |   38|     52|#define LIST_ASSIGN(x) {SET_VECTOR_ELT(data->ans_ptr, data->ans_length, x); data->ans_length++;}
  ------------------
  230|     52|	break;
  231|  1.54M|    }
  232|  1.54M|}
bind.c:StringAnswer:
  236|  10.5k|{
  237|  10.5k|    R_xlen_t i;
  238|  10.5k|    switch(TYPEOF(x)) {
  239|     48|    case NILSXP:
  ------------------
  |  |  111|     48|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (239:5): [True: 48, False: 10.4k]
  ------------------
  240|     48|	break;
  241|  2.08k|    case LISTSXP:
  ------------------
  |  |  113|  2.08k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (241:5): [True: 2.08k, False: 8.42k]
  ------------------
  242|  7.31k|	while (x != R_NilValue) {
  ------------------
  |  Branch (242:9): [True: 5.23k, False: 2.08k]
  ------------------
  243|  5.23k|	    StringAnswer(CAR(x), data, call);
  244|  5.23k|	    x = CDR(x);
  245|  5.23k|	}
  246|  2.08k|	break;
  247|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (247:5): [True: 0, False: 10.5k]
  ------------------
  248|     68|    case VECSXP:
  ------------------
  |  |  131|     68|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (248:5): [True: 68, False: 10.4k]
  ------------------
  249|  3.18k|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (249:14): [True: 3.11k, False: 68]
  ------------------
  250|  3.11k|	    StringAnswer(VECTOR_ELT(x, i), data, call);
  251|     68|	break;
  252|  8.30k|    default:
  ------------------
  |  Branch (252:5): [True: 8.30k, False: 2.19k]
  ------------------
  253|  8.30k|	PROTECT(x = coerceVector(x, STRSXP));
  ------------------
  |  |  357|  8.30k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  254|   129k|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (254:14): [True: 120k, False: 8.30k]
  ------------------
  255|   120k|	    SET_STRING_ELT(data->ans_ptr, data->ans_length++, STRING_ELT(x, i));
  256|  8.30k|	UNPROTECT(1);
  ------------------
  |  |  358|  8.30k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  257|  8.30k|	break;
  258|  10.5k|    }
  259|  10.5k|}
bind.c:RealAnswer:
  337|      4|{
  338|      4|    R_xlen_t i;
  339|      4|    int xi;
  340|      4|    switch(TYPEOF(x)) {
  341|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (341:5): [True: 0, False: 4]
  ------------------
  342|      0|	break;
  343|      1|    case LISTSXP:
  ------------------
  |  |  113|      1|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (343:5): [True: 1, False: 3]
  ------------------
  344|      4|	while (x != R_NilValue) {
  ------------------
  |  Branch (344:9): [True: 3, False: 1]
  ------------------
  345|      3|	    RealAnswer(CAR(x), data, call);
  346|      3|	    x = CDR(x);
  347|      3|	}
  348|      1|	break;
  349|      0|    case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (349:5): [True: 0, False: 4]
  ------------------
  350|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (350:5): [True: 0, False: 4]
  ------------------
  351|      0|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (351:14): [True: 0, False: 0]
  ------------------
  352|      0|	    RealAnswer(VECTOR_ELT(x, i), data, call);
  353|      0|	break;
  354|      3|    case REALSXP:
  ------------------
  |  |  124|      3|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (354:5): [True: 3, False: 1]
  ------------------
  355|      6|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (355:14): [True: 3, False: 3]
  ------------------
  356|      3|	    REAL(data->ans_ptr)[data->ans_length++] = REAL(x)[i];
  357|      3|	break;
  358|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (358:5): [True: 0, False: 4]
  ------------------
  359|      0|	for (i = 0; i < XLENGTH(x); i++) {
  ------------------
  |  Branch (359:14): [True: 0, False: 0]
  ------------------
  360|      0|	    xi = LOGICAL(x)[i];
  361|      0|	    if (xi == NA_LOGICAL)
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (361:10): [True: 0, False: 0]
  ------------------
  362|      0|		REAL(data->ans_ptr)[data->ans_length++] = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  363|      0|	    else REAL(data->ans_ptr)[data->ans_length++] = xi;
  364|      0|	}
  365|      0|	break;
  366|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (366:5): [True: 0, False: 4]
  ------------------
  367|      0|	for (i = 0; i < XLENGTH(x); i++) {
  ------------------
  |  Branch (367:14): [True: 0, False: 0]
  ------------------
  368|      0|	    xi = INTEGER(x)[i];
  369|      0|	    if (xi == NA_INTEGER)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (369:10): [True: 0, False: 0]
  ------------------
  370|      0|		REAL(data->ans_ptr)[data->ans_length++] = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  371|      0|	    else REAL(data->ans_ptr)[data->ans_length++] = xi;
  372|      0|	}
  373|      0|	break;
  374|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (374:5): [True: 0, False: 4]
  ------------------
  375|      0|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (375:14): [True: 0, False: 0]
  ------------------
  376|      0|	    REAL(data->ans_ptr)[data->ans_length++] = (int)RAW(x)[i];
  377|      0|	break;
  378|      0|    default:
  ------------------
  |  Branch (378:5): [True: 0, False: 4]
  ------------------
  379|      0|	errorcall(call, _("type '%s' is unimplemented in '%s'"),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("type '%s' is unimplemented in '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  380|      0|		  R_typeToChar(x), "RealAnswer");
  381|      4|    }
  382|      4|}
bind.c:LogicalAnswer:
  263|      4|{
  264|      4|    R_xlen_t i;
  265|      4|    switch(TYPEOF(x)) {
  266|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (266:5): [True: 0, False: 4]
  ------------------
  267|      0|	break;
  268|      0|    case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (268:5): [True: 0, False: 4]
  ------------------
  269|      0|	while (x != R_NilValue) {
  ------------------
  |  Branch (269:9): [True: 0, False: 0]
  ------------------
  270|      0|	    LogicalAnswer(CAR(x), data, call);
  271|      0|	    x = CDR(x);
  272|      0|	}
  273|      0|	break;
  274|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (274:5): [True: 0, False: 4]
  ------------------
  275|      1|    case VECSXP:
  ------------------
  |  |  131|      1|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (275:5): [True: 1, False: 3]
  ------------------
  276|      4|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (276:14): [True: 3, False: 1]
  ------------------
  277|      3|	    LogicalAnswer(VECTOR_ELT(x, i), data, call);
  278|      1|	break;
  279|      3|    case LGLSXP:
  ------------------
  |  |  121|      3|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (279:5): [True: 3, False: 1]
  ------------------
  280|      6|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (280:14): [True: 3, False: 3]
  ------------------
  281|      3|	    LOGICAL(data->ans_ptr)[data->ans_length++] = LOGICAL(x)[i];
  282|      3|	break;
  283|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (283:5): [True: 0, False: 4]
  ------------------
  284|      0|	for (i = 0; i < XLENGTH(x); i++) {
  ------------------
  |  Branch (284:14): [True: 0, False: 0]
  ------------------
  285|      0|	    int v = INTEGER(x)[i];
  286|      0|	    LOGICAL(data->ans_ptr)[data->ans_length++] = (v == NA_INTEGER) ? NA_LOGICAL : ( v != 0 );
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
              	    LOGICAL(data->ans_ptr)[data->ans_length++] = (v == NA_INTEGER) ? NA_LOGICAL : ( v != 0 );
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (286:51): [True: 0, False: 0]
  ------------------
  287|      0|	}
  288|      0|	break;
  289|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (289:5): [True: 0, False: 4]
  ------------------
  290|      0|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (290:14): [True: 0, False: 0]
  ------------------
  291|      0|	    LOGICAL(data->ans_ptr)[data->ans_length++] = (int)RAW(x)[i] != 0;
  292|      0|	break;
  293|      0|    default:
  ------------------
  |  Branch (293:5): [True: 0, False: 4]
  ------------------
  294|      0|	errorcall(call, _("type '%s' is unimplemented in '%s'"),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("type '%s' is unimplemented in '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  295|      0|		  R_typeToChar(x), "LogicalAnswer");
  296|      4|    }
  297|      4|}
bind.c:IntegerAnswer:
  301|    206|{
  302|    206|    R_xlen_t i;
  303|    206|    switch(TYPEOF(x)) {
  304|      8|    case NILSXP:
  ------------------
  |  |  111|      8|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (304:5): [True: 8, False: 198]
  ------------------
  305|      8|	break;
  306|     68|    case LISTSXP:
  ------------------
  |  |  113|     68|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (306:5): [True: 68, False: 138]
  ------------------
  307|    196|	while (x != R_NilValue) {
  ------------------
  |  Branch (307:9): [True: 128, False: 68]
  ------------------
  308|    128|	    IntegerAnswer(CAR(x), data, call);
  309|    128|	    x = CDR(x);
  310|    128|	}
  311|     68|	break;
  312|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (312:5): [True: 0, False: 206]
  ------------------
  313|      6|    case VECSXP:
  ------------------
  |  |  131|      6|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (313:5): [True: 6, False: 200]
  ------------------
  314|     10|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (314:14): [True: 4, False: 6]
  ------------------
  315|      4|	    IntegerAnswer(VECTOR_ELT(x, i), data, call);
  316|      6|	break;
  317|     11|    case LGLSXP:
  ------------------
  |  |  121|     11|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (317:5): [True: 11, False: 195]
  ------------------
  318|     22|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (318:14): [True: 11, False: 11]
  ------------------
  319|     11|	    INTEGER(data->ans_ptr)[data->ans_length++] = LOGICAL(x)[i];
  320|     11|	break;
  321|    113|    case INTSXP:
  ------------------
  |  |  123|    113|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (321:5): [True: 113, False: 93]
  ------------------
  322|    658|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (322:14): [True: 545, False: 113]
  ------------------
  323|    545|	    INTEGER(data->ans_ptr)[data->ans_length++] = INTEGER(x)[i];
  324|    113|	break;
  325|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (325:5): [True: 0, False: 206]
  ------------------
  326|      0|	for (i = 0; i < XLENGTH(x); i++)
  ------------------
  |  Branch (326:14): [True: 0, False: 0]
  ------------------
  327|      0|	    INTEGER(data->ans_ptr)[data->ans_length++] = (int)RAW(x)[i];
  328|      0|	break;
  329|      0|    default:
  ------------------
  |  Branch (329:5): [True: 0, False: 206]
  ------------------
  330|      0|	errorcall(call, _("type '%s' is unimplemented in '%s'"),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("type '%s' is unimplemented in '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  331|      0|		  R_typeToChar(x), "IntegerAnswer");
  332|    206|    }
  333|    206|}
bind.c:NewExtractNames:
  648|  1.54M|{
  649|  1.54M|    SEXP names, namei;
  650|  1.54M|    R_xlen_t i, n;
  651|  1.54M|    int savecount=0;
  652|  1.54M|    R_xlen_t saveseqno;
  653|       |
  654|       |    /* If we have a new tag, we reset the index
  655|       |     * sequence and create the new basename string : */
  656|  1.54M|    if (tag != R_NilValue) {
  ------------------
  |  Branch (656:9): [True: 3.13k, False: 1.54M]
  ------------------
  657|  3.13k|	PROTECT(base = NewBase(base, tag));
  ------------------
  |  |  357|  3.13k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  658|  3.13k|	saveseqno = nameData->seqno;
  659|  3.13k|	savecount = nameData->count;
  660|  3.13k|	nameData->count = 0;
  661|  3.13k|	namesCount(v, recurse, nameData);
  662|  3.13k|	nameData->seqno = 0;
  663|  3.13k|    }
  664|  1.54M|    else saveseqno = 0;
  665|       |
  666|  1.54M|    n = xlength(v);
  ------------------
  |  | 1049|  1.54M|#define xlength(x)		Rf_xlength(x)
  ------------------
  667|  1.54M|    PROTECT(names = getAttrib(v, R_NamesSymbol));
  ------------------
  |  |  357|  1.54M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  668|       |
  669|  1.54M|    switch(TYPEOF(v)) {
  670|     18|    case NILSXP:
  ------------------
  |  |  111|     18|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (670:5): [True: 18, False: 1.54M]
  ------------------
  671|     18|	break;
  672|      2|    case LISTSXP:
  ------------------
  |  |  113|      2|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (672:5): [True: 2, False: 1.54M]
  ------------------
  673|      5|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (673:14): [True: 3, False: 2]
  ------------------
  674|      3|	    PROTECT(namei = ItemName(names, i));
  ------------------
  |  |  357|      3|#define PROTECT(s)	Rf_protect(s)
  ------------------
  675|      3|	    if (recurse) {
  ------------------
  |  Branch (675:10): [True: 0, False: 3]
  ------------------
  676|      0|		NewExtractNames(CAR(v), base, namei, recurse, data, nameData);
  677|      0|	    }
  678|      3|	    else {
  679|      3|		namei = NewName(base, namei, ++(nameData->seqno), nameData->count);
  680|      3|		SET_STRING_ELT(data->ans_names, (data->ans_nnames)++, namei);
  681|      3|	    }
  682|      3|	    v = CDR(v);
  683|      3|	    UNPROTECT(1); /*namei*/
  ------------------
  |  |  358|      3|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  684|      3|	}
  685|      2|	break;
  686|  1.54M|    case VECSXP:
  ------------------
  |  |  131|  1.54M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (686:5): [True: 1.54M, False: 3.31k]
  ------------------
  687|  1.54M|    case EXPRSXP:
  ------------------
  |  |  132|  1.54M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (687:5): [True: 0, False: 1.54M]
  ------------------
  688|  3.08M|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (688:14): [True: 1.54M, False: 1.54M]
  ------------------
  689|  1.54M|	    namei = ItemName(names, i);
  ------------------
  |  | 1932|  1.54M|# define ItemName		Rf_ItemName
  ------------------
  690|  1.54M|	    if (recurse) {
  ------------------
  |  Branch (690:10): [True: 30, False: 1.54M]
  ------------------
  691|     30|		NewExtractNames(VECTOR_ELT(v, i), base, namei, recurse, data, nameData);
  692|     30|	    }
  693|  1.54M|	    else {
  694|  1.54M|		namei = NewName(base, namei, ++(nameData->seqno), nameData->count);
  695|  1.54M|		SET_STRING_ELT(data->ans_names, (data->ans_nnames)++, namei);
  696|  1.54M|	    }
  697|  1.54M|	}
  698|  1.54M|	break;
  699|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (699:5): [True: 0, False: 1.54M]
  ------------------
  700|      4|    case INTSXP:
  ------------------
  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (700:5): [True: 4, False: 1.54M]
  ------------------
  701|      4|    case REALSXP:
  ------------------
  |  |  124|      4|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (701:5): [True: 0, False: 1.54M]
  ------------------
  702|      4|    case CPLXSXP:
  ------------------
  |  |  125|      4|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (702:5): [True: 0, False: 1.54M]
  ------------------
  703|  3.29k|    case STRSXP:
  ------------------
  |  |  126|  3.29k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (703:5): [True: 3.29k, False: 1.54M]
  ------------------
  704|  3.29k|    case RAWSXP:
  ------------------
  |  |  136|  3.29k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (704:5): [True: 0, False: 1.54M]
  ------------------
  705|  7.84k|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (705:14): [True: 4.55k, False: 3.29k]
  ------------------
  706|  4.55k|	    namei = ItemName(names, i);
  ------------------
  |  | 1932|  4.55k|# define ItemName		Rf_ItemName
  ------------------
  707|  4.55k|	    namei = NewName(base, namei, ++(nameData->seqno), nameData->count);
  708|  4.55k|	    SET_STRING_ELT(data->ans_names, (data->ans_nnames)++, namei);
  709|  4.55k|	}
  710|  3.29k|	break;
  711|      1|    default:
  ------------------
  |  Branch (711:5): [True: 1, False: 1.54M]
  ------------------
  712|      1|	namei = NewName(base, R_NilValue, ++(nameData->seqno), nameData->count);
  713|      1|	SET_STRING_ELT(data->ans_names, (data->ans_nnames)++, namei);
  714|  1.54M|    }
  715|  1.54M|    if (tag != R_NilValue) {
  ------------------
  |  Branch (715:9): [True: 3.13k, False: 1.54M]
  ------------------
  716|  3.13k|	nameData->count = savecount;
  717|  3.13k|	UNPROTECT(1);
  ------------------
  |  |  358|  3.13k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  718|  3.13k|    }
  719|  1.54M|    UNPROTECT(1); /*names*/
  ------------------
  |  |  358|  1.54M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  720|  1.54M|    nameData->seqno = nameData->seqno + saveseqno;
  721|  1.54M|}
bind.c:NewBase:
  494|  3.13k|{
  495|  3.13k|    SEXP ans;
  496|  3.13k|    char *cbuf;
  497|  3.13k|    base = EnsureString(base);
  ------------------
  |  | 1894|  3.13k|# define EnsureString 		Rf_EnsureString
  ------------------
  498|  3.13k|    tag = EnsureString(tag);
  ------------------
  |  | 1894|  3.13k|# define EnsureString 		Rf_EnsureString
  ------------------
  499|  3.13k|    if (*CHAR(base) && *CHAR(tag)) { /* test of length */
  ------------------
  |  |  203|  6.26k|#define CHAR(x) R_CHAR(x)
  ------------------
                  if (*CHAR(base) && *CHAR(tag)) { /* test of length */
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (499:9): [True: 0, False: 3.13k]
  |  Branch (499:24): [True: 0, False: 0]
  ------------------
  500|      0|	const void *vmax = vmaxget();
  501|      0|	const char *sb = translateCharUTF8(base), *st = translateCharUTF8(tag);
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
              	const char *sb = translateCharUTF8(base), *st = translateCharUTF8(tag);
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  502|      0|	size_t sz = strlen(st) + strlen(sb) + 1;
  503|      0|	cbuf = R_AllocStringBuffer(sz, &cbuff);
  504|      0|	snprintf(cbuf, sz + 1, "%s.%s", sb, st);
  505|       |	/* This isn't strictly correct as we do not know that all the
  506|       |	   components of the name were correctly translated. */
  507|      0|	ans = mkCharCE(cbuf, CE_UTF8);
  ------------------
  |  |  999|      0|#define mkCharCE		Rf_mkCharCE
  ------------------
  508|      0|	vmaxset(vmax);
  509|      0|    }
  510|  3.13k|    else if (*CHAR(tag)) {
  ------------------
  |  |  203|  3.13k|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (510:14): [True: 3.13k, False: 0]
  ------------------
  511|  3.13k|	ans = tag;
  512|  3.13k|    }
  513|      0|    else if (*CHAR(base)) {
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (513:14): [True: 0, False: 0]
  ------------------
  514|      0|	ans = base;
  515|      0|    }
  516|      0|    else ans = R_BlankString;
  517|  3.13k|    return ans;
  518|  3.13k|}
bind.c:namesCount:
  598|  3.13k|{
  599|  3.13k|    R_xlen_t i, n = xlength(v);
  ------------------
  |  | 1049|  3.13k|#define xlength(x)		Rf_xlength(x)
  ------------------
  600|  3.13k|    SEXP names = PROTECT(getAttrib(v, R_NamesSymbol)), namei;
  ------------------
  |  |  357|  3.13k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  601|       |
  602|       |    /* The  "<= 1"  in every for() loop, i.e., for all "vector" cases,
  603|       |       makes this much faster for large vector 'v'
  604|       |       _and_ prevents ("almost surely") overflow of nameData->count.
  605|       |       -->  PR#17284 and PR#17292, with thanks to Suharto Anggono.
  606|       |    */
  607|  3.13k|    switch(TYPEOF(v)) {
  608|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (608:5): [True: 0, False: 3.13k]
  ------------------
  609|      0|	break;
  610|      0|    case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (610:5): [True: 0, False: 3.13k]
  ------------------
  611|      0|	if (recurse) {
  ------------------
  |  Branch (611:6): [True: 0, False: 0]
  ------------------
  612|      0|	    for (i = 0; i < n && nameData->count <= 1; i++) {
  ------------------
  |  Branch (612:18): [True: 0, False: 0]
  |  Branch (612:27): [True: 0, False: 0]
  ------------------
  613|      0|		PROTECT(namei = ItemName(names, i));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  614|      0|		if (namei == R_NilValue)
  ------------------
  |  Branch (614:7): [True: 0, False: 0]
  ------------------
  615|      0|		    namesCount(CAR(v), recurse, nameData);
  616|      0|		v = CDR(v);
  617|      0|		UNPROTECT(1); /*namei*/
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  618|      0|	    }
  619|      0|	    break;
  620|      0|	} /* else fall through */
  621|      0|    case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (621:5): [True: 0, False: 3.13k]
  ------------------
  622|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (622:5): [True: 0, False: 3.13k]
  ------------------
  623|      0|	if (recurse) {
  ------------------
  |  Branch (623:6): [True: 0, False: 0]
  ------------------
  624|      0|	    for (i = 0; i < n && nameData->count <= 1; i++) {
  ------------------
  |  Branch (624:18): [True: 0, False: 0]
  |  Branch (624:27): [True: 0, False: 0]
  ------------------
  625|      0|		namei = ItemName(names, i);
  ------------------
  |  | 1932|      0|# define ItemName		Rf_ItemName
  ------------------
  626|      0|		if (namei == R_NilValue)
  ------------------
  |  Branch (626:7): [True: 0, False: 0]
  ------------------
  627|      0|		    namesCount(VECTOR_ELT(v, i), recurse, nameData);
  628|      0|	    }
  629|      0|	    break;
  630|      0|	} /* else fall through */
  631|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (631:5): [True: 0, False: 3.13k]
  ------------------
  632|      4|    case INTSXP:
  ------------------
  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (632:5): [True: 4, False: 3.13k]
  ------------------
  633|      4|    case REALSXP:
  ------------------
  |  |  124|      4|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (633:5): [True: 0, False: 3.13k]
  ------------------
  634|      4|    case CPLXSXP:
  ------------------
  |  |  125|      4|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (634:5): [True: 0, False: 3.13k]
  ------------------
  635|  3.13k|    case STRSXP:
  ------------------
  |  |  126|  3.13k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (635:5): [True: 3.13k, False: 4]
  ------------------
  636|  3.13k|    case RAWSXP:
  ------------------
  |  |  136|  3.13k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (636:5): [True: 0, False: 3.13k]
  ------------------
  637|  6.26k|	for (i = 0; i < n && nameData->count <= 1; i++)
  ------------------
  |  Branch (637:14): [True: 3.13k, False: 3.13k]
  |  Branch (637:23): [True: 3.13k, False: 0]
  ------------------
  638|  3.13k|	    nameData->count++;
  639|  3.13k|	break;
  640|      0|    default:
  ------------------
  |  Branch (640:5): [True: 0, False: 3.13k]
  ------------------
  641|      0|	nameData->count++;
  642|  3.13k|    }
  643|  3.13k|    UNPROTECT(1); /*names*/
  ------------------
  |  |  358|  3.13k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  644|  3.13k|}
bind.c:NewName:
  521|  1.54M|{
  522|       |/* Construct a new Name/Tag, using
  523|       | *	base.tag
  524|       | *	base
  525|       | *	base<seqno>	or
  526|       | *	tag
  527|       | *
  528|       | */
  529|  1.54M|    SEXP ans;
  530|  1.54M|    base = EnsureString(base);
  ------------------
  |  | 1894|  1.54M|# define EnsureString 		Rf_EnsureString
  ------------------
  531|  1.54M|    tag = EnsureString(tag);
  ------------------
  |  | 1894|  1.54M|# define EnsureString 		Rf_EnsureString
  ------------------
  532|  1.54M|    if (*CHAR(base)) {
  ------------------
  |  |  203|  1.54M|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (532:9): [True: 3.13k, False: 1.54M]
  ------------------
  533|  3.13k|	if (*CHAR(tag)) {
  ------------------
  |  |  203|  3.13k|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (533:6): [True: 12, False: 3.12k]
  ------------------
  534|     12|	    const void *vmax = vmaxget();
  535|     12|	    const char
  536|     12|		*sb = translateCharUTF8(base),
  ------------------
  |  | 1039|     12|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  537|     12|		*st = translateCharUTF8(tag);
  ------------------
  |  | 1039|     12|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  538|     12|	    size_t sz = strlen(sb) + strlen(st) + 1;
  539|     12|	    char *cbuf = R_AllocStringBuffer(sz, &cbuff);
  540|     12|	    snprintf(cbuf, sz + 1, "%s.%s", sb, st);
  541|     12|	    ans = mkCharCE(cbuf, CE_UTF8);
  ------------------
  |  |  999|     12|#define mkCharCE		Rf_mkCharCE
  ------------------
  542|     12|	    vmaxset(vmax);
  543|     12|	}
  544|  3.12k|	else if (count == 1)
  ------------------
  |  Branch (544:11): [True: 3.12k, False: 0]
  ------------------
  545|  3.12k|	    ans = base;
  546|      0|	else {
  547|      0|	    const void *vmax = vmaxget();
  548|      0|	    const char *sb = translateCharUTF8(base);
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  549|      0|	    char *cbuf;
  550|      0|	    size_t sz = strlen(sb) + (size_t) IndexWidth(seqno) + 1;
  ------------------
  |  |   48|      0|#define IndexWidth    Rf_IndexWidth
  ------------------
  551|      0|	    cbuf = R_AllocStringBuffer(sz, &cbuff);
  552|      0|#ifdef LONG_VECTOR_SUPPORT
  553|      0|	    if (seqno > INT_MAX)
  ------------------
  |  Branch (553:10): [True: 0, False: 0]
  ------------------
  554|      0|		snprintf(cbuf, sz + 1, "%s%.0f", sb, (double) seqno);
  555|      0|	    else
  556|      0|#endif
  557|      0|		snprintf(cbuf, sz + 1, "%s%d", sb, (int) seqno);
  558|      0|	    ans = mkCharCE(cbuf, CE_UTF8);
  ------------------
  |  |  999|      0|#define mkCharCE		Rf_mkCharCE
  ------------------
  559|      0|	    vmaxset(vmax);
  560|      0|	}
  561|  3.13k|    }
  562|  1.54M|    else if (*CHAR(tag)) {
  ------------------
  |  |  203|  1.54M|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (562:14): [True: 1.54M, False: 11]
  ------------------
  563|  1.54M|	ans = tag;
  564|  1.54M|    } else
  565|     11|	ans = R_BlankString;
  566|  1.54M|    return ans;
  567|  1.54M|}
bind.c:cbind:
 1212|      8|{
 1213|      8|    bool have_rnames = false, have_cnames = false, warned = false;
 1214|      8|    int nnames, mnames;
 1215|      8|    int rows, cols, mrows, lenmin = 0;
 1216|      8|    SEXP dn, t, u, result, dims, expr;
 1217|       |
 1218|      8|    nnames = 0;
 1219|      8|    mnames = 0;
 1220|      8|    rows = 0;
 1221|      8|    cols = 0;
 1222|      8|    mrows = -1;
 1223|       |
 1224|       |    /* check if we are in the zero-row case */
 1225|       |
 1226|      8|    for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1226:20): [True: 8, False: 0]
  ------------------
 1227|      8|	u = PRVALUE(CAR(t));
 1228|      8|	if((isMatrix(u) ? nrows(u) : length(u)) > 0) {
  ------------------
  |  |  954|      8|#define isMatrix		Rf_isMatrix
  ------------------
              	if((isMatrix(u) ? nrows(u) : length(u)) > 0) {
  ------------------
  |  | 1008|      8|#define nrows			Rf_nrows
  ------------------
              	if((isMatrix(u) ? nrows(u) : length(u)) > 0) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1228:5): [True: 8, False: 0]
  |  Branch (1228:6): [True: 8, False: 0]
  ------------------
 1229|      8|	    lenmin = 1;
 1230|      8|	    break;
 1231|      8|	}
 1232|      8|    }
 1233|       |
 1234|       |    /* check conformability of matrix arguments */
 1235|       |
 1236|      8|    int na = 0;
 1237|     32|    for (t = args; t != R_NilValue; t = CDR(t), na++) {
  ------------------
  |  Branch (1237:20): [True: 24, False: 8]
  ------------------
 1238|     24|	u = PRVALUE(CAR(t));
 1239|     24|	dims = getAttrib(u, R_DimSymbol);
  ------------------
  |  |  924|     24|#define getAttrib		Rf_getAttrib
  ------------------
 1240|     24|	if (length(dims) == 2) {
  ------------------
  |  |  987|     24|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1240:6): [True: 8, False: 16]
  ------------------
 1241|      8|	    if (mrows == -1)
  ------------------
  |  Branch (1241:10): [True: 8, False: 0]
  ------------------
 1242|      8|		mrows = INTEGER(dims)[0];
 1243|      0|	    else if (mrows != INTEGER(dims)[0])
  ------------------
  |  Branch (1243:15): [True: 0, False: 0]
  ------------------
 1244|      0|		error(_("number of rows of matrices must match (see arg %d)"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("number of rows of matrices must match (see arg %d)"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1245|      0|		      na + 1);
 1246|      8|	    cols += INTEGER(dims)[1];
 1247|      8|	}
 1248|     16|	else if (length(u) >= lenmin) {
  ------------------
  |  |  987|     16|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1248:11): [True: 16, False: 0]
  ------------------
 1249|     16|	    rows = imax2(rows, length(u));
  ------------------
  |  |   31|     16|#define imax2(x, y) ((x < y) ? y : x)
  |  |  ------------------
  |  |  |  Branch (31:22): [True: 8, False: 8]
  |  |  ------------------
  ------------------
 1250|     16|	    cols += 1;
 1251|     16|	}
 1252|     24|    }
 1253|      8|    if (mrows != -1) rows = mrows;
  ------------------
  |  Branch (1253:9): [True: 8, False: 0]
  ------------------
 1254|       |
 1255|       |    /* Check conformability of vector arguments. -- Look for dimnames. */
 1256|       |
 1257|     32|    for (t = args, na = 0; t != R_NilValue; t = CDR(t), na++) {
  ------------------
  |  Branch (1257:28): [True: 24, False: 8]
  ------------------
 1258|     24|	u = PRVALUE(CAR(t));
 1259|     24|	dims = getAttrib(u, R_DimSymbol);
  ------------------
  |  |  924|     24|#define getAttrib		Rf_getAttrib
  ------------------
 1260|     24|	if (length(dims) == 2) {
  ------------------
  |  |  987|     24|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1260:6): [True: 8, False: 16]
  ------------------
 1261|      8|	    dn = getAttrib(u, R_DimNamesSymbol);
  ------------------
  |  |  924|      8|#define getAttrib		Rf_getAttrib
  ------------------
 1262|      8|	    if (length(dn) == 2) {
  ------------------
  |  |  987|      8|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1262:10): [True: 0, False: 8]
  ------------------
 1263|      0|		if (VECTOR_ELT(dn, 1) != R_NilValue)
  ------------------
  |  Branch (1263:7): [True: 0, False: 0]
  ------------------
 1264|      0|		    have_cnames = true;
 1265|      0|		if (VECTOR_ELT(dn, 0) != R_NilValue)
  ------------------
  |  Branch (1265:7): [True: 0, False: 0]
  ------------------
 1266|      0|		    mnames = mrows;
 1267|      0|	    }
 1268|     16|	} else {
 1269|     16|	    int k = length(u);
  ------------------
  |  |  987|     16|#define length(x)		Rf_length(x)
  ------------------
 1270|     16|	    if (!warned && k > 0 && (k > rows || rows % k)) {
  ------------------
  |  Branch (1270:10): [True: 16, False: 0]
  |  Branch (1270:21): [True: 16, False: 0]
  |  Branch (1270:31): [True: 0, False: 16]
  |  Branch (1270:43): [True: 0, False: 16]
  ------------------
 1271|      0|		warned = true;
 1272|      0|		warning("number of rows of result is not a multiple of vector length (arg %d)", na + 1);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
 1273|      0|	    }
 1274|     16|	    PROTECT(dn = getAttrib(u, R_NamesSymbol));
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1275|     16|	    if (k >= lenmin && (TAG(t) != R_NilValue ||
  ------------------
  |  Branch (1275:10): [True: 16, False: 0]
  |  Branch (1275:26): [True: 0, False: 16]
  ------------------
 1276|     16|				(deparse_level == 2) ||
  ------------------
  |  Branch (1276:5): [True: 0, False: 16]
  ------------------
 1277|     16|				((deparse_level == 1) &&
  ------------------
  |  Branch (1277:6): [True: 16, False: 0]
  ------------------
 1278|     16|				 isSymbol(substitute(CAR(t),R_NilValue)))))
  ------------------
  |  |  953|     16|#define isSymbol		Rf_isSymbol
  ------------------
              				 isSymbol(substitute(CAR(t),R_NilValue)))))
  ------------------
  |  | 1035|     16|#define substitute		Rf_substitute
  ------------------
  |  Branch (1278:6): [True: 8, False: 8]
  ------------------
 1279|      8|		have_cnames = true;
 1280|     16|	    nnames = imax2(nnames, length(dn));
  ------------------
  |  |   31|     16|#define imax2(x, y) ((x < y) ? y : x)
  |  |  ------------------
  |  |  |  Branch (31:22): [True: 0, False: 16]
  |  |  ------------------
  ------------------
 1281|     16|	    UNPROTECT(1); /* dn */
  ------------------
  |  |  358|     16|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1282|     16|	}
 1283|     24|    }
 1284|      8|    if (mnames || nnames == rows)
  ------------------
  |  Branch (1284:9): [True: 0, False: 8]
  |  Branch (1284:19): [True: 0, False: 8]
  ------------------
 1285|      0|	have_rnames = true;
 1286|       |
 1287|      8|    PROTECT(result = allocMatrix(mode, rows, cols));
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1288|      8|    R_xlen_t n = 0; // index, possibly of long vector
 1289|       |
 1290|      8|    if (mode == STRSXP) {
  ------------------
  |  |  126|      8|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1290:9): [True: 8, False: 0]
  ------------------
 1291|     32|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1291:17): [True: 24, False: 8]
  ------------------
 1292|     24|	    u = PRVALUE(CAR(t));
 1293|     24|	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  954|     24|#define isMatrix		Rf_isMatrix
  ------------------
              	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  987|     16|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1293:10): [True: 8, False: 16]
  |  Branch (1293:25): [True: 16, False: 0]
  ------------------
 1294|     24|		u = coerceVector(u, STRSXP);
  ------------------
  |  |  895|     24|#define coerceVector		Rf_coerceVector
  ------------------
              		u = coerceVector(u, STRSXP);
  ------------------
  |  |  126|     24|#define STRSXP	    16	  /* string vectors */
  ------------------
 1295|     24|		R_xlen_t k = XLENGTH(u);
 1296|     24|		R_xlen_t idx = (!isMatrix(u)) ? rows : k;
  ------------------
  |  |  954|     24|#define isMatrix		Rf_isMatrix
  ------------------
  |  Branch (1296:18): [True: 16, False: 8]
  ------------------
 1297|     24|		xcopyStringWithRecycle(result, u, n, idx, k);
 1298|     24|		n += idx;
 1299|     24|	    }
 1300|     24|	}
 1301|      8|    }
 1302|      0|    else if (mode == VECSXP) {
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1302:14): [True: 0, False: 0]
  ------------------
 1303|      0|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1303:17): [True: 0, False: 0]
  ------------------
 1304|      0|	    u = PRVALUE(CAR(t));
 1305|      0|	    int umatrix = isMatrix(u); /* might be lost in coercion to VECSXP */
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
 1306|      0|	    if (umatrix || length(u) >= lenmin) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1306:10): [True: 0, False: 0]
  |  Branch (1306:21): [True: 0, False: 0]
  ------------------
 1307|       |		/* we cannot assume here that coercion will work */
 1308|      0|		switch(TYPEOF(u)) {
 1309|      0|		case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1309:3): [True: 0, False: 0]
  ------------------
 1310|      0|		case LANGSXP:
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (1310:3): [True: 0, False: 0]
  ------------------
 1311|      0|		case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1311:3): [True: 0, False: 0]
  ------------------
 1312|      0|		case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1312:3): [True: 0, False: 0]
  ------------------
 1313|      0|		case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1313:3): [True: 0, False: 0]
  ------------------
 1314|      0|		case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1314:3): [True: 0, False: 0]
  ------------------
 1315|      0|		case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1315:3): [True: 0, False: 0]
  ------------------
 1316|      0|		case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1316:3): [True: 0, False: 0]
  ------------------
 1317|      0|		case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1317:3): [True: 0, False: 0]
  ------------------
 1318|      0|		case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1318:3): [True: 0, False: 0]
  ------------------
 1319|      0|		    PROTECT(u = coerceVector(u, mode));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1320|      0|		    R_xlen_t k = XLENGTH(u);
 1321|      0|		    if (k > 0) {
  ------------------
  |  Branch (1321:11): [True: 0, False: 0]
  ------------------
 1322|      0|			R_xlen_t idx = (!umatrix) ? rows : k;
  ------------------
  |  Branch (1322:19): [True: 0, False: 0]
  ------------------
 1323|      0|			R_xlen_t i, i1;
 1324|      0|			MOD_ITERATE1(idx, k, i, i1, {
  ------------------
  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |   68|      0|	i = i1 = 0;					\
  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  ------------------
  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |   64|      0|		}							\
  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1325|      0|			    SET_VECTOR_ELT(result, n++,
 1326|      0|				lazy_duplicate(VECTOR_ELT(u, i1)));
 1327|      0|			});
 1328|      0|		    }
 1329|      0|		    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1330|      0|		    break;
 1331|      0|		default:
  ------------------
  |  Branch (1331:3): [True: 0, False: 0]
  ------------------
 1332|      0|		    for (int i = 0; i < rows; i++)
  ------------------
  |  Branch (1332:23): [True: 0, False: 0]
  ------------------
 1333|      0|			SET_VECTOR_ELT(result, n++, lazy_duplicate(u));
  ------------------
  |  |  985|      0|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
 1334|      0|		}
 1335|      0|	    }
 1336|      0|	}
 1337|      0|    }
 1338|      0|    else if (mode == CPLXSXP) {
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1338:14): [True: 0, False: 0]
  ------------------
 1339|      0|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1339:17): [True: 0, False: 0]
  ------------------
 1340|      0|	    u = PRVALUE(CAR(t));
 1341|      0|	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1341:10): [True: 0, False: 0]
  |  Branch (1341:25): [True: 0, False: 0]
  ------------------
 1342|      0|		u = coerceVector(u, CPLXSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              		u = coerceVector(u, CPLXSXP);
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
 1343|      0|		R_xlen_t k = XLENGTH(u);
 1344|      0|		R_xlen_t idx = (!isMatrix(u)) ? rows : k;
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
  |  Branch (1344:18): [True: 0, False: 0]
  ------------------
 1345|      0|		xcopyComplexWithRecycle(COMPLEX(result), COMPLEX(u), n, idx, k);
 1346|      0|		n += idx;
 1347|      0|	    }
 1348|      0|	}
 1349|      0|    }
 1350|      0|    else if (mode == RAWSXP) {
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1350:14): [True: 0, False: 0]
  ------------------
 1351|      0|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1351:17): [True: 0, False: 0]
  ------------------
 1352|      0|	    u = PRVALUE(CAR(t));
 1353|      0|	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1353:10): [True: 0, False: 0]
  |  Branch (1353:25): [True: 0, False: 0]
  ------------------
 1354|      0|		u = coerceVector(u, RAWSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              		u = coerceVector(u, RAWSXP);
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
 1355|      0|		R_xlen_t k = XLENGTH(u);
 1356|      0|		R_xlen_t idx = (!isMatrix(u)) ? rows : k;
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
  |  Branch (1356:18): [True: 0, False: 0]
  ------------------
 1357|      0|		xcopyRawWithRecycle(RAW(result), RAW(u), n, idx, k);
 1358|      0|		n += idx;
 1359|      0|	    }
 1360|      0|	}
 1361|      0|    }
 1362|      0|    else { /* everything else, currently NILSXP, REALSXP, INTSXP, LGLSXP */
 1363|      0|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1363:17): [True: 0, False: 0]
  ------------------
 1364|      0|	    u = PRVALUE(CAR(t)); /* type of u can be any of: RAW, LGL, INT, REAL, or NULL */
 1365|      0|	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1365:10): [True: 0, False: 0]
  |  Branch (1365:25): [True: 0, False: 0]
  ------------------
 1366|      0|		R_xlen_t k = xlength(u); /* use xlength since u can be NULL */
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
 1367|      0|		R_xlen_t idx = (!isMatrix(u)) ? rows : k;
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
  |  Branch (1367:18): [True: 0, False: 0]
  ------------------
 1368|      0|		if (idx > 0 && TYPEOF(u) <= INTSXP) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1368:7): [True: 0, False: 0]
  |  Branch (1368:18): [True: 0, False: 0]
  ------------------
 1369|       |		    /* NILSXP or INT or LGL
 1370|       |		     * taking INTERER(NILSXP) should segfault, and
 1371|       |		     * sometimes does.  But if cbind-ing a NULL, there
 1372|       |		     * are zero rows and u is not a matrix, so nothing to do. */
 1373|      0|		    if (mode <= INTSXP) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1373:11): [True: 0, False: 0]
  ------------------
 1374|      0|			xcopyIntegerWithRecycle(INTEGER(result), INTEGER(u),
 1375|      0|						n, idx, k);
 1376|      0|			n += idx;
 1377|      0|		    }
 1378|      0|		    else {
 1379|      0|			R_xlen_t i, i1;
 1380|      0|			MOD_ITERATE1(idx, k, i, i1, {
  ------------------
  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |   68|      0|	i = i1 = 0;					\
  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  ------------------
  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   64|      0|		}							\
  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1381|      0|			    REAL(result)[n++] =
 1382|      0|				(INTEGER(u)[i1]) == NA_INTEGER ? NA_REAL : INTEGER(u)[i1];
 1383|      0|			});
 1384|      0|		    }
 1385|      0|		}
 1386|      0|		else if (TYPEOF(u) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1386:12): [True: 0, False: 0]
  ------------------
 1387|      0|		    xcopyRealWithRecycle(REAL(result), REAL(u), n, idx, k);
 1388|      0|		    n += idx;
 1389|      0|		}
 1390|      0|		else { /* u is a RAWSXP */
 1391|       |		    /* FIXME: I'm not sure what the author intended when the sequence was
 1392|       |		       defined as raw < logical -- it is possible to represent logical as
 1393|       |		       raw losslessly but not vice versa. So due to the way this was
 1394|       |		       defined the raw -> logical conversion is bound to be lossy .. 
 1395|       |		       But it is not: logicals include NAs, raws do not.
 1396|       |*/
 1397|      0|		    if (mode == LGLSXP) {
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1397:11): [True: 0, False: 0]
  ------------------
 1398|      0|			R_xlen_t i, i1;
 1399|      0|			MOD_ITERATE1(idx, k, i, i1, {
  ------------------
  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |   68|      0|	i = i1 = 0;					\
  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  ------------------
  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   64|      0|		}							\
  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1400|      0|			    LOGICAL(result)[n++] = RAW(u)[i1] ? TRUE : FALSE;
 1401|      0|			});
 1402|      0|		    } else if (mode == INTSXP) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1402:18): [True: 0, False: 0]
  ------------------
 1403|      0|			R_xlen_t i, i1;
 1404|      0|			MOD_ITERATE1(idx, k, i, i1, {
  ------------------
  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |   68|      0|	i = i1 = 0;					\
  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  ------------------
  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |   64|      0|		}							\
  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1405|      0|			    INTEGER(result)[n++] = (unsigned char) RAW(u)[i1];
 1406|      0|			});
 1407|      0|		    } else if (mode == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1407:18): [True: 0, False: 0]
  ------------------
 1408|      0|			R_xlen_t i, i1;
 1409|      0|			MOD_ITERATE1(idx, k, i, i1, {
  ------------------
  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |   68|      0|	i = i1 = 0;					\
  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  ------------------
  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |   64|      0|		}							\
  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1410|      0|			    REAL(result)[n++] = (unsigned char) RAW(u)[i1];
 1411|      0|			});
 1412|      0|		    } else
 1413|       |			/* not sure this can be reached, but to be safe: */
 1414|       |                        /* `mode` is created in do_bind(), it can only
 1415|       |                         be one of: NILSXP, LGLSXP, INTSXP, REALSXP,
 1416|       |                         CPLXSXP, STRSXP, VECSXP, RAWSXP */
 1417|      0|			error(_("cannot create a matrix of type '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              			error(_("cannot create a matrix of type '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1418|      0|			      type2char(mode));
  ------------------
  |  | 1040|      0|#define type2char		Rf_type2char
  ------------------
 1419|      0|		}
 1420|      0|	    }
 1421|      0|	}
 1422|      0|    }
 1423|       |
 1424|       |    /* Adjustment of dimnames attributes. */
 1425|      8|    if (have_cnames || have_rnames) {
  ------------------
  |  Branch (1425:9): [True: 8, False: 0]
  |  Branch (1425:24): [True: 0, False: 0]
  ------------------
 1426|      8|	SEXP nam, tnam,v;
 1427|      8|	PROTECT(dn = allocVector(VECSXP, 2));
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1428|      8|	if (have_cnames)
  ------------------
  |  Branch (1428:6): [True: 8, False: 0]
  ------------------
 1429|      8|	    nam = SET_VECTOR_ELT(dn, 1, allocVector(STRSXP, cols));
  ------------------
  |  |  875|      8|#define allocVector		Rf_allocVector
  ------------------
              	    nam = SET_VECTOR_ELT(dn, 1, allocVector(STRSXP, cols));
  ------------------
  |  |  126|      8|#define STRSXP	    16	  /* string vectors */
  ------------------
 1430|      0|	else
 1431|      0|	    nam = R_NilValue;	/* -Wall */
 1432|      8|	int j = 0;
 1433|     32|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1433:17): [True: 24, False: 8]
  ------------------
 1434|     24|	    u = PRVALUE(CAR(t));
 1435|     24|	    if (isMatrix(u)) {
  ------------------
  |  |  954|     24|#define isMatrix		Rf_isMatrix
  ------------------
  |  Branch (1435:10): [True: 8, False: 16]
  ------------------
 1436|      8|		v = getAttrib(u, R_DimNamesSymbol);
  ------------------
  |  |  924|      8|#define getAttrib		Rf_getAttrib
  ------------------
 1437|       |
 1438|      8|		if (have_rnames &&
  ------------------
  |  Branch (1438:7): [True: 0, False: 8]
  ------------------
 1439|      0|		    GetRowNames(dn) == R_NilValue &&
  ------------------
  |  |  931|      0|#define GetRowNames		Rf_GetRowNames
  ------------------
  |  Branch (1439:7): [True: 0, False: 0]
  ------------------
 1440|      0|		    GetRowNames(v) != R_NilValue)
  ------------------
  |  |  931|      0|#define GetRowNames		Rf_GetRowNames
  ------------------
  |  Branch (1440:7): [True: 0, False: 0]
  ------------------
 1441|      0|		    SetRowNames(dn, lazy_duplicate(GetRowNames(v)));
  ------------------
  |  |  985|      0|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
              		    SetRowNames(dn, lazy_duplicate(GetRowNames(v)));
  ------------------
  |  |  931|      0|#define GetRowNames		Rf_GetRowNames
  ------------------
 1442|       |
 1443|       |		/* rbind() does this only  if(have_?names) .. : */
 1444|       |		/* but if tnam is non-null, have_cnames = TRUE: see above */
 1445|      8|		tnam = GetColNames(v);
  ------------------
  |  |  926|      8|#define GetColNames		Rf_GetColNames
  ------------------
 1446|      8|		if (tnam != R_NilValue) {
  ------------------
  |  Branch (1446:7): [True: 0, False: 8]
  ------------------
 1447|      0|		    for (int i = 0; i < length(tnam); i++)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1447:23): [True: 0, False: 0]
  ------------------
 1448|      0|			SET_STRING_ELT(nam, j++, STRING_ELT(tnam, i));
 1449|      0|		}
 1450|      8|		else if (have_cnames) {
  ------------------
  |  Branch (1450:12): [True: 8, False: 0]
  ------------------
 1451|     32|		    for (int i = 0; i < ncols(u); i++)
  ------------------
  |  | 1005|     32|#define ncols			Rf_ncols
  ------------------
  |  Branch (1451:23): [True: 24, False: 8]
  ------------------
 1452|     24|			SET_STRING_ELT(nam, j++, R_BlankString);
 1453|      8|		}
 1454|     16|	    } else if (length(u) >= lenmin) {
  ------------------
  |  |  987|     16|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1454:17): [True: 16, False: 0]
  ------------------
 1455|     16|		u = getAttrib(u, R_NamesSymbol);
  ------------------
  |  |  924|     16|#define getAttrib		Rf_getAttrib
  ------------------
 1456|       |
 1457|     16|		if (have_rnames && GetRowNames(dn) == R_NilValue
  ------------------
  |  |  931|      0|#define GetRowNames		Rf_GetRowNames
  ------------------
  |  Branch (1457:7): [True: 0, False: 16]
  |  Branch (1457:22): [True: 0, False: 0]
  ------------------
 1458|      0|		    && u != R_NilValue && length(u) == rows)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1458:10): [True: 0, False: 0]
  |  Branch (1458:29): [True: 0, False: 0]
  ------------------
 1459|      0|		    SetRowNames(dn, lazy_duplicate(u));
  ------------------
  |  |  985|      0|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
 1460|       |
 1461|     16|		if (TAG(t) != R_NilValue)
  ------------------
  |  Branch (1461:7): [True: 0, False: 16]
  ------------------
 1462|      0|		    SET_STRING_ELT(nam, j++, PRINTNAME(TAG(t)));
 1463|     16|		else {
 1464|     16|		    expr = substitute(CAR(t), R_NilValue);
  ------------------
  |  | 1035|     16|#define substitute		Rf_substitute
  ------------------
 1465|     16|		    if (deparse_level == 1 && isSymbol(expr))
  ------------------
  |  |  953|     16|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1465:11): [True: 16, False: 0]
  |  Branch (1465:33): [True: 8, False: 8]
  ------------------
 1466|      8|			SET_STRING_ELT(nam, j++, PRINTNAME(expr));
 1467|      8|		    else if (deparse_level == 2) {
  ------------------
  |  Branch (1467:16): [True: 0, False: 8]
  ------------------
 1468|      0|			PROTECT(expr);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1469|      0|			SET_STRING_ELT(nam, j++,
 1470|      0|				       STRING_ELT(deparse1line(expr, true), 0));
  ------------------
  |  | 1884|      0|# define deparse1line		Rf_deparse1line
  ------------------
 1471|      0|			UNPROTECT(1); /* expr */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1472|      8|		    } else if (have_cnames)
  ------------------
  |  Branch (1472:18): [True: 8, False: 0]
  ------------------
 1473|      8|			SET_STRING_ELT(nam, j++, R_BlankString);
 1474|     16|		}
 1475|     16|	    }
 1476|     24|	}
 1477|      8|	setAttrib(result, R_DimNamesSymbol, dn);
  ------------------
  |  | 1027|      8|#define setAttrib		Rf_setAttrib
  ------------------
 1478|      8|	UNPROTECT(1);
  ------------------
  |  |  358|      8|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1479|      8|    }
 1480|      8|    UNPROTECT(1);
  ------------------
  |  |  358|      8|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1481|      8|    return result;
 1482|      8|} /* cbind */
bind.c:rbind:
 1486|      8|{
 1487|      8|    bool have_rnames = false, have_cnames = false, warned = false;
 1488|      8|    int nnames, mnames;
 1489|      8|    int rows, cols, mcols, lenmin = 0;
 1490|      8|    SEXP dn, t, u, result, dims, expr;
 1491|       |
 1492|      8|    nnames = 0;
 1493|      8|    mnames = 0;
 1494|      8|    rows = 0;
 1495|      8|    cols = 0;
 1496|      8|    mcols = -1;
 1497|       |
 1498|       |    /* check if we are in the zero-cols case */
 1499|       |
 1500|      8|    for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1500:20): [True: 8, False: 0]
  ------------------
 1501|      8|	u = PRVALUE(CAR(t));
 1502|      8|	if((isMatrix(u) ? ncols(u) : length(u)) > 0) {
  ------------------
  |  |  954|      8|#define isMatrix		Rf_isMatrix
  ------------------
              	if((isMatrix(u) ? ncols(u) : length(u)) > 0) {
  ------------------
  |  | 1005|      8|#define ncols			Rf_ncols
  ------------------
              	if((isMatrix(u) ? ncols(u) : length(u)) > 0) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1502:5): [True: 8, False: 0]
  |  Branch (1502:6): [True: 8, False: 0]
  ------------------
 1503|      8|	    lenmin = 1;
 1504|      8|	    break;
 1505|      8|	}
 1506|      8|    }
 1507|       |
 1508|       |    /* check conformability of matrix arguments */
 1509|       |
 1510|      8|    int na = 0;
 1511|     24|    for (t = args; t != R_NilValue; t = CDR(t), na++) {
  ------------------
  |  Branch (1511:20): [True: 16, False: 8]
  ------------------
 1512|     16|	u = PRVALUE(CAR(t));
 1513|     16|	dims = getAttrib(u, R_DimSymbol);
  ------------------
  |  |  924|     16|#define getAttrib		Rf_getAttrib
  ------------------
 1514|     16|	if (length(dims) == 2) {
  ------------------
  |  |  987|     16|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1514:6): [True: 16, False: 0]
  ------------------
 1515|     16|	    if (mcols == -1)
  ------------------
  |  Branch (1515:10): [True: 8, False: 8]
  ------------------
 1516|      8|		mcols = INTEGER(dims)[1];
 1517|      8|	    else if (mcols != INTEGER(dims)[1])
  ------------------
  |  Branch (1517:15): [True: 0, False: 8]
  ------------------
 1518|      0|		error(_("number of columns of matrices must match (see arg %d)"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("number of columns of matrices must match (see arg %d)"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1519|      0|		      na + 1);
 1520|     16|	    rows += INTEGER(dims)[0];
 1521|     16|	}
 1522|      0|	else if (length(u) >= lenmin){
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1522:11): [True: 0, False: 0]
  ------------------
 1523|      0|	    cols = imax2(cols, length(u));
  ------------------
  |  |   31|      0|#define imax2(x, y) ((x < y) ? y : x)
  |  |  ------------------
  |  |  |  Branch (31:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1524|      0|	    rows += 1;
 1525|      0|	}
 1526|     16|    }
 1527|      8|    if (mcols != -1) cols = mcols;
  ------------------
  |  Branch (1527:9): [True: 8, False: 0]
  ------------------
 1528|       |
 1529|       |    /* Check conformability of vector arguments. -- Look for dimnames. */
 1530|       |
 1531|      8|    na = 0;
 1532|     24|    for (t = args; t != R_NilValue; t = CDR(t), na++) {
  ------------------
  |  Branch (1532:20): [True: 16, False: 8]
  ------------------
 1533|     16|	u = PRVALUE(CAR(t));
 1534|     16|	dims = getAttrib(u, R_DimSymbol);
  ------------------
  |  |  924|     16|#define getAttrib		Rf_getAttrib
  ------------------
 1535|     16|	if (length(dims) == 2) {
  ------------------
  |  |  987|     16|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1535:6): [True: 16, False: 0]
  ------------------
 1536|     16|	    dn = getAttrib(u, R_DimNamesSymbol);
  ------------------
  |  |  924|     16|#define getAttrib		Rf_getAttrib
  ------------------
 1537|     16|	    if (length(dn) == 2) {
  ------------------
  |  |  987|     16|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1537:10): [True: 0, False: 16]
  ------------------
 1538|      0|		if (VECTOR_ELT(dn, 0) != R_NilValue)
  ------------------
  |  Branch (1538:7): [True: 0, False: 0]
  ------------------
 1539|      0|		    have_rnames = true;
 1540|      0|		if (VECTOR_ELT(dn, 1) != R_NilValue)
  ------------------
  |  Branch (1540:7): [True: 0, False: 0]
  ------------------
 1541|      0|		    mnames = mcols;
 1542|      0|	    }
 1543|     16|	}
 1544|      0|	else {
 1545|      0|	    int k = length(u);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 1546|      0|	    if (!warned && k>0 && (k > cols || cols % k)) {
  ------------------
  |  Branch (1546:10): [True: 0, False: 0]
  |  Branch (1546:21): [True: 0, False: 0]
  |  Branch (1546:29): [True: 0, False: 0]
  |  Branch (1546:41): [True: 0, False: 0]
  ------------------
 1547|      0|		warned = true;
 1548|      0|		warning("number of columns of result is not a multiple of vector length (arg %d)", na + 1);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
 1549|      0|	    }
 1550|      0|	    PROTECT(dn = getAttrib(u, R_NamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1551|      0|	    if (k >= lenmin && (TAG(t) != R_NilValue ||
  ------------------
  |  Branch (1551:10): [True: 0, False: 0]
  |  Branch (1551:26): [True: 0, False: 0]
  ------------------
 1552|      0|				(deparse_level == 2) ||
  ------------------
  |  Branch (1552:5): [True: 0, False: 0]
  ------------------
 1553|      0|				((deparse_level == 1) &&
  ------------------
  |  Branch (1553:6): [True: 0, False: 0]
  ------------------
 1554|      0|				 isSymbol(substitute(CAR(t),R_NilValue)))))
  ------------------
  |  |  953|      0|#define isSymbol		Rf_isSymbol
  ------------------
              				 isSymbol(substitute(CAR(t),R_NilValue)))))
  ------------------
  |  | 1035|      0|#define substitute		Rf_substitute
  ------------------
  |  Branch (1554:6): [True: 0, False: 0]
  ------------------
 1555|      0|		have_rnames = true;
 1556|      0|	    nnames = imax2(nnames, length(dn));
  ------------------
  |  |   31|      0|#define imax2(x, y) ((x < y) ? y : x)
  |  |  ------------------
  |  |  |  Branch (31:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1557|      0|	    UNPROTECT(1); /* dn */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1558|      0|	}
 1559|     16|    }
 1560|      8|    if (mnames || nnames == cols)
  ------------------
  |  Branch (1560:9): [True: 0, False: 8]
  |  Branch (1560:19): [True: 0, False: 8]
  ------------------
 1561|      0|	have_cnames = true;
 1562|       |
 1563|      8|    PROTECT(result = allocMatrix(mode, rows, cols));
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1564|       |
 1565|      8|    R_xlen_t n = 0;
 1566|       |
 1567|      8|    if (mode == STRSXP) {
  ------------------
  |  |  126|      8|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1567:9): [True: 8, False: 0]
  ------------------
 1568|     24|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1568:17): [True: 16, False: 8]
  ------------------
 1569|     16|	    u = PRVALUE(CAR(t));
 1570|     16|	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  954|     16|#define isMatrix		Rf_isMatrix
  ------------------
              	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1570:10): [True: 16, False: 0]
  |  Branch (1570:25): [True: 0, False: 0]
  ------------------
 1571|     16|		u = coerceVector(u, STRSXP);
  ------------------
  |  |  895|     16|#define coerceVector		Rf_coerceVector
  ------------------
              		u = coerceVector(u, STRSXP);
  ------------------
  |  |  126|     16|#define STRSXP	    16	  /* string vectors */
  ------------------
 1572|     16|		R_xlen_t k = XLENGTH(u);
 1573|     16|		R_xlen_t idx = (isMatrix(u)) ? nrows(u) : (k > 0);
  ------------------
  |  |  954|     16|#define isMatrix		Rf_isMatrix
  ------------------
              		R_xlen_t idx = (isMatrix(u)) ? nrows(u) : (k > 0);
  ------------------
  |  | 1008|     16|#define nrows			Rf_nrows
  ------------------
  |  Branch (1573:18): [True: 16, False: 0]
  ------------------
 1574|     16|		xfillStringMatrixWithRecycle(result, u, n, rows, idx, cols, k);
 1575|     16|		n += idx;
 1576|     16|	    }
 1577|     16|	}
 1578|      8|    }
 1579|      0|    else if (mode == VECSXP) {
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1579:14): [True: 0, False: 0]
  ------------------
 1580|      0|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1580:17): [True: 0, False: 0]
  ------------------
 1581|      0|	    u = PRVALUE(CAR(t));
 1582|      0|	    int umatrix = isMatrix(u), urows = umatrix ? nrows(u) : 1; /* coercing to VECSXP will lose these. PR#15468 */
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              	    int umatrix = isMatrix(u), urows = umatrix ? nrows(u) : 1; /* coercing to VECSXP will lose these. PR#15468 */
  ------------------
  |  | 1008|      0|#define nrows			Rf_nrows
  ------------------
  |  Branch (1582:41): [True: 0, False: 0]
  ------------------
 1583|      0|	    if (umatrix || length(u) >= lenmin) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1583:10): [True: 0, False: 0]
  |  Branch (1583:21): [True: 0, False: 0]
  ------------------
 1584|      0|		PROTECT(u = coerceVector(u, mode));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1585|      0|		R_xlen_t k = XLENGTH(u);
 1586|      0|		R_xlen_t idx = umatrix ? urows : (k > 0);
  ------------------
  |  Branch (1586:18): [True: 0, False: 0]
  ------------------
 1587|      0|		FILL_MATRIX_ITERATE(n, rows, idx, cols, k)
  ------------------
  |  |   38|      0|    for(R_xlen_t i = 0, sidx = 0; i < srows; i++, sidx = i)		\
  |  |  ------------------
  |  |  |  Branch (38:35): [True: 0, False: 0]
  |  |  ------------------
  |  |   39|      0|        for(R_xlen_t j = 0, didx = dstart + i; j < cols;		\
  |  |  ------------------
  |  |  |  Branch (39:48): [True: 0, False: 0]
  |  |  ------------------
  |  |   40|      0|            j++, 							\
  |  |   41|      0|            sidx += srows,						\
  |  |   42|      0|            (sidx >= nsrc) ? sidx -= nsrc : 0,				\
  |  |  ------------------
  |  |  |  Branch (42:13): [True: 0, False: 0]
  |  |  ------------------
  |  |   43|      0|            didx += drows)
  ------------------
 1588|      0|		    SET_VECTOR_ELT(result, didx,
 1589|      0|			lazy_duplicate(VECTOR_ELT(u, sidx)));
  ------------------
  |  |  985|      0|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
 1590|      0|		n += idx;
 1591|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1592|      0|	    }
 1593|      0|	}
 1594|      0|    }
 1595|      0|    else if (mode == RAWSXP) {
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1595:14): [True: 0, False: 0]
  ------------------
 1596|      0|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1596:17): [True: 0, False: 0]
  ------------------
 1597|      0|	    u = PRVALUE(CAR(t));
 1598|      0|	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1598:10): [True: 0, False: 0]
  |  Branch (1598:25): [True: 0, False: 0]
  ------------------
 1599|      0|		u = coerceVector(u, RAWSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              		u = coerceVector(u, RAWSXP);
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
 1600|      0|		R_xlen_t k = XLENGTH(u);
 1601|      0|		R_xlen_t idx = (isMatrix(u)) ? nrows(u) : (k > 0);
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              		R_xlen_t idx = (isMatrix(u)) ? nrows(u) : (k > 0);
  ------------------
  |  | 1008|      0|#define nrows			Rf_nrows
  ------------------
  |  Branch (1601:18): [True: 0, False: 0]
  ------------------
 1602|      0|		xfillRawMatrixWithRecycle(RAW(result), RAW(u), n, rows, idx,
 1603|      0|					  cols, k);
 1604|      0|		n += idx;
 1605|      0|	    }
 1606|      0|	}
 1607|      0|    }
 1608|      0|    else if (mode == CPLXSXP) {
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1608:14): [True: 0, False: 0]
  ------------------
 1609|      0|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1609:17): [True: 0, False: 0]
  ------------------
 1610|      0|	    u = PRVALUE(CAR(t));
 1611|      0|	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1611:10): [True: 0, False: 0]
  |  Branch (1611:25): [True: 0, False: 0]
  ------------------
 1612|      0|		u = coerceVector(u, CPLXSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              		u = coerceVector(u, CPLXSXP);
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
 1613|      0|		R_xlen_t k = XLENGTH(u);
 1614|      0|		R_xlen_t idx = (isMatrix(u)) ? nrows(u) : (k > 0);
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              		R_xlen_t idx = (isMatrix(u)) ? nrows(u) : (k > 0);
  ------------------
  |  | 1008|      0|#define nrows			Rf_nrows
  ------------------
  |  Branch (1614:18): [True: 0, False: 0]
  ------------------
 1615|      0|		xfillComplexMatrixWithRecycle(COMPLEX(result), COMPLEX(u), n,
 1616|      0|					      rows, idx, cols, k);
 1617|      0|		n += idx;
 1618|      0|	    }
 1619|      0|	}
 1620|      0|    }
 1621|      0|    else if (mode == INTSXP) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1621:14): [True: 0, False: 0]
  ------------------
 1622|      0|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1622:17): [True: 0, False: 0]
  ------------------
 1623|      0|	    u = PRVALUE(CAR(t));
 1624|      0|	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1624:10): [True: 0, False: 0]
  |  Branch (1624:25): [True: 0, False: 0]
  ------------------
 1625|      0|		u = coerceVector(u, INTSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              		u = coerceVector(u, INTSXP);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
 1626|      0|		R_xlen_t k = XLENGTH(u);
 1627|      0|		R_xlen_t idx = (isMatrix(u)) ? nrows(u) : (k > 0);
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              		R_xlen_t idx = (isMatrix(u)) ? nrows(u) : (k > 0);
  ------------------
  |  | 1008|      0|#define nrows			Rf_nrows
  ------------------
  |  Branch (1627:18): [True: 0, False: 0]
  ------------------
 1628|      0|		xfillIntegerMatrixWithRecycle(INTEGER(result), INTEGER(u), n, rows, idx,
 1629|      0|					  cols, k);
 1630|      0|		n += idx;
 1631|      0|	    }
 1632|      0|	}
 1633|      0|    }
 1634|      0|     else if (mode == LGLSXP) {
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1634:15): [True: 0, False: 0]
  ------------------
 1635|      0|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1635:17): [True: 0, False: 0]
  ------------------
 1636|      0|	    u = PRVALUE(CAR(t));
 1637|      0|	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              	    if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1637:10): [True: 0, False: 0]
  |  Branch (1637:25): [True: 0, False: 0]
  ------------------
 1638|      0|		u = coerceVector(u, LGLSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              		u = coerceVector(u, LGLSXP);
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
 1639|      0|		R_xlen_t k = XLENGTH(u);
 1640|      0|		R_xlen_t idx = (isMatrix(u)) ? nrows(u) : (k > 0);
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              		R_xlen_t idx = (isMatrix(u)) ? nrows(u) : (k > 0);
  ------------------
  |  | 1008|      0|#define nrows			Rf_nrows
  ------------------
  |  Branch (1640:18): [True: 0, False: 0]
  ------------------
 1641|      0|		xfillLogicalMatrixWithRecycle(LOGICAL(result), LOGICAL(u), n, rows, idx,
 1642|      0|					  cols, k);
 1643|      0|		n += idx;
 1644|      0|	    }
 1645|      0|	}
 1646|      0|     }
 1647|      0|     else if (mode == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1647:15): [True: 0, False: 0]
  ------------------
 1648|      0|	 for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1648:18): [True: 0, False: 0]
  ------------------
 1649|      0|	     u = PRVALUE(CAR(t));
 1650|      0|	     if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              	     if (isMatrix(u) || length(u) >= lenmin) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1650:11): [True: 0, False: 0]
  |  Branch (1650:26): [True: 0, False: 0]
  ------------------
 1651|      0|		 u = coerceVector(u, REALSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              		 u = coerceVector(u, REALSXP);
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
 1652|      0|		 R_xlen_t k = XLENGTH(u);
 1653|      0|		 R_xlen_t idx = (isMatrix(u)) ? nrows(u) : (k > 0);
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              		 R_xlen_t idx = (isMatrix(u)) ? nrows(u) : (k > 0);
  ------------------
  |  | 1008|      0|#define nrows			Rf_nrows
  ------------------
  |  Branch (1653:19): [True: 0, False: 0]
  ------------------
 1654|      0|		 xfillRealMatrixWithRecycle(REAL(result), REAL(u), n, rows, idx,
 1655|      0|					  cols, k);
 1656|      0|		 n += idx;
 1657|      0|	     }
 1658|      0|	 }
 1659|      0|     }
 1660|      0|     else { /* everything else, currently NILSXP so do nothing */
 1661|      0|     }
 1662|       |
 1663|       |    /* Adjustment of dimnames attributes. */
 1664|      8|    if (have_rnames || have_cnames) {
  ------------------
  |  Branch (1664:9): [True: 0, False: 8]
  |  Branch (1664:24): [True: 0, False: 8]
  ------------------
 1665|      0|	SEXP nam, tnam,v;
 1666|      0|	PROTECT(dn = allocVector(VECSXP, 2));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1667|      0|	if (have_rnames)
  ------------------
  |  Branch (1667:6): [True: 0, False: 0]
  ------------------
 1668|      0|	    nam = SET_VECTOR_ELT(dn, 0, allocVector(STRSXP, rows));
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	    nam = SET_VECTOR_ELT(dn, 0, allocVector(STRSXP, rows));
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
 1669|      0|	else
 1670|      0|	    nam = R_NilValue;	/* -Wall */
 1671|      0|	int j = 0;
 1672|      0|	for (t = args; t != R_NilValue; t = CDR(t)) {
  ------------------
  |  Branch (1672:17): [True: 0, False: 0]
  ------------------
 1673|      0|	    u = PRVALUE(CAR(t));
 1674|      0|	    if (isMatrix(u)) {
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
  |  Branch (1674:10): [True: 0, False: 0]
  ------------------
 1675|      0|		v = getAttrib(u, R_DimNamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 1676|       |
 1677|      0|		if (have_cnames &&
  ------------------
  |  Branch (1677:7): [True: 0, False: 0]
  ------------------
 1678|      0|		    GetColNames(dn) == R_NilValue &&
  ------------------
  |  |  926|      0|#define GetColNames		Rf_GetColNames
  ------------------
  |  Branch (1678:7): [True: 0, False: 0]
  ------------------
 1679|      0|		    GetColNames(v) != R_NilValue)
  ------------------
  |  |  926|      0|#define GetColNames		Rf_GetColNames
  ------------------
  |  Branch (1679:7): [True: 0, False: 0]
  ------------------
 1680|      0|		    SetColNames(dn, lazy_duplicate(GetColNames(v)));
  ------------------
  |  |  985|      0|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
              		    SetColNames(dn, lazy_duplicate(GetColNames(v)));
  ------------------
  |  |  926|      0|#define GetColNames		Rf_GetColNames
  ------------------
 1681|       |
 1682|       |		/* cbind() doesn't test have_?names BEFORE tnam!=Nil..:*/
 1683|       |		/* but if tnam is non-null, have_rnames = TRUE: see above */
 1684|      0|		tnam = GetRowNames(v);
  ------------------
  |  |  931|      0|#define GetRowNames		Rf_GetRowNames
  ------------------
 1685|      0|		if (have_rnames) {
  ------------------
  |  Branch (1685:7): [True: 0, False: 0]
  ------------------
 1686|      0|		    if (tnam != R_NilValue) {
  ------------------
  |  Branch (1686:11): [True: 0, False: 0]
  ------------------
 1687|      0|			for (int i = 0; i < length(tnam); i++)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1687:20): [True: 0, False: 0]
  ------------------
 1688|      0|			    SET_STRING_ELT(nam, j++, STRING_ELT(tnam, i));
 1689|      0|		    }
 1690|      0|		    else {
 1691|      0|			for (int i = 0; i < nrows(u); i++)
  ------------------
  |  | 1008|      0|#define nrows			Rf_nrows
  ------------------
  |  Branch (1691:20): [True: 0, False: 0]
  ------------------
 1692|      0|				SET_STRING_ELT(nam, j++, R_BlankString);
 1693|      0|		    }
 1694|      0|		}
 1695|      0|	    }
 1696|      0|	    else if (length(u) >= lenmin) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1696:15): [True: 0, False: 0]
  ------------------
 1697|      0|		u = getAttrib(u, R_NamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 1698|       |
 1699|      0|		if (have_cnames && GetColNames(dn) == R_NilValue
  ------------------
  |  |  926|      0|#define GetColNames		Rf_GetColNames
  ------------------
  |  Branch (1699:7): [True: 0, False: 0]
  |  Branch (1699:22): [True: 0, False: 0]
  ------------------
 1700|      0|		    && u != R_NilValue && length(u) == cols)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1700:10): [True: 0, False: 0]
  |  Branch (1700:29): [True: 0, False: 0]
  ------------------
 1701|      0|		    SetColNames(dn, lazy_duplicate(u));
  ------------------
  |  |  985|      0|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
 1702|       |
 1703|      0|		if (TAG(t) != R_NilValue)
  ------------------
  |  Branch (1703:7): [True: 0, False: 0]
  ------------------
 1704|      0|		    SET_STRING_ELT(nam, j++, PRINTNAME(TAG(t)));
 1705|      0|		else {
 1706|      0|		    expr = substitute(CAR(t), R_NilValue);
  ------------------
  |  | 1035|      0|#define substitute		Rf_substitute
  ------------------
 1707|      0|		    if (deparse_level == 1 && isSymbol(expr))
  ------------------
  |  |  953|      0|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1707:11): [True: 0, False: 0]
  |  Branch (1707:33): [True: 0, False: 0]
  ------------------
 1708|      0|			SET_STRING_ELT(nam, j++, PRINTNAME(expr));
 1709|      0|		    else if (deparse_level == 2) {
  ------------------
  |  Branch (1709:16): [True: 0, False: 0]
  ------------------
 1710|      0|			PROTECT(expr);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1711|      0|			SET_STRING_ELT(nam, j++,
 1712|      0|				       STRING_ELT(deparse1line(expr, true), 0));
  ------------------
  |  | 1884|      0|# define deparse1line		Rf_deparse1line
  ------------------
 1713|      0|			UNPROTECT(1); /* expr */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1714|      0|		    } else if (have_rnames)
  ------------------
  |  Branch (1714:18): [True: 0, False: 0]
  ------------------
 1715|      0|			SET_STRING_ELT(nam, j++, R_BlankString);
 1716|      0|		}
 1717|      0|	    }
 1718|      0|	}
 1719|      0|	setAttrib(result, R_DimNamesSymbol, dn);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 1720|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1721|      0|    }
 1722|      8|    UNPROTECT(1);
  ------------------
  |  |  358|      8|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1723|      8|    return result;
 1724|      8|} /* rbind */

Rf_asVecSize:
   37|   385k|{
   38|   385k|    if (isVectorAtomic(x) && LENGTH(x) >= 1) {
  ------------------
  |  |  975|   385k|#define isVectorAtomic		Rf_isVectorAtomic
  ------------------
  |  Branch (38:9): [True: 385k, False: 0]
  |  Branch (38:30): [True: 385k, False: 0]
  ------------------
   39|   385k|	switch (TYPEOF(x)) {
   40|   385k|	case INTSXP:
  ------------------
  |  |  123|   385k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (40:2): [True: 385k, False: 29]
  ------------------
   41|   385k|	{
   42|   385k|	    int res = INTEGER(x)[0];
   43|   385k|	    if(res == NA_INTEGER) error(_("vector size cannot be NA"));
  ------------------
  |  |   56|   385k|#define NA_INTEGER	R_NaInt
  ------------------
              	    if(res == NA_INTEGER) error(_("vector size cannot be NA"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    if(res == NA_INTEGER) error(_("vector size cannot be NA"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (43:9): [True: 0, False: 385k]
  ------------------
   44|   385k|	    return (R_xlen_t) res;
   45|      0|	}
   46|     29|	case REALSXP:
  ------------------
  |  |  124|     29|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (46:2): [True: 29, False: 385k]
  ------------------
   47|     29|	{
   48|     29|	    double d = REAL(x)[0];
   49|     29|	    if(ISNAN(d)) error(_("vector size cannot be NA/NaN"));
  ------------------
  |  |   76|     29|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 29]
  |  |  ------------------
  ------------------
              	    if(ISNAN(d)) error(_("vector size cannot be NA/NaN"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    if(ISNAN(d)) error(_("vector size cannot be NA/NaN"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   50|     29|	    if(!R_FINITE(d)) error(_("vector size cannot be infinite"));
  ------------------
  |  |   82|     29|# define R_FINITE(x)    isfinite(x)
  ------------------
              	    if(!R_FINITE(d)) error(_("vector size cannot be infinite"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    if(!R_FINITE(d)) error(_("vector size cannot be infinite"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (50:9): [True: 0, False: 29]
  ------------------
   51|     29|	    if(d > R_XLEN_T_MAX) error(_("vector size specified is too large"));
  ------------------
  |  |   76|     29|# define R_XLEN_T_MAX 4503599627370496
  ------------------
              	    if(d > R_XLEN_T_MAX) error(_("vector size specified is too large"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    if(d > R_XLEN_T_MAX) error(_("vector size specified is too large"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (51:9): [True: 0, False: 29]
  ------------------
   52|     29|	    return (R_xlen_t) d;
   53|      0|	}
   54|      0|	case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (54:2): [True: 0, False: 385k]
  ------------------
   55|      0|	{
   56|      0|	    double d = asReal(x);
  ------------------
  |  |  889|      0|#define asReal			Rf_asReal
  ------------------
   57|      0|	    if(ISNAN(d)) error(_("vector size cannot be NA/NaN"));
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	    if(ISNAN(d)) error(_("vector size cannot be NA/NaN"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    if(ISNAN(d)) error(_("vector size cannot be NA/NaN"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   58|      0|	    if(!R_FINITE(d)) error(_("vector size cannot be infinite"));
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
              	    if(!R_FINITE(d)) error(_("vector size cannot be infinite"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    if(!R_FINITE(d)) error(_("vector size cannot be infinite"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (58:9): [True: 0, False: 0]
  ------------------
   59|      0|	    if(d > R_XLEN_T_MAX) error(_("vector size specified is too large"));
  ------------------
  |  |   76|      0|# define R_XLEN_T_MAX 4503599627370496
  ------------------
              	    if(d > R_XLEN_T_MAX) error(_("vector size specified is too large"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    if(d > R_XLEN_T_MAX) error(_("vector size specified is too large"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (59:9): [True: 0, False: 0]
  ------------------
   60|      0|	    return (R_xlen_t) d;
   61|      0|	}
   62|      0|	default:
  ------------------
  |  Branch (62:2): [True: 0, False: 385k]
  ------------------
   63|      0|	    break;
   64|   385k|	}
   65|   385k|    }
   66|      0|    return -999;  /* which gives error in the caller */
   67|   385k|}
do_delayed:
   70|  1.32k|{
   71|  1.32k|    SEXP name = R_NilValue /* -Wall */, expr, eenv, aenv;
   72|  1.32k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.32k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
   73|       |
   74|  1.32k|    if (!isString(CAR(args)) || LENGTH(CAR(args)) == 0)
  ------------------
  |  |  966|  1.32k|#define isString		Rf_isString
  ------------------
  |  Branch (74:9): [True: 0, False: 1.32k]
  |  Branch (74:33): [True: 0, False: 1.32k]
  ------------------
   75|      0|	error(_("invalid first argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid first argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   76|  1.32k|    else
   77|  1.32k|	name = installTrChar(STRING_ELT(CAR(args), 0));
  ------------------
  |  |  937|  1.32k|#define installTrChar		Rf_installTrChar
  ------------------
   78|  1.32k|    args = CDR(args);
   79|  1.32k|    expr = CAR(args);
   80|       |
   81|  1.32k|    args = CDR(args);
   82|  1.32k|    eenv = CAR(args);
   83|  1.32k|    if (isNull(eenv)) {
  ------------------
  |  |  956|  1.32k|#define isNull			Rf_isNull
  ------------------
  |  Branch (83:9): [True: 0, False: 1.32k]
  ------------------
   84|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   85|      0|	eenv = R_BaseEnv;
   86|      0|    } else
   87|  1.32k|    if (!isEnvironment(eenv))
  ------------------
  |  |  944|  1.32k|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (87:9): [True: 0, False: 1.32k]
  ------------------
   88|      0|	error(_("invalid '%s' argument"), "eval.env");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "eval.env");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   89|       |
   90|  1.32k|    args = CDR(args);
   91|  1.32k|    aenv = CAR(args);
   92|  1.32k|    if (isNull(aenv)) {
  ------------------
  |  |  956|  1.32k|#define isNull			Rf_isNull
  ------------------
  |  Branch (92:9): [True: 0, False: 1.32k]
  ------------------
   93|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   94|      0|	aenv = R_BaseEnv;
   95|      0|    } else
   96|  1.32k|    if (!isEnvironment(aenv))
  ------------------
  |  |  944|  1.32k|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (96:9): [True: 0, False: 1.32k]
  ------------------
   97|      0|	error(_("invalid '%s' argument"), "assign.env");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "assign.env");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   98|       |
   99|  1.32k|    defineVar(name, mkPROMISE(expr, eenv), aenv);
  ------------------
  |  |  905|  1.32k|#define defineVar		Rf_defineVar
  ------------------
                  defineVar(name, mkPROMISE(expr, eenv), aenv);
  ------------------
  |  | 1957|  1.32k|# define mkPROMISE		Rf_mkPROMISE
  ------------------
  100|  1.32k|    return R_NilValue;
  101|  1.32k|}
do_makelazy:
  105|     18|{
  106|     18|    SEXP names, values, val, expr, eenv, aenv, expr0;
  107|     18|    R_xlen_t i;
  108|       |
  109|     18|    checkArity(op, args);
  ------------------
  |  | 1788|     18|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  110|     18|    names = CAR(args); args = CDR(args);
  111|     18|    if (!isString(names))
  ------------------
  |  |  966|     18|#define isString		Rf_isString
  ------------------
  |  Branch (111:9): [True: 0, False: 18]
  ------------------
  112|      0|	error(_("invalid first argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid first argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  113|     18|    values = CAR(args); args = CDR(args);
  114|     18|    expr = CAR(args); args = CDR(args);
  115|     18|    eenv = CAR(args); args = CDR(args);
  116|     18|    if (!isEnvironment(eenv)) error(_("invalid '%s' argument"), "eval.env");
  ------------------
  |  |  944|     18|#define isEnvironment		Rf_isEnvironment
  ------------------
                  if (!isEnvironment(eenv)) error(_("invalid '%s' argument"), "eval.env");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (!isEnvironment(eenv)) error(_("invalid '%s' argument"), "eval.env");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (116:9): [True: 0, False: 18]
  ------------------
  117|     18|    aenv = CAR(args);
  118|     18|    if (!isEnvironment(aenv)) error(_("invalid '%s' argument"), "assign.env");
  ------------------
  |  |  944|     18|#define isEnvironment		Rf_isEnvironment
  ------------------
                  if (!isEnvironment(aenv)) error(_("invalid '%s' argument"), "assign.env");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (!isEnvironment(aenv)) error(_("invalid '%s' argument"), "assign.env");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (118:9): [True: 0, False: 18]
  ------------------
  119|       |
  120|  8.53k|    for(i = 0; i < XLENGTH(names); i++) {
  ------------------
  |  Branch (120:16): [True: 8.51k, False: 18]
  ------------------
  121|  8.51k|	SEXP name = installTrChar(STRING_ELT(names, i));
  ------------------
  |  |  937|  8.51k|#define installTrChar		Rf_installTrChar
  ------------------
  122|  8.51k|	PROTECT(val = eval(VECTOR_ELT(values, i), eenv));
  ------------------
  |  |  357|  8.51k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  123|  8.51k|	PROTECT(expr0 = duplicate(expr));
  ------------------
  |  |  357|  8.51k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  124|  8.51k|	SETCAR(CDR(expr0), val);
  125|  8.51k|	defineVar(name, mkPROMISE(expr0, eenv), aenv);
  ------------------
  |  |  905|  8.51k|#define defineVar		Rf_defineVar
  ------------------
              	defineVar(name, mkPROMISE(expr0, eenv), aenv);
  ------------------
  |  | 1957|  8.51k|# define mkPROMISE		Rf_mkPROMISE
  ------------------
  126|  8.51k|	UNPROTECT(2);
  ------------------
  |  |  358|  8.51k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  127|  8.51k|    }
  128|     18|    return R_NilValue;
  129|     18|}
do_onexit:
  133|    238|{
  134|    238|    RCNTXT *ctxt;
  135|    238|    SEXP code, oldcode, argList;
  136|    238|    int addit = FALSE;
  137|    238|    int after = TRUE;
  138|    238|    static SEXP do_onexit_formals = NULL;
  139|       |
  140|    238|    checkArity(op, args);
  ------------------
  |  | 1788|    238|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  141|    238|    if (do_onexit_formals == NULL)
  ------------------
  |  Branch (141:9): [True: 2, False: 236]
  ------------------
  142|      2|        do_onexit_formals = allocFormalsList3(install("expr"),
  ------------------
  |  |  866|      2|#define allocFormalsList3	Rf_allocFormalsList3
  ------------------
                      do_onexit_formals = allocFormalsList3(install("expr"),
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  143|      2|                                              install("add"),
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  144|      2|                                              install("after"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  145|       |
  146|    238|    PROTECT(argList =  matchArgs_NR(do_onexit_formals, args, call));
  ------------------
  |  |  357|    238|#define PROTECT(s)	Rf_protect(s)
  ------------------
  147|    238|    if (CAR(argList) == R_MissingArg) code = R_NilValue;
  ------------------
  |  Branch (147:9): [True: 38, False: 200]
  ------------------
  148|    200|    else code = CAR(argList);
  149|       |
  150|    238|    if (CADR(argList) != R_MissingArg) {
  ------------------
  |  Branch (150:9): [True: 26, False: 212]
  ------------------
  151|     26|	addit = asLogical(PROTECT(eval(CADR(argList), rho)));
  ------------------
  |  |  886|     26|#define asLogical		Rf_asLogical
  ------------------
              	addit = asLogical(PROTECT(eval(CADR(argList), rho)));
  ------------------
  |  |  357|     26|#define PROTECT(s)	Rf_protect(s)
  ------------------
  152|     26|	UNPROTECT(1);
  ------------------
  |  |  358|     26|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  153|     26|	if (addit == NA_INTEGER)
  ------------------
  |  |   56|     26|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (153:6): [True: 0, False: 26]
  ------------------
  154|      0|	    errorcall(call, _("invalid '%s' argument"), "add");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("invalid '%s' argument"), "add");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  155|     26|    }
  156|    238|    if (CADDR(argList) != R_MissingArg) {
  ------------------
  |  Branch (156:9): [True: 0, False: 238]
  ------------------
  157|      0|	after = asLogical(PROTECT(eval(CADDR(argList), rho)));
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
              	after = asLogical(PROTECT(eval(CADDR(argList), rho)));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  158|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  159|      0|        if (after == NA_INTEGER)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (159:13): [True: 0, False: 0]
  ------------------
  160|      0|            errorcall(call, _("invalid '%s' argument"), "lifo");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
                          errorcall(call, _("invalid '%s' argument"), "lifo");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  161|      0|    }
  162|       |
  163|    238|    ctxt = R_GlobalContext;
  164|       |    /* Search for the context to which the on.exit action is to be
  165|       |       attached. Lexical scoping is implemented by searching for the
  166|       |       first closure call context with an environment matching the
  167|       |       expression evaluation environment. */
  168|    238|    while (ctxt != R_ToplevelContext &&
  ------------------
  |  Branch (168:12): [True: 238, False: 0]
  ------------------
  169|    238|	   !((ctxt->callflag & CTXT_FUNCTION) && ctxt->cloenv == rho) )
  ------------------
  |  Branch (169:7): [True: 238, False: 0]
  |  Branch (169:43): [True: 238, False: 0]
  ------------------
  170|      0|	ctxt = ctxt->nextcontext;
  171|    238|    if (ctxt->callflag & CTXT_FUNCTION)
  ------------------
  |  Branch (171:9): [True: 238, False: 0]
  ------------------
  172|    238|    {
  173|    238|	if (code == R_NilValue && ! addit)
  ------------------
  |  Branch (173:6): [True: 38, False: 200]
  |  Branch (173:28): [True: 38, False: 0]
  ------------------
  174|     38|	    ctxt->conexit = R_NilValue;
  175|    200|	else {
  176|    200|	    oldcode = ctxt->conexit;
  177|    200|	    if (oldcode == R_NilValue || ! addit)
  ------------------
  |  Branch (177:10): [True: 174, False: 26]
  |  Branch (177:35): [True: 0, False: 26]
  ------------------
  178|    174|                ctxt->conexit = CONS(code, R_NilValue);
  ------------------
  |  |  309|    174|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  179|     26|	    else {
  180|     26|                if (after) {
  ------------------
  |  Branch (180:21): [True: 26, False: 0]
  ------------------
  181|     26|                    SEXP codelist = PROTECT(CONS(code, R_NilValue));
  ------------------
  |  |  357|     26|#define PROTECT(s)	Rf_protect(s)
  ------------------
  182|     26|                    ctxt->conexit = listAppend(shallow_duplicate(oldcode), codelist);
  ------------------
  |  |  995|     26|#define listAppend		Rf_listAppend
  ------------------
                                  ctxt->conexit = listAppend(shallow_duplicate(oldcode), codelist);
  ------------------
  |  | 1030|     26|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
  183|     26|                    UNPROTECT(1);
  ------------------
  |  |  358|     26|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  184|     26|                } else {
  185|      0|                    ctxt->conexit = CONS(code, oldcode);
  ------------------
  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  186|      0|                }
  187|     26|	    }
  188|    200|	}
  189|    238|    }
  190|    238|    UNPROTECT(1);
  ------------------
  |  |  358|    238|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  191|    238|    return R_NilValue;
  192|    238|}
do_formals:
  250|     39|{
  251|     39|    checkArity(op, args);
  ------------------
  |  | 1788|     39|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  252|     39|    if (TYPEOF(CAR(args)) == CLOSXP) {
  ------------------
  |  |  114|     39|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (252:9): [True: 39, False: 0]
  ------------------
  253|     39|	SEXP f = FORMALS(CAR(args));
  254|     39|	RAISE_NAMED(f, NAMED(CAR(args)));
  255|     39|	return f;
  256|     39|    } else {
  257|      0|	if(!(TYPEOF(CAR(args)) == BUILTINSXP ||
  ------------------
  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (257:7): [True: 0, False: 0]
  ------------------
  258|      0|	     TYPEOF(CAR(args)) == SPECIALSXP))
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (258:7): [True: 0, False: 0]
  ------------------
  259|      0|	    warningcall(call, _("argument is not a function"));
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              	    warningcall(call, _("argument is not a function"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  260|      0|	return R_NilValue;
  261|      0|    }
  262|     39|}
do_body:
  265|      7|{
  266|      7|    checkArity(op, args);
  ------------------
  |  | 1788|      7|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  267|      7|    if (TYPEOF(CAR(args)) == CLOSXP) {
  ------------------
  |  |  114|      7|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (267:9): [True: 7, False: 0]
  ------------------
  268|      7|	SEXP b = BODY_EXPR(CAR(args));
  ------------------
  |  | 1220|      7|#define BODY_EXPR(e) R_ClosureExpr(e)
  ------------------
  269|      7|	RAISE_NAMED(b, NAMED(CAR(args)));
  270|      7|	return b;
  271|      7|    } else {
  272|      0|	if(!(TYPEOF(CAR(args)) == BUILTINSXP ||
  ------------------
  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (272:7): [True: 0, False: 0]
  ------------------
  273|      0|	     TYPEOF(CAR(args)) == SPECIALSXP))
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (273:7): [True: 0, False: 0]
  ------------------
  274|      0|	    warningcall(call, _("argument is not a function"));
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              	    warningcall(call, _("argument is not a function"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  275|      0|	return R_NilValue;
  276|      0|    }
  277|      7|}
do_envir:
  295|   386k|{
  296|   386k|    checkArity(op, args);
  ------------------
  |  | 1788|   386k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  297|   386k|    if (TYPEOF(CAR(args)) == CLOSXP)
  ------------------
  |  |  114|   386k|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (297:9): [True: 68, False: 385k]
  ------------------
  298|     68|	return CLOENV(CAR(args));
  299|   385k|    else if (CAR(args) == R_NilValue)
  ------------------
  |  Branch (299:14): [True: 385k, False: 0]
  ------------------
  300|   385k|	return R_GlobalContext->sysparent;
  301|      0|    else return getAttrib(CAR(args), R_DotEnvSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  302|   386k|}
do_newenv:
  346|    781|{
  347|    781|    SEXP enclos;
  348|    781|    int hash, size = 0;
  349|       |
  350|    781|    checkArity(op, args);
  ------------------
  |  | 1788|    781|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  351|       |
  352|    781|    hash = asInteger(CAR(args));
  ------------------
  |  |  885|    781|#define asInteger		Rf_asInteger
  ------------------
  353|    781|    args = CDR(args);
  354|    781|    enclos = CAR(args);
  355|    781|    if (isNull(enclos))
  ------------------
  |  |  956|    781|#define isNull			Rf_isNull
  ------------------
  |  Branch (355:9): [True: 0, False: 781]
  ------------------
  356|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  357|       |
  358|    781|    if( !isEnvironment(enclos) &&
  ------------------
  |  |  944|    781|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (358:9): [True: 0, False: 781]
  ------------------
  359|      0|	!isEnvironment((enclos = simple_as_environment(enclos))))
  ------------------
  |  |  944|      0|#define isEnvironment		Rf_isEnvironment
  ------------------
              	!isEnvironment((enclos = simple_as_environment(enclos))))
  ------------------
  |  |  290|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : arg)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : arg)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (290:37): [True: 0, False: 0]
  |  |  |  Branch (290:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (359:2): [True: 0, False: 0]
  ------------------
  360|      0|	error(_("'enclos' must be an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'enclos' must be an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  361|       |
  362|    781|    if( hash ) {
  ------------------
  |  Branch (362:9): [True: 779, False: 2]
  ------------------
  363|    779|	size = asInteger(CADR(args));
  ------------------
  |  |  885|    779|#define asInteger		Rf_asInteger
  ------------------
  364|    779|	if (size == NA_INTEGER)
  ------------------
  |  |   56|    779|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (364:6): [True: 0, False: 779]
  ------------------
  365|      0|	    size = 0; /* so it will use the internal default */
  366|    779|    }
  367|      2|    else size = 0;
  368|    781|    return R_NewEnv(enclos, hash, size);
  369|    781|}
do_parentenv:
  372|    222|{
  373|    222|    checkArity(op, args);
  ------------------
  |  | 1788|    222|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  374|    222|    SEXP arg = CAR(args);
  375|       |
  376|    222|    if( !isEnvironment(arg)  &&
  ------------------
  |  |  944|    222|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (376:9): [True: 0, False: 222]
  ------------------
  377|      0|	!isEnvironment((arg = simple_as_environment(arg))))
  ------------------
  |  |  944|      0|#define isEnvironment		Rf_isEnvironment
  ------------------
              	!isEnvironment((arg = simple_as_environment(arg))))
  ------------------
  |  |  290|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : arg)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : arg)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (290:37): [True: 0, False: 0]
  |  |  |  Branch (290:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (377:2): [True: 0, False: 0]
  ------------------
  378|      0|	error( _("argument is not an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error( _("argument is not an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  379|    222|    if( arg == R_EmptyEnv )
  ------------------
  |  Branch (379:9): [True: 0, False: 222]
  ------------------
  380|      0|	error(_("the empty environment has no parent"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("the empty environment has no parent"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  381|    222|    return( ENCLOS(arg) );
  382|    222|}
do_parentenvgets:
  403|    577|{
  404|    577|    SEXP env, parent;
  405|    577|    checkArity(op, args);
  ------------------
  |  | 1788|    577|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  406|       |
  407|    577|    env = CAR(args);
  408|    577|    if (isNull(env)) {
  ------------------
  |  |  956|    577|#define isNull			Rf_isNull
  ------------------
  |  Branch (408:9): [True: 0, False: 577]
  ------------------
  409|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  410|      0|	env = R_BaseEnv;
  411|      0|    } else
  412|    577|    if( !isEnvironment(env) &&
  ------------------
  |  |  944|    577|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (412:9): [True: 0, False: 577]
  ------------------
  413|      0|	!isEnvironment((env = simple_as_environment(env))))
  ------------------
  |  |  944|      0|#define isEnvironment		Rf_isEnvironment
  ------------------
              	!isEnvironment((env = simple_as_environment(env))))
  ------------------
  |  |  290|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : arg)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : arg)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (290:37): [True: 0, False: 0]
  |  |  |  Branch (290:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (413:2): [True: 0, False: 0]
  ------------------
  414|      0|	error(_("argument is not an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("argument is not an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  415|    577|    if( env == R_EmptyEnv )
  ------------------
  |  Branch (415:9): [True: 0, False: 577]
  ------------------
  416|      0|	error(_("can not set parent of the empty environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("can not set parent of the empty environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  417|    577|    if (R_EnvironmentIsLocked(env) && R_IsNamespaceEnv(env))
  ------------------
  |  Branch (417:9): [True: 0, False: 577]
  |  Branch (417:39): [True: 0, False: 0]
  ------------------
  418|      0|	error(_("can not set the parent environment of a namespace"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("can not set the parent environment of a namespace"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  419|    577|    if (R_EnvironmentIsLocked(env) && R_IsImportsEnv(env))
  ------------------
  |  Branch (419:9): [True: 0, False: 577]
  |  Branch (419:39): [True: 0, False: 0]
  ------------------
  420|      0|	error(_("can not set the parent environment of package imports"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("can not set the parent environment of package imports"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  421|    577|    parent = CADR(args);
  422|    577|    if (isNull(parent)) {
  ------------------
  |  |  956|    577|#define isNull			Rf_isNull
  ------------------
  |  Branch (422:9): [True: 0, False: 577]
  ------------------
  423|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  424|      0|	parent = R_BaseEnv;
  425|      0|    } else
  426|    577|    if( !isEnvironment(parent) &&
  ------------------
  |  |  944|    577|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (426:9): [True: 0, False: 577]
  ------------------
  427|      0|	!isEnvironment((parent = simple_as_environment(parent))))
  ------------------
  |  |  944|      0|#define isEnvironment		Rf_isEnvironment
  ------------------
              	!isEnvironment((parent = simple_as_environment(parent))))
  ------------------
  |  |  290|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : arg)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : arg)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (290:37): [True: 0, False: 0]
  |  |  |  Branch (290:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (427:2): [True: 0, False: 0]
  ------------------
  428|      0|	error(_("'parent' is not an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'parent' is not an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  429|       |
  430|    577|    SET_ENCLOS(env, parent);
  431|       |
  432|    577|    return( CAR(args) );
  433|    577|}
do_makelist:
  718|  1.93M|{
  719|  1.93M|    int n, havenames;
  720|       |    /* compute number of args and check for names */
  721|  1.93M|    SEXP next;
  722|  1.93M|    for (next = args, n = 0, havenames = FALSE;
  723|  6.17M|	 next != R_NilValue;
  ------------------
  |  Branch (723:3): [True: 4.24M, False: 1.93M]
  ------------------
  724|  4.24M|	 next = CDR(next)) {
  725|  4.24M|	if (TAG(next) != R_NilValue)
  ------------------
  |  Branch (725:6): [True: 4.24M, False: 4.19k]
  ------------------
  726|  4.24M|	    havenames = TRUE;
  727|  4.24M|	n++;
  728|  4.24M|    }
  729|       |
  730|  1.93M|    SEXP list = PROTECT(allocVector(VECSXP, n));
  ------------------
  |  |  357|  1.93M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  731|  1.93M|    SEXP names = PROTECT(havenames ? allocVector(STRSXP, n) : R_NilValue);
  ------------------
  |  |  357|  3.86M|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  |  Branch (357:31): [True: 1.92M, False: 3.23k]
  |  |  ------------------
  ------------------
  732|  6.17M|    for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (732:21): [True: 4.24M, False: 1.93M]
  ------------------
  733|  4.24M|	if (havenames) {
  ------------------
  |  Branch (733:6): [True: 4.24M, False: 4.19k]
  ------------------
  734|  4.24M|	    if (TAG(args) != R_NilValue)
  ------------------
  |  Branch (734:10): [True: 4.24M, False: 0]
  ------------------
  735|  4.24M|		SET_STRING_ELT(names, i, PRINTNAME(TAG(args)));
  736|      0|	    else
  737|      0|		SET_STRING_ELT(names, i, R_BlankString);
  738|  4.24M|	}
  739|  4.24M|	if (NAMED(CAR(args)))
  ------------------
  |  Branch (739:6): [True: 4.24M, False: 210]
  ------------------
  740|  4.24M|	    ENSURE_NAMEDMAX(CAR(args));
  741|  4.24M|	SET_VECTOR_ELT(list, i, CAR(args));
  742|  4.24M|	args = CDR(args);
  743|  4.24M|    }
  744|  1.93M|    if (havenames) {
  ------------------
  |  Branch (744:9): [True: 1.92M, False: 3.23k]
  ------------------
  745|  1.92M|	setAttrib(list, R_NamesSymbol, names);
  ------------------
  |  | 1027|  1.92M|#define setAttrib		Rf_setAttrib
  ------------------
  746|  1.92M|    }
  747|  1.93M|    UNPROTECT(2);
  ------------------
  |  |  358|  1.93M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  748|  1.93M|    return list;
  749|  1.93M|}
do_makevector:
  787|   385k|{
  788|   385k|    R_xlen_t len;
  789|   385k|    SEXP s;
  790|   385k|    SEXPTYPE mode;
  791|   385k|    checkArity(op, args);
  ------------------
  |  | 1788|   385k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  792|   385k|    if (length(CADR(args)) != 1) error(_("invalid '%s' argument"), "length");
  ------------------
  |  |  987|   385k|#define length(x)		Rf_length(x)
  ------------------
                  if (length(CADR(args)) != 1) error(_("invalid '%s' argument"), "length");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (length(CADR(args)) != 1) error(_("invalid '%s' argument"), "length");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (792:9): [True: 0, False: 385k]
  ------------------
  793|   385k|    len = asVecSize(CADR(args));
  ------------------
  |  | 1862|   385k|# define asVecSize		Rf_asVecSize
  ------------------
  794|   385k|    if (len < 0) error(_("invalid '%s' argument"), "length");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (len < 0) error(_("invalid '%s' argument"), "length");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (794:9): [True: 0, False: 385k]
  ------------------
  795|   385k|    s = coerceVector(CAR(args), STRSXP);
  ------------------
  |  |  895|   385k|#define coerceVector		Rf_coerceVector
  ------------------
                  s = coerceVector(CAR(args), STRSXP);
  ------------------
  |  |  126|   385k|#define STRSXP	    16	  /* string vectors */
  ------------------
  796|   385k|    if (length(s) != 1) error(_("invalid '%s' argument"), "mode");
  ------------------
  |  |  987|   385k|#define length(x)		Rf_length(x)
  ------------------
                  if (length(s) != 1) error(_("invalid '%s' argument"), "mode");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (length(s) != 1) error(_("invalid '%s' argument"), "mode");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (796:9): [True: 0, False: 385k]
  ------------------
  797|   385k|    mode = str2type(CHAR(STRING_ELT(s, 0))); /* ASCII */
  ------------------
  |  | 1031|   385k|#define str2type		Rf_str2type
  ------------------
                  mode = str2type(CHAR(STRING_ELT(s, 0))); /* ASCII */
  ------------------
  |  |  203|   385k|#define CHAR(x) R_CHAR(x)
  ------------------
  798|   385k|    if (mode == -1 && streql(CHAR(STRING_ELT(s, 0)), "double"))
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (798:9): [True: 0, False: 385k]
  ------------------
  799|      0|	mode = REALSXP;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  800|   385k|    switch (mode) {
  801|     12|    case LGLSXP:
  ------------------
  |  |  121|     12|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (801:5): [True: 12, False: 385k]
  ------------------
  802|     88|    case INTSXP:
  ------------------
  |  |  123|     88|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (802:5): [True: 76, False: 385k]
  ------------------
  803|     90|    case REALSXP:
  ------------------
  |  |  124|     90|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (803:5): [True: 2, False: 385k]
  ------------------
  804|     90|    case CPLXSXP:
  ------------------
  |  |  125|     90|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (804:5): [True: 0, False: 385k]
  ------------------
  805|    134|    case STRSXP:
  ------------------
  |  |  126|    134|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (805:5): [True: 44, False: 385k]
  ------------------
  806|    134|    case EXPRSXP:
  ------------------
  |  |  132|    134|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (806:5): [True: 0, False: 385k]
  ------------------
  807|   385k|    case VECSXP:
  ------------------
  |  |  131|   385k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (807:5): [True: 385k, False: 134]
  ------------------
  808|   385k|    case RAWSXP:
  ------------------
  |  |  136|   385k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (808:5): [True: 0, False: 385k]
  ------------------
  809|   385k|	s = allocVector(mode, len);
  ------------------
  |  |  875|   385k|#define allocVector		Rf_allocVector
  ------------------
  810|   385k|	break;
  811|      0|    case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (811:5): [True: 0, False: 385k]
  ------------------
  812|      0|	if (len > INT_MAX) error("too long for a pairlist");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (812:6): [True: 0, False: 0]
  ------------------
  813|      0|	s = allocList((int) len);
  ------------------
  |  |  871|      0|#define allocList		Rf_allocList
  ------------------
  814|      0|	break;
  815|      0|    default:
  ------------------
  |  Branch (815:5): [True: 0, False: 385k]
  ------------------
  816|      0|	error(_("vector: cannot make a vector of mode '%s'."),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("vector: cannot make a vector of mode '%s'."),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  817|      0|	      translateChar(STRING_ELT(s, 0))); /* should be ASCII */
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  818|   385k|    }
  819|   385k|    if (mode == INTSXP || mode == LGLSXP)
  ------------------
  |  |  123|   771k|#define INTSXP	    13	  /* integer vectors */
  ------------------
                  if (mode == INTSXP || mode == LGLSXP)
  ------------------
  |  |  121|   385k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (819:9): [True: 76, False: 385k]
  |  Branch (819:27): [True: 12, False: 385k]
  ------------------
  820|     88|	Memzero(INTEGER(s), len);
  ------------------
  |  |   63|     88|#define Memzero(p,n)  R_chk_memset(p, 0, (R_SIZE_T)(n) * sizeof(*p))
  ------------------
  821|   385k|    else if (mode == REALSXP)
  ------------------
  |  |  124|   385k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (821:14): [True: 2, False: 385k]
  ------------------
  822|      2|	Memzero(REAL(s), len);
  ------------------
  |  |   63|      2|#define Memzero(p,n)  R_chk_memset(p, 0, (R_SIZE_T)(n) * sizeof(*p))
  ------------------
  823|   385k|    else if (mode == CPLXSXP)
  ------------------
  |  |  125|   385k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (823:14): [True: 0, False: 385k]
  ------------------
  824|      0|	Memzero(COMPLEX(s), len);
  ------------------
  |  |   63|      0|#define Memzero(p,n)  R_chk_memset(p, 0, (R_SIZE_T)(n) * sizeof(*p))
  ------------------
  825|   385k|    else if (mode == RAWSXP)
  ------------------
  |  |  136|   385k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (825:14): [True: 0, False: 385k]
  ------------------
  826|      0|	Memzero(RAW(s), len);
  ------------------
  |  |   63|      0|#define Memzero(p,n)  R_chk_memset(p, 0, (R_SIZE_T)(n) * sizeof(*p))
  ------------------
  827|       |    /* other cases: list/expression have "NULL", ok */
  828|   385k|    return s;
  829|   385k|}
Rf_xlengthgets:
  838|     96|{
  839|     96|    R_xlen_t lenx, i;
  840|     96|    SEXP rval, names, xnames, t;
  841|     96|    if (!isVector(x) && !isList(x))
  ------------------
  |  |  974|     96|#define isVector		Rf_isVector
  ------------------
                  if (!isVector(x) && !isList(x))
  ------------------
  |  |  951|      0|#define isList			Rf_isList
  ------------------
  |  Branch (841:9): [True: 0, False: 96]
  |  Branch (841:25): [True: 0, False: 0]
  ------------------
  842|      0|	error(_("cannot set length of non-(vector or list)"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot set length of non-(vector or list)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  843|     96|    if (len < 0) error(_("invalid value")); // e.g. -999 from asVecSize()
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (len < 0) error(_("invalid value")); // e.g. -999 from asVecSize()
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (843:9): [True: 0, False: 96]
  ------------------
  844|     96|    if (isNull(x) && len > 0)
  ------------------
  |  |  956|     96|#define isNull			Rf_isNull
  ------------------
  |  Branch (844:9): [True: 0, False: 96]
  |  Branch (844:22): [True: 0, False: 0]
  ------------------
  845|      0|    	warning(_("length of NULL cannot be changed"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
                  	warning(_("length of NULL cannot be changed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  846|     96|    lenx = xlength(x);
  ------------------
  |  | 1049|     96|#define xlength(x)		Rf_xlength(x)
  ------------------
  847|     96|    if (lenx == len)
  ------------------
  |  Branch (847:9): [True: 0, False: 96]
  ------------------
  848|      0|	return (x);
  849|     96|    PROTECT(rval = allocVector(TYPEOF(x), len));
  ------------------
  |  |  357|     96|#define PROTECT(s)	Rf_protect(s)
  ------------------
  850|     96|    PROTECT(xnames = getAttrib(x, R_NamesSymbol));
  ------------------
  |  |  357|     96|#define PROTECT(s)	Rf_protect(s)
  ------------------
  851|     96|    if (xnames != R_NilValue)
  ------------------
  |  Branch (851:9): [True: 0, False: 96]
  ------------------
  852|      0|	names = allocVector(STRSXP, len);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	names = allocVector(STRSXP, len);
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  853|     96|    else names = R_NilValue;	/*- just for -Wall --- should we do this ? */
  854|     96|    switch (TYPEOF(x)) {
  855|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (855:5): [True: 0, False: 96]
  ------------------
  856|      0|	break;
  857|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (857:5): [True: 0, False: 96]
  ------------------
  858|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (858:5): [True: 0, False: 96]
  ------------------
  859|      0|	for (i = 0; i < len; i++)
  ------------------
  |  Branch (859:14): [True: 0, False: 0]
  ------------------
  860|      0|	    if (i < lenx) {
  ------------------
  |  Branch (860:10): [True: 0, False: 0]
  ------------------
  861|      0|		INTEGER(rval)[i] = INTEGER(x)[i];
  862|      0|		if (xnames != R_NilValue)
  ------------------
  |  Branch (862:7): [True: 0, False: 0]
  ------------------
  863|      0|		    SET_STRING_ELT(names, i, STRING_ELT(xnames, i));
  864|      0|	    }
  865|      0|	    else
  866|      0|		INTEGER(rval)[i] = NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  867|      0|	break;
  868|     96|    case REALSXP:
  ------------------
  |  |  124|     96|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (868:5): [True: 96, False: 0]
  ------------------
  869|    384|	for (i = 0; i < len; i++)
  ------------------
  |  Branch (869:14): [True: 288, False: 96]
  ------------------
  870|    288|	    if (i < lenx) {
  ------------------
  |  Branch (870:10): [True: 0, False: 288]
  ------------------
  871|      0|		REAL(rval)[i] = REAL(x)[i];
  872|      0|		if (xnames != R_NilValue)
  ------------------
  |  Branch (872:7): [True: 0, False: 0]
  ------------------
  873|      0|		    SET_STRING_ELT(names, i, STRING_ELT(xnames, i));
  874|      0|	    }
  875|    288|	    else
  876|    288|		REAL(rval)[i] = NA_REAL;
  ------------------
  |  |   58|    384|#define NA_REAL		R_NaReal
  ------------------
  877|     96|	break;
  878|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (878:5): [True: 0, False: 96]
  ------------------
  879|      0|	for (i = 0; i < len; i++)
  ------------------
  |  Branch (879:14): [True: 0, False: 0]
  ------------------
  880|      0|	    if (i < lenx) {
  ------------------
  |  Branch (880:10): [True: 0, False: 0]
  ------------------
  881|      0|		COMPLEX(rval)[i] = COMPLEX(x)[i];
  882|      0|		if (xnames != R_NilValue)
  ------------------
  |  Branch (882:7): [True: 0, False: 0]
  ------------------
  883|      0|		    SET_STRING_ELT(names, i, STRING_ELT(xnames, i));
  884|      0|	    }
  885|      0|	    else {
  886|      0|		COMPLEX(rval)[i].r = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  887|      0|		COMPLEX(rval)[i].i = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  888|      0|	    }
  889|      0|	break;
  890|      0|    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (890:5): [True: 0, False: 96]
  ------------------
  891|      0|	for (i = 0; i < len; i++)
  ------------------
  |  Branch (891:14): [True: 0, False: 0]
  ------------------
  892|      0|	    if (i < lenx) {
  ------------------
  |  Branch (892:10): [True: 0, False: 0]
  ------------------
  893|      0|		SET_STRING_ELT(rval, i, STRING_ELT(x, i));
  894|      0|		if (xnames != R_NilValue)
  ------------------
  |  Branch (894:7): [True: 0, False: 0]
  ------------------
  895|      0|		    SET_STRING_ELT(names, i, STRING_ELT(xnames, i));
  896|      0|	    }
  897|      0|	    else
  898|      0|		SET_STRING_ELT(rval, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  899|      0|	break;
  900|      0|    case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (900:5): [True: 0, False: 96]
  ------------------
  901|      0|	for (t = rval; t != R_NilValue; t = CDR(t), x = CDR(x)) {
  ------------------
  |  Branch (901:17): [True: 0, False: 0]
  ------------------
  902|      0|	    SETCAR(t, CAR(x));
  903|      0|	    SET_TAG(t, TAG(x));
  904|      0|	}
  905|      0|	break;
  906|      0|    case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (906:5): [True: 0, False: 96]
  ------------------
  907|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (907:5): [True: 0, False: 96]
  ------------------
  908|      0|	for (i = 0; i < len; i++)
  ------------------
  |  Branch (908:14): [True: 0, False: 0]
  ------------------
  909|      0|	    if (i < lenx) {
  ------------------
  |  Branch (909:10): [True: 0, False: 0]
  ------------------
  910|      0|		SET_VECTOR_ELT(rval, i, VECTOR_ELT(x, i));
  911|      0|		if (xnames != R_NilValue)
  ------------------
  |  Branch (911:7): [True: 0, False: 0]
  ------------------
  912|      0|		    SET_STRING_ELT(names, i, STRING_ELT(xnames, i));
  913|      0|	    }
  914|      0|	break;
  915|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (915:5): [True: 0, False: 96]
  ------------------
  916|      0|	for (i = 0; i < len; i++)
  ------------------
  |  Branch (916:14): [True: 0, False: 0]
  ------------------
  917|      0|	    if (i < lenx) {
  ------------------
  |  Branch (917:10): [True: 0, False: 0]
  ------------------
  918|      0|		RAW(rval)[i] = RAW(x)[i];
  919|      0|		if (xnames != R_NilValue)
  ------------------
  |  Branch (919:7): [True: 0, False: 0]
  ------------------
  920|      0|		    SET_STRING_ELT(names, i, STRING_ELT(xnames, i));
  921|      0|	    }
  922|      0|	    else
  923|      0|		RAW(rval)[i] = (Rbyte) 0;
  924|      0|	break;
  925|      0|    default:
  ------------------
  |  Branch (925:5): [True: 0, False: 96]
  ------------------
  926|      0|	UNIMPLEMENTED_TYPE("length<-", x);
  927|     96|    }
  928|     96|    if (isVector(x) && xnames != R_NilValue)
  ------------------
  |  |  974|     96|#define isVector		Rf_isVector
  ------------------
  |  Branch (928:9): [True: 96, False: 0]
  |  Branch (928:24): [True: 0, False: 96]
  ------------------
  929|      0|	setAttrib(rval, R_NamesSymbol, names);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  930|       |    // *not* keeping "class": in line with  x[1:k]
  931|     96|    UNPROTECT(2);
  ------------------
  |  |  358|     96|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  932|     96|    return rval;
  933|     96|}

do_nzchar:
  113|    100|{
  114|    100|    int nargs = length(args);
  ------------------
  |  |  987|    100|#define length(x)		Rf_length(x)
  ------------------
  115|       |
  116|       |    // checkArity(op, args);  .Primitive() and may have 1 or 2 args
  117|    100|    if (nargs < 1 || nargs > 2)
  ------------------
  |  Branch (117:9): [True: 0, False: 100]
  |  Branch (117:22): [True: 0, False: 100]
  ------------------
  118|      0|	errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  119|      0|		  ngettext("%d argument passed to '%s' which requires %d to %d",
  120|      0|			   "%d arguments passed to '%s' which requires %d to %d",
  121|      0|			   (unsigned long) nargs),
  122|      0|		  nargs, PRIMNAME(op), 1, 2);
  ------------------
  |  | 1346|      0|#define PRIMNAME(x)	(R_FunTab[PRIMOFFSET(x)].name)
  ------------------
  123|    100|    check1arg(args, call, "x");
  ------------------
  |  | 1867|    100|# define check1arg		Rf_check1arg
  ------------------
  124|       |
  125|    100|    if (isFactor(CAR(args)))
  ------------------
  |  |  946|    100|#define isFactor		Rf_isFactor
  ------------------
  |  Branch (125:9): [True: 0, False: 100]
  ------------------
  126|      0|	error(_("'%s' requires a character vector"), "nzchar()");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'%s' requires a character vector"), "nzchar()");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  127|    100|    SEXP x = PROTECT(coerceVector(CAR(args), STRSXP));
  ------------------
  |  |  357|    100|#define PROTECT(s)	Rf_protect(s)
  ------------------
  128|    100|    if (!isString(x))
  ------------------
  |  |  966|    100|#define isString		Rf_isString
  ------------------
  |  Branch (128:9): [True: 0, False: 100]
  ------------------
  129|      0|	error(_("'%s' requires a character vector"), "nzchar()");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'%s' requires a character vector"), "nzchar()");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  130|       |
  131|    100|    int keepNA = FALSE; // the default
  132|    100|    if(nargs > 1) {
  ------------------
  |  Branch (132:8): [True: 0, False: 100]
  ------------------
  133|      0|	keepNA = asLogical(CADR(args));
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
  134|      0|	if (keepNA == NA_LOGICAL) keepNA = FALSE;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (134:6): [True: 0, False: 0]
  ------------------
  135|      0|    }
  136|    100|    R_xlen_t i, len = XLENGTH(x);
  137|    100|    SEXP ans = PROTECT(allocVector(LGLSXP, len));
  ------------------
  |  |  357|    100|#define PROTECT(s)	Rf_protect(s)
  ------------------
  138|    100|    if (keepNA)
  ------------------
  |  Branch (138:9): [True: 0, False: 100]
  ------------------
  139|      0|	for (i = 0; i < len; i++) {
  ------------------
  |  Branch (139:14): [True: 0, False: 0]
  ------------------
  140|      0|	    SEXP sxi = STRING_ELT(x, i);
  141|      0|	    LOGICAL(ans)[i] = (sxi == NA_STRING) ? NA_LOGICAL : LENGTH(sxi) > 0;
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
              	    LOGICAL(ans)[i] = (sxi == NA_STRING) ? NA_LOGICAL : LENGTH(sxi) > 0;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (141:24): [True: 0, False: 0]
  ------------------
  142|      0|	}
  143|    100|    else
  144|    208|	for (i = 0; i < len; i++)
  ------------------
  |  Branch (144:14): [True: 108, False: 100]
  ------------------
  145|    108|	    LOGICAL(ans)[i] = LENGTH(STRING_ELT(x, i)) > 0;
  146|    100|    UNPROTECT(2);
  ------------------
  |  |  358|    100|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  147|    100|    return ans;
  148|    100|}
R_nchar:
  166|      3|{
  167|      3|    if (string == NA_STRING)
  ------------------
  |  |  433|      3|#define NA_STRING	R_NaString
  ------------------
  |  Branch (167:9): [True: 0, False: 3]
  ------------------
  168|      0|	return keepNA ? NA_INTEGER : 2;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (168:9): [True: 0, False: 0]
  ------------------
  169|       |    // else :
  170|      3|    switch(type_) {
  ------------------
  |  Branch (170:12): [True: 3, False: 0]
  ------------------
  171|      0|    case Bytes:
  ------------------
  |  Branch (171:5): [True: 0, False: 3]
  ------------------
  172|      0|	return LENGTH(string);
  173|      0|	break;
  174|      3|    case Chars:
  ------------------
  |  Branch (174:5): [True: 3, False: 0]
  ------------------
  175|      3|	if (IS_UTF8(string)) {
  ------------------
  |  Branch (175:6): [True: 0, False: 3]
  ------------------
  176|      0|	    const char *p = CHAR(string);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  177|      0|	    if (!utf8Valid(p)) {
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
  |  Branch (177:10): [True: 0, False: 0]
  ------------------
  178|      0|		if (!allowNA) {
  ------------------
  |  Branch (178:7): [True: 0, False: 0]
  ------------------
  179|      0|		    if (msg_name)
  ------------------
  |  Branch (179:11): [True: 0, False: 0]
  ------------------
  180|      0|			error(_("invalid multibyte string, %s"), msg_name);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              			error(_("invalid multibyte string, %s"), msg_name);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  181|      0|		    else
  182|      0|			return -1;
  183|      0|		}
  184|      0|		return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  185|      0|	    } else {
  186|      0|		int nc = 0;
  187|      0|		for( ; *p; p += utf8clen(*p)) nc++;
  ------------------
  |  | 2008|      0|# define utf8clen		Rf_utf8clen
  ------------------
  |  Branch (187:10): [True: 0, False: 0]
  ------------------
  188|      0|		return nc;
  189|      0|	    }
  190|      3|	} else if (IS_LATIN1(string)) {
  ------------------
  |  Branch (190:13): [True: 0, False: 3]
  ------------------
  191|       |	    // just count bytes
  192|      0|	    return (int) strlen(CHAR(string));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  193|      3|	} else if (IS_BYTES(string)) {
  ------------------
  |  Branch (193:13): [True: 0, False: 3]
  ------------------
  194|      0|	    if (!allowNA) /* could do chars 0 */ {
  ------------------
  |  Branch (194:10): [True: 0, False: 0]
  ------------------
  195|      0|		if (msg_name)
  ------------------
  |  Branch (195:7): [True: 0, False: 0]
  ------------------
  196|      0|		    error(_("number of characters is not computable in \"bytes\" encoding, %s"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("number of characters is not computable in \"bytes\" encoding, %s"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  197|      0|		          msg_name);
  198|      0|		else
  199|      0|		    return -2;
  200|      0|	    }
  201|      0|	    return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  202|      3|	} else if (mbcslocale) {
  ------------------
  |  Branch (202:13): [True: 0, False: 3]
  ------------------
  203|      0|	    int nc = (int) mbstowcs(NULL, translateChar(string), 0);
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  204|      0|	    if (!allowNA && nc < 0) {
  ------------------
  |  Branch (204:10): [True: 0, False: 0]
  |  Branch (204:22): [True: 0, False: 0]
  ------------------
  205|      0|		if (msg_name)
  ------------------
  |  Branch (205:7): [True: 0, False: 0]
  ------------------
  206|      0|		    error(_("invalid multibyte string, %s"), msg_name);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid multibyte string, %s"), msg_name);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  207|      0|		else
  208|      0|		    return -1;
  209|      0|	    }
  210|      0|	    return (nc >= 0 ? nc : NA_INTEGER);
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (210:14): [True: 0, False: 0]
  ------------------
  211|      0|	} else
  212|      3|	    return ((int) strlen(translateChar(string)));
  ------------------
  |  | 1037|      3|#define translateChar		Rf_translateChar
  ------------------
  213|      0|	break;
  214|      0|    case Width:
  ------------------
  |  Branch (214:5): [True: 0, False: 3]
  ------------------
  215|      0|	if (IS_UTF8(string)) {
  ------------------
  |  Branch (215:6): [True: 0, False: 0]
  ------------------
  216|      0|	    const char *p = CHAR(string);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  217|      0|	    if (!utf8Valid(p)) {
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
  |  Branch (217:10): [True: 0, False: 0]
  ------------------
  218|      0|		if (!allowNA) {
  ------------------
  |  Branch (218:7): [True: 0, False: 0]
  ------------------
  219|      0|		    if (msg_name)
  ------------------
  |  Branch (219:11): [True: 0, False: 0]
  ------------------
  220|      0|			error(_("invalid multibyte string, %s"), msg_name);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              			error(_("invalid multibyte string, %s"), msg_name);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  221|      0|		    else
  222|      0|			return -1;
  223|      0|		}
  224|      0|		return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  225|      0|	    } else {
  226|      0|		int nc = 0;
  227|      0|		for( ; *p; p += utf8clen(*p)) {
  ------------------
  |  | 2008|      0|# define utf8clen		Rf_utf8clen
  ------------------
  |  Branch (227:10): [True: 0, False: 0]
  ------------------
  228|      0|		    wchar_t wc1;
  229|      0|		    utf8toucs(&wc1, p);
  ------------------
  |  | 2009|      0|# define utf8toucs		Rf_utf8toucs
  ------------------
  230|      0|		    R_wchar_t ucs;
  231|      0|		    if (IS_HIGH_SURROGATE(wc1))
  ------------------
  |  |  173|      0|#define IS_HIGH_SURROGATE(wch) (((wch) >= HIGH_SURROGATE_START) && ((wch) <= HIGH_SURROGATE_END))
  |  |  ------------------
  |  |  |  |  162|      0|#define HIGH_SURROGATE_START 0xd800
  |  |  ------------------
  |  |               #define IS_HIGH_SURROGATE(wch) (((wch) >= HIGH_SURROGATE_START) && ((wch) <= HIGH_SURROGATE_END))
  |  |  ------------------
  |  |  |  |  163|      0|#define HIGH_SURROGATE_END 0xdbff
  |  |  ------------------
  |  |  |  Branch (173:33): [True: 0, False: 0]
  |  |  |  Branch (173:68): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  232|      0|		    	ucs = utf8toucs32(wc1, p);
  ------------------
  |  |  177|      0|# define utf8toucs32		Rf_utf8toucs32
  ------------------
  233|      0|		    else
  234|      0|		    	ucs = wc1;
  235|      0|#ifdef USE_RI18N_WIDTH
  236|      0|		    nc += Ri18n_wcwidth(ucs);
  237|       |#else
  238|       |		    {
  239|       |			int this = wcwidth(ucs);
  240|       |			if (this >= 0) nc += this;
  241|       |		    }
  242|       |#endif
  243|      0|		}
  244|      0|		return nc;
  245|      0|	    }
  246|      0|	} else if (IS_BYTES(string)) {
  ------------------
  |  Branch (246:13): [True: 0, False: 0]
  ------------------
  247|      0|	    if (!allowNA) { /* could do width 0 */
  ------------------
  |  Branch (247:10): [True: 0, False: 0]
  ------------------
  248|      0|		if (msg_name)
  ------------------
  |  Branch (248:7): [True: 0, False: 0]
  ------------------
  249|      0|		    error(_("width is not computable for %s in \"bytes\" encoding"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("width is not computable for %s in \"bytes\" encoding"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  250|      0|		          msg_name);
  251|      0|		else
  252|      0|		    return -2;
  253|      0|	    }
  254|      0|	    return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  255|      0|	} else if (IS_LATIN1(string)) {
  ------------------
  |  Branch (255:13): [True: 0, False: 0]
  ------------------
  256|       |	    // just count bytes as they are all width-1 chars
  257|       |	    // FIXME, well not control chars but there is ambiguity for most of 0x80-9F
  258|      0|	    return (int) strlen(CHAR(string));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  259|      0|	} else if (mbcslocale) {
  ------------------
  |  Branch (259:13): [True: 0, False: 0]
  ------------------
  260|      0|	    const char *xi = translateChar(string);
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  261|      0|	    int nc = (int) mbstowcs(NULL, xi, 0);
  262|      0|	    if (nc >= 0) {
  ------------------
  |  Branch (262:10): [True: 0, False: 0]
  ------------------
  263|      0|		const void *vmax = vmaxget();
  264|       |		/* working in wchar_t restricts this to the BMP on
  265|       |		   Windows, but maybe that is all current native
  266|       |		   charsets cover. */
  267|      0|		wchar_t *wc = (wchar_t *)
  268|      0|		    R_AllocStringBuffer((nc+1)*sizeof(wchar_t), &cbuff);
  269|      0|		mbstowcs(wc, xi, nc + 1);
  270|       |		// FIXME: width could conceivably exceed MAX_INT.
  271|      0|#ifdef USE_RI18N_WIDTH
  272|      0|		int nci18n = Ri18n_wcswidth(wc, 2147483647);
  273|       |#else
  274|       |		// We do not use this unless R_wchar_t is wchar_t
  275|       |		// This could be -1 if there are non-printable chars,
  276|       |		// then this is ignored
  277|       |		int nci18n = wcswidth(wc, 2147483647);
  278|       |#endif
  279|      0|		if (msg_name)
  ------------------
  |  Branch (279:7): [True: 0, False: 0]
  ------------------
  280|      0|		    R_FreeStringBufferL(&cbuff);
  281|      0|		vmaxset(vmax);
  282|      0|		return (nci18n < 0) ? nc : nci18n;
  ------------------
  |  Branch (282:10): [True: 0, False: 0]
  ------------------
  283|      0|	    } else if (!allowNA) {
  ------------------
  |  Branch (283:17): [True: 0, False: 0]
  ------------------
  284|      0|		if (msg_name)
  ------------------
  |  Branch (284:7): [True: 0, False: 0]
  ------------------
  285|      0|		    error(_("invalid multibyte string, %s"), msg_name);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid multibyte string, %s"), msg_name);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  286|      0|		else
  287|      0|		    return -1;
  288|      0|	    }
  289|      0|	    else
  290|      0|		return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  291|      0|	} else
  292|       |	    // See Latin-1 comment.
  293|      0|	    return (int) strlen(translateChar(string));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  294|       |
  295|      3|    } // switch
  296|      0|    return NA_INTEGER; // -Wall
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  297|      3|} // R_nchar()
do_nchar:
  300|      3|{
  301|      3|    SEXP d, s, x, stype, ans;
  302|      3|    int nargs = length(args);
  ------------------
  |  |  987|      3|#define length(x)		Rf_length(x)
  ------------------
  303|       |
  304|       |#ifdef R_version_3_4_or_so
  305|       |    checkArity(op, args);
  306|       |#else
  307|       |    // will work also for code byte-compiled *before* 'keepNA' was introduced
  308|      3|    if (nargs < 3 || nargs > 4)
  ------------------
  |  Branch (308:9): [True: 0, False: 3]
  |  Branch (308:22): [True: 0, False: 3]
  ------------------
  309|      0|	error(ngettext("%d argument passed to '%s' which requires %d to %d",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  310|      0|		       "%d arguments passed to '%s' which requires %d to %d",
  311|      0|			   (unsigned long) nargs),
  312|      0|	      nargs, PRIMNAME(op), 3, 4);
  ------------------
  |  | 1346|      0|#define PRIMNAME(x)	(R_FunTab[PRIMOFFSET(x)].name)
  ------------------
  313|      3|#endif
  314|       |    /* DispatchOrEval internal generic: nchar */
  315|      3|    if (DispatchOrEval(call, op, "nchar", args, env, &ans, 0, 1))
  ------------------
  |  | 1887|      3|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (315:9): [True: 0, False: 3]
  ------------------
  316|      0|      return(ans);
  317|      3|    if (isFactor(CAR(args)))
  ------------------
  |  |  946|      3|#define isFactor		Rf_isFactor
  ------------------
  |  Branch (317:9): [True: 0, False: 3]
  ------------------
  318|      0|	error(_("'%s' requires a character vector"), "nchar()");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'%s' requires a character vector"), "nchar()");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  319|      3|    PROTECT(x = coerceVector(CAR(args), STRSXP));
  ------------------
  |  |  357|      3|#define PROTECT(s)	Rf_protect(s)
  ------------------
  320|      3|    if (!isString(x))
  ------------------
  |  |  966|      3|#define isString		Rf_isString
  ------------------
  |  Branch (320:9): [True: 0, False: 3]
  ------------------
  321|      0|	error(_("'%s' requires a character vector"), "nchar()");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'%s' requires a character vector"), "nchar()");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  322|      3|    R_xlen_t len = XLENGTH(x);
  323|      3|    stype = CADR(args);
  324|      3|    if (!isString(stype) || LENGTH(stype) != 1)
  ------------------
  |  |  966|      3|#define isString		Rf_isString
  ------------------
  |  Branch (324:9): [True: 0, False: 3]
  |  Branch (324:29): [True: 0, False: 3]
  ------------------
  325|      0|	error(_("invalid '%s' argument"), "type");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "type");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  326|      3|    const char *type = CHAR(STRING_ELT(stype, 0)); /* always ASCII */
  ------------------
  |  |  203|      3|#define CHAR(x) R_CHAR(x)
  ------------------
  327|      3|    size_t ntype = strlen(type);
  328|      3|    if (ntype == 0) error(_("invalid '%s' argument"), "type");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (ntype == 0) error(_("invalid '%s' argument"), "type");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (328:9): [True: 0, False: 3]
  ------------------
  329|      3|    nchar_type type_;
  330|      3|    if (strncmp(type, "bytes", ntype) == 0)	 type_ = Bytes;
  ------------------
  |  Branch (330:9): [True: 0, False: 3]
  ------------------
  331|      3|    else if (strncmp(type, "chars", ntype) == 0) type_ = Chars;
  ------------------
  |  Branch (331:14): [True: 3, False: 0]
  ------------------
  332|      0|    else if (strncmp(type, "width", ntype) == 0) type_ = Width;
  ------------------
  |  Branch (332:14): [True: 0, False: 0]
  ------------------
  333|      0|    else error(_("invalid '%s' argument"), "type");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  else error(_("invalid '%s' argument"), "type");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  334|      3|    int allowNA = asLogical(CADDR(args));
  ------------------
  |  |  886|      3|#define asLogical		Rf_asLogical
  ------------------
  335|      3|    if (allowNA == NA_LOGICAL) allowNA = 0;
  ------------------
  |  |   55|      3|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (335:9): [True: 0, False: 3]
  ------------------
  336|      3|    int keepNA;
  337|      3|    if(nargs >= 4) {
  ------------------
  |  Branch (337:8): [True: 3, False: 0]
  ------------------
  338|      3|	keepNA = asLogical(CADDDR(args));
  ------------------
  |  |  886|      3|#define asLogical		Rf_asLogical
  ------------------
  339|      3|	if (keepNA == NA_LOGICAL) // default
  ------------------
  |  |   55|      3|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (339:6): [True: 3, False: 0]
  ------------------
  340|      3|	    keepNA = (type_ == Width) ? FALSE : TRUE;
  ------------------
  |  Branch (340:15): [True: 0, False: 3]
  ------------------
  341|      3|    } else  keepNA = (type_ == Width) ? FALSE : TRUE;
  ------------------
  |  Branch (341:22): [True: 0, False: 0]
  ------------------
  342|      3|    PROTECT(s = allocVector(INTSXP, len));
  ------------------
  |  |  357|      3|#define PROTECT(s)	Rf_protect(s)
  ------------------
  343|      3|    int *s_ = INTEGER(s);
  344|      6|    for (R_xlen_t i = 0; i < len; i++) {
  ------------------
  |  Branch (344:26): [True: 3, False: 3]
  ------------------
  345|      3|	SEXP sxi = STRING_ELT(x, i);
  346|       |	// NA_LOGICAL has now been excluded
  347|      3|	int res = R_nchar(sxi, type_,
  348|      3|			  (Rboolean) allowNA, (Rboolean) keepNA, NULL);
  349|      3|	switch(res) {
  350|      0|	case -1:
  ------------------
  |  Branch (350:2): [True: 0, False: 3]
  ------------------
  351|      0|	    error(_("invalid multibyte string, element %lld"), (long long)i+1);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid multibyte string, element %lld"), (long long)i+1);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  352|      0|	case -2:
  ------------------
  |  Branch (352:2): [True: 0, False: 3]
  ------------------
  353|      0|	    if (type_ == Chars)
  ------------------
  |  Branch (353:10): [True: 0, False: 0]
  ------------------
  354|      0|		error(_("number of characters is not computable in \"bytes\" encoding, element %lld"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("number of characters is not computable in \"bytes\" encoding, element %lld"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  355|      0|		      (long long)i+1);
  356|      0|	    else /* type_ == Width */
  357|      0|		error(_("width is not computable in \"bytes\" encoding, element %lld"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("width is not computable in \"bytes\" encoding, element %lld"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  358|      0|		      (long long)i+1);
  359|      3|	default:
  ------------------
  |  Branch (359:2): [True: 3, False: 0]
  ------------------
  360|      3|	    s_[i] = res;
  361|      3|	    break;
  362|      3|	}
  363|      3|    }
  364|      3|    R_FreeStringBufferL(&cbuff);
  365|      3|    if ((d = getAttrib(x, R_NamesSymbol)) != R_NilValue)
  ------------------
  |  |  924|      3|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (365:9): [True: 0, False: 3]
  ------------------
  366|      0|	setAttrib(s, R_NamesSymbol, d);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  367|      3|    if ((d = getAttrib(x, R_DimSymbol)) != R_NilValue)
  ------------------
  |  |  924|      3|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (367:9): [True: 0, False: 3]
  ------------------
  368|      0|	setAttrib(s, R_DimSymbol, d);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  369|      3|    if ((d = getAttrib(x, R_DimNamesSymbol)) != R_NilValue)
  ------------------
  |  |  924|      3|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (369:9): [True: 0, False: 3]
  ------------------
  370|      0|	setAttrib(s, R_DimNamesSymbol, d);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  371|      3|    UNPROTECT(2);
  ------------------
  |  |  358|      3|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  372|      3|    return s;
  373|      3|}
do_startsWith:
  496|     82|{
  497|     82|    checkArity(op, args);
  ------------------
  |  | 1788|     82|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  498|       |
  499|     82|    SEXP x = CAR(args), Xfix = CADR(args); // 'prefix' or 'suffix'
  500|     82|    if (!isString(x) || !isString(Xfix))
  ------------------
  |  |  966|     82|#define isString		Rf_isString
  ------------------
                  if (!isString(x) || !isString(Xfix))
  ------------------
  |  |  966|     82|#define isString		Rf_isString
  ------------------
  |  Branch (500:9): [True: 0, False: 82]
  |  Branch (500:25): [True: 0, False: 82]
  ------------------
  501|      0|	error(_("non-character object(s)"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("non-character object(s)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  502|     82|    R_xlen_t
  503|     82|	n1 = XLENGTH(x),
  504|     82|	n2 = XLENGTH(Xfix),
  505|     82|	n = (n1 > 0 && n2 > 0) ? ((n1 >= n2) ? n1 : n2) : 0;
  ------------------
  |  Branch (505:7): [True: 70, False: 12]
  |  Branch (505:17): [True: 70, False: 0]
  |  Branch (505:28): [True: 70, False: 0]
  ------------------
  506|     82|    if (n == 0) return allocVector(LGLSXP, 0);
  ------------------
  |  |  875|     12|#define allocVector		Rf_allocVector
  ------------------
                  if (n == 0) return allocVector(LGLSXP, 0);
  ------------------
  |  |  121|     12|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (506:9): [True: 12, False: 70]
  ------------------
  507|     70|    SEXP ans = PROTECT(allocVector(LGLSXP, n));
  ------------------
  |  |  357|     70|#define PROTECT(s)	Rf_protect(s)
  ------------------
  508|       |
  509|     70|    typedef const char * cp;
  510|     70|    if (n2 == 1) { // optimize the most common case
  ------------------
  |  Branch (510:9): [True: 70, False: 0]
  ------------------
  511|     70|	SEXP el = STRING_ELT(Xfix, 0);
  512|     70|	if (el == NA_STRING) {
  ------------------
  |  |  433|     70|#define NA_STRING	R_NaString
  ------------------
  |  Branch (512:6): [True: 0, False: 70]
  ------------------
  513|      0|	    for (R_xlen_t i = 0; i < n1; i++)
  ------------------
  |  Branch (513:27): [True: 0, False: 0]
  ------------------
  514|      0|		LOGICAL(ans)[i] = NA_LOGICAL;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  515|     70|	} else {
  516|       |	    // ASCII matching will do for ASCII Xfix except in non-UTF-8 MBCS
  517|     70|	    Rboolean need_translate = TRUE;
  518|     70|	    if (IS_ASCII(el) && (utf8locale || !mbcslocale))
  ------------------
  |  Branch (518:10): [True: 70, False: 0]
  |  Branch (518:27): [True: 0, False: 70]
  |  Branch (518:41): [True: 70, False: 0]
  ------------------
  519|     70|		need_translate = FALSE;
  520|     70|	    cp y0 = need_translate ? translateCharUTF8(el) : CHAR(el);
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
              	    cp y0 = need_translate ? translateCharUTF8(el) : CHAR(el);
  ------------------
  |  |  203|     70|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (520:14): [True: 0, False: 70]
  ------------------
  521|     70|	    int ylen = (int) strlen(y0);
  522|  21.2k|	    for (R_xlen_t i = 0; i < n1; i++) {
  ------------------
  |  Branch (522:27): [True: 21.1k, False: 70]
  ------------------
  523|  21.1k|		SEXP el = STRING_ELT(x, i);
  524|  21.1k|		if (el == NA_STRING) {
  ------------------
  |  |  433|  21.1k|#define NA_STRING	R_NaString
  ------------------
  |  Branch (524:7): [True: 0, False: 21.1k]
  ------------------
  525|      0|		    LOGICAL(ans)[i] = NA_LOGICAL;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  526|  21.1k|		} else {
  527|  21.1k|		    cp x0 = need_translate ? translateCharUTF8(el) : CHAR(el);
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
              		    cp x0 = need_translate ? translateCharUTF8(el) : CHAR(el);
  ------------------
  |  |  203|  21.1k|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (527:15): [True: 0, False: 21.1k]
  ------------------
  528|  21.1k|		    if(PRIMVAL(op) == 0) { // startsWith
  ------------------
  |  | 1347|  21.1k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (528:10): [True: 21.1k, False: 0]
  ------------------
  529|  21.1k|			LOGICAL(ans)[i] = strncmp(x0, y0, ylen) == 0;
  530|  21.1k|		    } else { // endsWith
  531|      0|			int off = (int)strlen(x0) - ylen;
  532|      0|			if (off < 0)
  ------------------
  |  Branch (532:8): [True: 0, False: 0]
  ------------------
  533|      0|			    LOGICAL(ans)[i] = 0;
  534|      0|			else {
  535|      0|			    LOGICAL(ans)[i] = memcmp(x0 + off, y0, ylen) == 0;
  536|      0|			}
  537|      0|		    }
  538|  21.1k|		}
  539|  21.1k|	    }
  540|     70|	}
  541|     70|    } else { // n2 > 1
  542|       |	// convert both inputs to UTF-8
  543|      0|	cp *x0 = (cp *) R_alloc(n1, sizeof(char *));
  544|      0|	cp *y0 = (cp *) R_alloc(n2, sizeof(char *));
  545|       |	// and record lengths, -1 for NA
  546|      0|	int *x1 = (int *) R_alloc(n1, sizeof(int));
  547|      0|	int *y1 = (int *) R_alloc(n2, sizeof(int));
  548|      0|	for (R_xlen_t i = 0; i < n1; i++) {
  ------------------
  |  Branch (548:23): [True: 0, False: 0]
  ------------------
  549|      0|	    SEXP el = STRING_ELT(x, i);
  550|      0|	    if (el == NA_STRING)
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (550:10): [True: 0, False: 0]
  ------------------
  551|      0|		x1[i] = -1;
  552|      0|	    else {
  553|      0|		x0[i] = translateCharUTF8(el);
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  554|      0|		x1[i] = (int) strlen(x0[i]);
  555|      0|	    }
  556|      0|	}
  557|      0|	for (R_xlen_t i = 0; i < n2; i++) {
  ------------------
  |  Branch (557:23): [True: 0, False: 0]
  ------------------
  558|      0|	    SEXP el = STRING_ELT(Xfix, i);
  559|      0|	    if (el == NA_STRING)
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (559:10): [True: 0, False: 0]
  ------------------
  560|      0|		y1[i] = -1;
  561|      0|	    else {
  562|      0|		y0[i] = translateCharUTF8(el);
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  563|      0|		y1[i] = (int) strlen(y0[i]);
  564|      0|	    }
  565|      0|	}
  566|      0|	R_xlen_t i, i1, i2;
  567|      0|	if(PRIMVAL(op) == 0) { // 0 = startsWith, 1 = endsWith
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (567:5): [True: 0, False: 0]
  ------------------
  568|      0|	    MOD_ITERATE2(n, n1, n2, i, i1, i2, {
  ------------------
  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  ------------------
  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   84|      0|		}							\
  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  569|      0|		    if (x1[i1] < 0 || y1[i2] < 0)
  570|      0|			LOGICAL(ans)[i] = NA_LOGICAL;
  571|      0|		    else if (x1[i1] < y1[i2])
  572|      0|			LOGICAL(ans)[i] = 0;
  573|      0|		    else // memcmp should be faster than strncmp
  574|      0|			LOGICAL(ans)[i] =
  575|      0|			    memcmp(x0[i1], y0[i2], y1[i2]) == 0;
  576|      0|		});
  577|      0|	} else { // endsWith
  578|      0|	    MOD_ITERATE2(n, n1, n2, i, i1, i2, {
  ------------------
  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  ------------------
  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   84|      0|		}							\
  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  579|      0|		    if (x1[i1] < 0 || y1[i2] < 0)
  580|      0|			LOGICAL(ans)[i] = NA_LOGICAL;
  581|      0|		    else {
  582|      0|			int off = x1[i1] - y1[i2];
  583|      0|			if (off < 0)
  584|      0|			    LOGICAL(ans)[i] = 0;
  585|      0|			else {
  586|      0|			    LOGICAL(ans)[i] =
  587|      0|				memcmp(x0[i1] + off, y0[i2], y1[i2]) == 0;
  588|      0|			}
  589|      0|		    }
  590|      0|		});
  591|      0|	}
  592|      0|    }
  593|     70|    UNPROTECT(1);
  ------------------
  |  |  358|     70|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  594|     70|    return ans;
  595|     82|}
do_makenames:
  993|      2|{
  994|      2|    SEXP arg, ans;
  995|      2|    R_xlen_t i, n;
  996|      2|    int l, allow_;
  997|      2|    char *p, *tmp = NULL, *cbuf;
  998|      2|    const char *This;
  999|      2|    Rboolean need_prefix;
 1000|      2|    const void *vmax;
 1001|       |
 1002|      2|    checkArity(op ,args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1003|      2|    arg = CAR(args);
 1004|      2|    if (!isString(arg))
  ------------------
  |  |  966|      2|#define isString		Rf_isString
  ------------------
  |  Branch (1004:9): [True: 0, False: 2]
  ------------------
 1005|      0|	error(_("non-character names"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("non-character names"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1006|      2|    n = XLENGTH(arg);
 1007|      2|    allow_ = asLogical(CADR(args));
  ------------------
  |  |  886|      2|#define asLogical		Rf_asLogical
  ------------------
 1008|      2|    if (allow_ == NA_LOGICAL)
  ------------------
  |  |   55|      2|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1008:9): [True: 0, False: 2]
  ------------------
 1009|      0|	error(_("invalid '%s' value"), "allow_");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' value"), "allow_");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1010|      2|    PROTECT(ans = allocVector(STRSXP, n));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1011|      2|    vmax = vmaxget();
 1012|     14|    for (i = 0 ; i < n ; i++) {
  ------------------
  |  Branch (1012:18): [True: 12, False: 2]
  ------------------
 1013|     12|	This = translateChar(STRING_ELT(arg, i));
  ------------------
  |  | 1037|     12|#define translateChar		Rf_translateChar
  ------------------
 1014|     12|	l = (int) strlen(This);
 1015|       |	/* need to prefix names not beginning with alpha or ., as
 1016|       |	   well as . followed by a number */
 1017|     12|	need_prefix = FALSE;
 1018|     12|	if (mbcslocale && This[0]) {
  ------------------
  |  Branch (1018:6): [True: 0, False: 12]
  |  Branch (1018:20): [True: 0, False: 0]
  ------------------
 1019|      0|	    int nc = l, used;
 1020|      0|	    wchar_t wc;
 1021|      0|	    mbstate_t mb_st;
 1022|      0|	    const char *pp = This;
 1023|      0|	    mbs_init(&mb_st);
  ------------------
  |  | 2454|      0|#define mbs_init(x) memset(x, 0, sizeof(mbstate_t))
  ------------------
 1024|      0|	    used = (int) Mbrtowc(&wc, pp, R_MB_CUR_MAX, &mb_st);
  ------------------
  |  | 1949|      0|# define Mbrtowc		Rf_mbrtowc
  ------------------
 1025|      0|	    pp += used; nc -= used;
 1026|      0|	    if (wc == L'.') {
  ------------------
  |  Branch (1026:10): [True: 0, False: 0]
  ------------------
 1027|      0|		if (nc > 0) {
  ------------------
  |  Branch (1027:7): [True: 0, False: 0]
  ------------------
 1028|      0|		    Mbrtowc(&wc, pp, R_MB_CUR_MAX, &mb_st);
  ------------------
  |  | 1949|      0|# define Mbrtowc		Rf_mbrtowc
  ------------------
 1029|      0|		    if (iswdigit(wc))  need_prefix = TRUE;
  ------------------
  |  Branch (1029:11): [True: 0, False: 0]
  ------------------
 1030|      0|		}
 1031|      0|	    } else if (!iswalpha(wc)) need_prefix = TRUE;
  ------------------
  |  Branch (1031:17): [True: 0, False: 0]
  ------------------
 1032|     12|	} else {
 1033|     12|	    if (This[0] == '.') {
  ------------------
  |  Branch (1033:10): [True: 0, False: 12]
  ------------------
 1034|      0|		if (l >= 1 && isdigit(0xff & (int) This[1])) need_prefix = TRUE;
  ------------------
  |  Branch (1034:7): [True: 0, False: 0]
  |  Branch (1034:17): [True: 0, False: 0]
  ------------------
 1035|     12|	    } else if (!isalpha(0xff & (int) This[0])) need_prefix = TRUE;
  ------------------
  |  Branch (1035:17): [True: 0, False: 12]
  ------------------
 1036|     12|	}
 1037|       |	/* Use R_alloc() rather than R_Calloc(): the invalid multibyte
 1038|       |	   string error below would otherwise leak the buffer.
 1039|       |	   vmaxset() at the end of each iteration releases it. */
 1040|     12|	if (need_prefix) {
  ------------------
  |  Branch (1040:6): [True: 0, False: 12]
  ------------------
 1041|      0|	    tmp = R_alloc(l+2, sizeof(char));
 1042|      0|	    strcpy(tmp, "X");
 1043|      0|	    strcat(tmp, translateChar(STRING_ELT(arg, i)));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
 1044|     12|	} else {
 1045|     12|	    tmp = R_alloc(l+1, sizeof(char));
 1046|     12|	    strcpy(tmp, translateChar(STRING_ELT(arg, i)));
  ------------------
  |  | 1037|     12|#define translateChar		Rf_translateChar
  ------------------
 1047|     12|	}
 1048|     12|	if (mbcslocale) {
  ------------------
  |  Branch (1048:6): [True: 0, False: 12]
  ------------------
 1049|       |	    /* This cannot lengthen the string, so safe to overwrite it. */
 1050|      0|	    int nc = (int) mbstowcs(NULL, tmp, 0);
 1051|      0|	    if (nc >= 0) {
  ------------------
  |  Branch (1051:10): [True: 0, False: 0]
  ------------------
 1052|      0|		wchar_t *wstr = R_Calloc(nc+1, wchar_t);
  ------------------
  |  |   55|      0|#define R_Calloc(n, t)   (t *) R_chk_calloc( (R_SIZE_T) (n), sizeof(t) )
  ------------------
 1053|      0|		mbstowcs(wstr, tmp, nc+1);
 1054|      0|		for (wchar_t * wc = wstr; *wc; wc++) {
  ------------------
  |  Branch (1054:29): [True: 0, False: 0]
  ------------------
 1055|      0|		    if (*wc == L'.' || (allow_ && *wc == L'_'))
  ------------------
  |  Branch (1055:11): [True: 0, False: 0]
  |  Branch (1055:27): [True: 0, False: 0]
  |  Branch (1055:37): [True: 0, False: 0]
  ------------------
 1056|      0|			/* leave alone */;
 1057|      0|		    else if (!iswalnum((int)*wc)) *wc = L'.';
  ------------------
  |  Branch (1057:16): [True: 0, False: 0]
  ------------------
 1058|      0|		}
 1059|      0|		wcstombs(tmp, wstr, strlen(tmp)+1);
 1060|      0|		R_Free(wstr);
  ------------------
  |  |   57|      0|#define R_Free(p)      (R_chk_free( (void *)(p) ), (p) = NULL)
  ------------------
 1061|      0|	    } else error(_("invalid multibyte string %lld"), (long long)i+1);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    } else error(_("invalid multibyte string %lld"), (long long)i+1);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1062|     12|	} else {
 1063|    102|	    for (p = tmp; *p; p++) {
  ------------------
  |  Branch (1063:20): [True: 90, False: 12]
  ------------------
 1064|     90|		if (*p == '.' || (allow_ && *p == '_')) /* leave alone */;
  ------------------
  |  Branch (1064:7): [True: 4, False: 86]
  |  Branch (1064:21): [True: 86, False: 0]
  |  Branch (1064:31): [True: 2, False: 84]
  ------------------
 1065|     84|		else if (!isalnum(0xff & (int)*p)) *p = '.';
  ------------------
  |  Branch (1065:12): [True: 0, False: 84]
  ------------------
 1066|       |		/* else leave alone */
 1067|     90|	    }
 1068|     12|	}
 1069|     12|	SET_STRING_ELT(ans, i, mkChar(tmp));
  ------------------
  |  |  998|     12|#define mkChar			Rf_mkChar
  ------------------
 1070|       |	/* do we have a reserved word?  If so the name is invalid */
 1071|     12|	if (!isValidName(tmp)) {
  ------------------
  |  | 1930|     12|# define isValidName		Rf_isValidName
  ------------------
  |  Branch (1071:6): [True: 0, False: 12]
  ------------------
 1072|      0|	    cbuf = R_alloc(strlen(tmp) + 2, sizeof(char));
 1073|      0|	    strcpy(cbuf, tmp);
 1074|      0|	    strcat(cbuf, ".");
 1075|      0|	    SET_STRING_ELT(ans, i, mkChar(cbuf));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 1076|      0|	}
 1077|     12|	vmaxset(vmax);
 1078|     12|    }
 1079|      2|    UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1080|      2|    return ans;
 1081|      2|}
Rf_stringSuffix:
 1776|    124|attribute_hidden SEXP stringSuffix(SEXP string, int fromIndex) {
 1777|       |
 1778|    124|    int origLen = LENGTH(string);
 1779|    124|    int newLen = origLen - fromIndex;
 1780|       |
 1781|    124|    SEXP res = PROTECT(allocVector(STRSXP, newLen));
  ------------------
  |  |  357|    124|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1782|    124|    int i;
 1783|    232|    for(i = 0; i < newLen; i++) {
  ------------------
  |  Branch (1783:16): [True: 108, False: 124]
  ------------------
 1784|    108|	SET_STRING_ELT(res, i, STRING_ELT(string, fromIndex++));
 1785|    108|    }
 1786|       |
 1787|    124|    UNPROTECT(1); /* res */
  ------------------
  |  |  358|    124|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1788|    124|    return res;
 1789|    124|}

Rf_CoercionWarning:
   76|  6.62k|{
   77|       |/* FIXME: Use
   78|       |   =====
   79|       |   WarningMessage(R_NilValue, WARNING_....);
   80|       |*/
   81|  6.62k|    if (warn & WARN_NA)
  ------------------
  |  |   48|  6.62k|#define WARN_NA	   1
  ------------------
  |  Branch (81:9): [True: 1.14k, False: 5.47k]
  ------------------
   82|  1.14k|	warning(_("NAs introduced by coercion"));
  ------------------
  |  |   89|  1.14k|#define warning Rf_warning
  ------------------
              	warning(_("NAs introduced by coercion"));
  ------------------
  |  | 2531|  1.14k|#   define _(String) gettext (String)
  ------------------
   83|  6.62k|    if (warn & WARN_INT_NA)
  ------------------
  |  |   49|  6.62k|#define WARN_INT_NA 2
  ------------------
  |  Branch (83:9): [True: 0, False: 6.62k]
  ------------------
   84|      0|	warning(_("NAs introduced by coercion to integer range"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("NAs introduced by coercion to integer range"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   85|  6.62k|    if (warn & WARN_IMAG)
  ------------------
  |  |   50|  6.62k|#define WARN_IMAG  4
  ------------------
  |  Branch (85:9): [True: 0, False: 6.62k]
  ------------------
   86|      0|	warning(_("imaginary parts discarded in coercion"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("imaginary parts discarded in coercion"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   87|  6.62k|    if (warn & WARN_RAW)
  ------------------
  |  |   51|  6.62k|#define WARN_RAW  8
  ------------------
  |  Branch (87:9): [True: 0, False: 6.62k]
  ------------------
   88|      0|	warning(_("out-of-range values treated as 0 in coercion to raw"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("out-of-range values treated as 0 in coercion to raw"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   89|  6.62k|}
Rf_LogicalFromInteger:
   92|     76|{
   93|     76|    return (x == NA_INTEGER) ?
  ------------------
  |  |   56|     76|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (93:12): [True: 0, False: 76]
  ------------------
   94|     76|	NA_LOGICAL : (x != 0);
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
   95|     76|}
Rf_IntegerFromLogical:
  119|  2.37k|{
  120|  2.37k|    return (x == NA_LOGICAL) ?
  ------------------
  |  |   55|  2.37k|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (120:12): [True: 67, False: 2.30k]
  ------------------
  121|  2.30k|	NA_INTEGER : x;
  ------------------
  |  |   56|     67|#define NA_INTEGER	R_NaInt
  ------------------
  122|  2.37k|}
Rf_IntegerFromReal:
  125|  7.86k|{
  126|  7.86k|    if (ISNAN(x))
  ------------------
  |  |   76|  7.86k|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 7.86k]
  |  |  ------------------
  ------------------
  127|      0|	return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  128|  7.86k|    else if (x >= INT_MAX+1. || x <= INT_MIN ) {
  ------------------
  |  Branch (128:14): [True: 0, False: 7.86k]
  |  Branch (128:33): [True: 0, False: 7.86k]
  ------------------
  129|      0|	*warn |= WARN_INT_NA;
  ------------------
  |  |   49|      0|#define WARN_INT_NA 2
  ------------------
  130|      0|	return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  131|      0|    }
  132|  7.86k|    return (int) x;
  133|  7.86k|}
Rf_IntegerFromString:
  150|    120|{
  151|    120|    if (x != R_NaString && !isBlankString(CHAR(x))) { /* ASCII */
  ------------------
  |  |   53|    120|#define isBlankString Rf_isBlankString
  ------------------
                  if (x != R_NaString && !isBlankString(CHAR(x))) { /* ASCII */
  ------------------
  |  |  203|    120|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (151:9): [True: 120, False: 0]
  |  Branch (151:28): [True: 120, False: 0]
  ------------------
  152|    120|	char *endp;
  153|    120|	double xdouble = R_strtod(CHAR(x), &endp); /* ASCII */
  ------------------
  |  |  203|    120|#define CHAR(x) R_CHAR(x)
  ------------------
  154|    120|	if (isBlankString(endp)) {
  ------------------
  |  |   53|    120|#define isBlankString Rf_isBlankString
  ------------------
  |  Branch (154:6): [True: 120, False: 0]
  ------------------
  155|       |#ifdef _R_pre_Version_3_3_0
  156|       |	    if (xdouble > INT_MAX) {
  157|       |		*warn |= WARN_INT_NA;
  158|       |		return INT_MAX;
  159|       |	    }
  160|       |	    else if(xdouble < INT_MIN+1) {
  161|       |		*warn |= WARN_INT_NA;
  162|       |		return INT_MIN;// <- "wrong" as INT_MIN == NA_INTEGER currently; should have used INT_MIN+1
  163|       |	    }
  164|       |#else
  165|       |	    // behave the same as IntegerFromReal() etc:
  166|    120|	    if (xdouble >= INT_MAX+1. || xdouble <= INT_MIN ) {
  ------------------
  |  Branch (166:10): [True: 0, False: 120]
  |  Branch (166:35): [True: 0, False: 120]
  ------------------
  167|      0|		*warn |= WARN_INT_NA;
  ------------------
  |  |   49|      0|#define WARN_INT_NA 2
  ------------------
  168|      0|		return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  169|      0|	    }
  170|    120|#endif
  171|    120|	    else
  172|    120|		return (int) xdouble;
  173|    120|	}
  174|      0|	else *warn |= WARN_NA;
  ------------------
  |  |   48|      0|#define WARN_NA	   1
  ------------------
  175|    120|    }
  176|      0|    return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  177|    120|}
Rf_RealFromString:
  200|   617k|{
  201|   617k|    double xdouble;
  202|   617k|    char *endp;
  203|   617k|    if (x != R_NaString && !isBlankString(CHAR(x))) { /* ASCII */
  ------------------
  |  |   53|   617k|#define isBlankString Rf_isBlankString
  ------------------
                  if (x != R_NaString && !isBlankString(CHAR(x))) { /* ASCII */
  ------------------
  |  |  203|   617k|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (203:9): [True: 617k, False: 0]
  |  Branch (203:28): [True: 508k, False: 108k]
  ------------------
  204|   508k|	xdouble = R_strtod(CHAR(x), &endp); /* ASCII */
  ------------------
  |  |  203|   508k|#define CHAR(x) R_CHAR(x)
  ------------------
  205|   508k|	if (isBlankString(endp))
  ------------------
  |  |   53|   508k|#define isBlankString Rf_isBlankString
  ------------------
  |  Branch (205:6): [True: 484k, False: 24.2k]
  ------------------
  206|   484k|	    return xdouble;
  207|  24.2k|	else
  208|  24.2k|	    *warn |= WARN_NA;
  ------------------
  |  |   48|  24.2k|#define WARN_NA	   1
  ------------------
  209|   508k|    }
  210|   132k|    return NA_REAL;
  ------------------
  |  |   58|   132k|#define NA_REAL		R_NaReal
  ------------------
  211|   617k|}
Rf_StringFromInteger:
  317|      4|{
  318|      4|    if (x == NA_INTEGER) return NA_STRING;
  ------------------
  |  |   56|      4|#define NA_INTEGER	R_NaInt
  ------------------
                  if (x == NA_INTEGER) return NA_STRING;
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (318:9): [True: 0, False: 4]
  ------------------
  319|      4|    else if (x >= 0 && x < SFI_CACHE_SIZE) {
  ------------------
  |  |  313|      4|#define SFI_CACHE_SIZE 512
  ------------------
  |  Branch (319:14): [True: 4, False: 0]
  |  Branch (319:24): [True: 4, False: 0]
  ------------------
  320|      4|	if (sficache == NULL) {
  ------------------
  |  Branch (320:6): [True: 2, False: 2]
  ------------------
  321|      2|	    sficache = allocVector(STRSXP, SFI_CACHE_SIZE);
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
              	    sficache = allocVector(STRSXP, SFI_CACHE_SIZE);
  ------------------
  |  |  126|      2|#define STRSXP	    16	  /* string vectors */
  ------------------
              	    sficache = allocVector(STRSXP, SFI_CACHE_SIZE);
  ------------------
  |  |  313|      2|#define SFI_CACHE_SIZE 512
  ------------------
  322|      2|	    R_PreserveObject(sficache);
  323|      2|	}
  324|      4|	SEXP cval = STRING_ELT(sficache, x);
  325|      4|	if (cval == R_BlankString) { // ""
  ------------------
  |  Branch (325:6): [True: 4, False: 0]
  ------------------
  326|      4|	    int w;
  327|      4|	    formatInteger(&x, 1, &w);
  ------------------
  |  |   40|      4|#define formatInteger      Rf_formatInteger
  ------------------
  328|      4|	    cval = mkChar(EncodeInteger(x, w));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
              	    cval = mkChar(EncodeInteger(x, w));
  ------------------
  |  |   44|      4|#define EncodeInteger      Rf_EncodeInteger
  ------------------
  329|      4|	    SET_STRING_ELT(sficache, x, cval);
  330|      4|	}
  331|      4|	return cval;
  332|      4|    }
  333|      0|    else {
  334|      0|	int w;
  335|      0|	formatInteger(&x, 1, &w);
  ------------------
  |  |   40|      0|#define formatInteger      Rf_formatInteger
  ------------------
  336|      0|	return mkChar(EncodeInteger(x, w));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
              	return mkChar(EncodeInteger(x, w));
  ------------------
  |  |   44|      0|#define EncodeInteger      Rf_EncodeInteger
  ------------------
  337|      0|    }
  338|      4|}
Rf_PairToVectorList:
  362|     87|{
  363|     87|    SEXP xptr, xnew, xnames;
  364|     87|    int i, len = 0, named = 0;
  365|    261|    for (xptr = x ; xptr != R_NilValue ; xptr = CDR(xptr)) {
  ------------------
  |  Branch (365:21): [True: 174, False: 87]
  ------------------
  366|    174|	named = named | (TAG(xptr) != R_NilValue);
  367|    174|	len++;
  368|    174|    }
  369|     87|    PROTECT(x);
  ------------------
  |  |  357|     87|#define PROTECT(s)	Rf_protect(s)
  ------------------
  370|     87|    PROTECT(xnew = allocVector(VECSXP, len));
  ------------------
  |  |  357|     87|#define PROTECT(s)	Rf_protect(s)
  ------------------
  371|    261|    for (i = 0, xptr = x; i < len; i++, xptr = CDR(xptr)) {
  ------------------
  |  Branch (371:27): [True: 174, False: 87]
  ------------------
  372|    174|	RAISE_NAMED(CAR(xptr), NAMED(x));
  373|    174|	SET_VECTOR_ELT(xnew, i, CAR(xptr));
  374|    174|    }
  375|     87|    if (named) {
  ------------------
  |  Branch (375:9): [True: 17, False: 70]
  ------------------
  376|     17|	PROTECT(xnames = allocVector(STRSXP, len));
  ------------------
  |  |  357|     17|#define PROTECT(s)	Rf_protect(s)
  ------------------
  377|     17|	xptr = x;
  378|     64|	for (i = 0, xptr = x; i < len; i++, xptr = CDR(xptr)) {
  ------------------
  |  Branch (378:24): [True: 47, False: 17]
  ------------------
  379|     47|	    if(TAG(xptr) == R_NilValue)
  ------------------
  |  Branch (379:9): [True: 25, False: 22]
  ------------------
  380|     25|		SET_STRING_ELT(xnames, i, R_BlankString);
  381|     22|	    else
  382|     22|		SET_STRING_ELT(xnames, i, PRINTNAME(TAG(xptr)));
  383|     47|	}
  384|     17|	setAttrib(xnew, R_NamesSymbol, xnames);
  ------------------
  |  | 1027|     17|#define setAttrib		Rf_setAttrib
  ------------------
  385|     17|	UNPROTECT(1);
  ------------------
  |  |  358|     17|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  386|     17|    }
  387|     87|    copyMostAttrib(x, xnew);
  ------------------
  |  |  901|     87|#define copyMostAttrib		Rf_copyMostAttrib
  ------------------
  388|     87|    UNPROTECT(2);
  ------------------
  |  |  358|     87|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  389|     87|    return xnew;
  390|     87|}
Rf_VectorToPairList:
  393|     14|{
  394|     14|    SEXP xptr, xnew, xnames;
  395|     14|    int i, len, named;
  396|       |
  397|     14|    len = length(x);
  ------------------
  |  |  987|     14|#define length(x)		Rf_length(x)
  ------------------
  398|     14|    PROTECT(x);
  ------------------
  |  |  357|     14|#define PROTECT(s)	Rf_protect(s)
  ------------------
  399|     14|    PROTECT(xnew = allocList(len)); /* limited to int */
  ------------------
  |  |  357|     14|#define PROTECT(s)	Rf_protect(s)
  ------------------
  400|     14|    PROTECT(xnames = getAttrib(x, R_NamesSymbol));
  ------------------
  |  |  357|     14|#define PROTECT(s)	Rf_protect(s)
  ------------------
  401|     14|    named = (xnames != R_NilValue);
  402|     14|    xptr = xnew;
  403|     14|    for (i = 0; i < len; i++) {
  ------------------
  |  Branch (403:17): [True: 0, False: 14]
  ------------------
  404|      0|	RAISE_NAMED(VECTOR_ELT(x, i), NAMED(x));
  405|      0|	SETCAR(xptr, VECTOR_ELT(x, i));
  406|      0|	if (named && CHAR(STRING_ELT(xnames, i))[0] != '\0') /* ASCII */
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (406:6): [True: 0, False: 0]
  |  Branch (406:15): [True: 0, False: 0]
  ------------------
  407|      0|	    SET_TAG(xptr, installTrChar(STRING_ELT(xnames, i)));
  ------------------
  |  |  937|      0|#define installTrChar		Rf_installTrChar
  ------------------
  408|      0|	xptr = CDR(xptr);
  409|      0|    }
  410|     14|    if (len > 0)       /* can't set attributes on NULL */
  ------------------
  |  Branch (410:9): [True: 0, False: 14]
  ------------------
  411|      0|	copyMostAttrib(x, xnew);
  ------------------
  |  |  901|      0|#define copyMostAttrib		Rf_copyMostAttrib
  ------------------
  412|     14|    UNPROTECT(3);
  ------------------
  |  |  358|     14|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  413|     14|    return xnew;
  414|     14|}
Rf_coerceVector:
 1174|  7.74M|{
 1175|  7.74M|    if (TYPEOF(v) == type)
  ------------------
  |  Branch (1175:9): [True: 7.73M, False: 5.54k]
  ------------------
 1176|  7.73M|	return v;
 1177|       |
 1178|  5.54k|    SEXP ans = R_NilValue;	/* -Wall */
 1179|  5.54k|    if (ALTREP(v)) {
  ------------------
  |  Branch (1179:9): [True: 0, False: 5.54k]
  ------------------
 1180|      0|	PROTECT(v); /* the methods should protect, but ... */
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1181|       |	            /* also "v" is protected by caller */
 1182|      0|	ans = ALTREP_COERCE(v, type);
 1183|      0|	if (ans) {
  ------------------
  |  Branch (1183:6): [True: 0, False: 0]
  ------------------
 1184|       |	    /* attribute copying could be handled by a Coerce_Ex
 1185|       |	       method as for Duplicate; for now, do it here */
 1186|      0|	    PROTECT(ans);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1187|      0|	    SHALLOW_DUPLICATE_ATTRIB(ans, v);
  ------------------
  |  |   58|      0|#define SHALLOW_DUPLICATE_ATTRIB(to, from) do {\
  |  |   59|      0|  SEXP __from__ = (from); \
  |  |   60|      0|  if (ATTRIB(__from__) != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (60:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   61|      0|    SEXP __to__ = (to); \
  |  |   62|      0|    (SHALLOW_DUPLICATE_ATTRIB)(__to__, __from__);	\
  |  |   63|      0|  } \
  |  |   64|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (64:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1188|      0|	    UNPROTECT(2); /* v, ans */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1189|      0|	    return ans;
 1190|      0|	}
 1191|      0|	UNPROTECT(1); /* v */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1192|      0|    }
 1193|       |
 1194|       |    /* code to allow classes to extend ENVSXP, SYMSXP, etc */
 1195|  5.54k|    if(IS_S4_OBJECT(v) && TYPEOF(v) == OBJSXP) {
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (1195:8): [True: 0, False: 5.54k]
  |  Branch (1195:27): [True: 0, False: 0]
  ------------------
 1196|      0|	SEXP vv = R_getS4DataSlot(v, ANYSXP);
  ------------------
  |  |  128|      0|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
 1197|      0|	if(vv == R_NilValue)
  ------------------
  |  Branch (1197:5): [True: 0, False: 0]
  ------------------
 1198|      0|	  error(_("no method for coercing this S4 class to a vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	  error(_("no method for coercing this S4 class to a vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1199|      0|	else if(TYPEOF(vv) == type)
  ------------------
  |  Branch (1199:10): [True: 0, False: 0]
  ------------------
 1200|      0|	  return vv;
 1201|      0|	v = vv;
 1202|      0|    }
 1203|  5.54k|    PROTECT(v);
  ------------------
  |  |  357|  5.54k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1204|       |
 1205|  5.54k|    switch (TYPEOF(v)) {
 1206|       |#ifdef NOTYET
 1207|       |    case NILSXP:
 1208|       |	ans = coerceNull(v, type);
 1209|       |	break;
 1210|       |#endif
 1211|      0|    case SYMSXP:
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1211:5): [True: 0, False: 5.54k]
  ------------------
 1212|      0|	ans = coerceSymbol(v, type);
 1213|      0|	break;
 1214|     14|    case NILSXP:
  ------------------
  |  |  111|     14|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1214:5): [True: 14, False: 5.53k]
  ------------------
 1215|     15|    case LISTSXP:
  ------------------
  |  |  113|     15|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1215:5): [True: 1, False: 5.54k]
  ------------------
 1216|     15|	if(type == LISTSXP) {
  ------------------
  |  |  113|     15|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1216:5): [True: 0, False: 15]
  ------------------
 1217|      0|	    UNPROTECT(1); /* v */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1218|      0|	    return v; // as coercePairList() is also used for LANGSXP
 1219|      0|	}
 1220|     15|	ans = coercePairList(v, type);
 1221|     15|	break;
 1222|     84|    case LANGSXP: {
  ------------------
  |  |  117|     84|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (1222:5): [True: 84, False: 5.46k]
  ------------------
 1223|     84|	if (type != STRSXP) {
  ------------------
  |  |  126|     84|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1223:6): [True: 84, False: 0]
  ------------------
 1224|     84|	    ans = coercePairList(v, type);
 1225|     84|	    break;
 1226|     84|	}
 1227|       |
 1228|       |	/* This is mostly copied from coercePairList, but we need to
 1229|       |	 * special-case the first element so as not to get operators
 1230|       |	 * put in backticks. */
 1231|      0|	int n = length(v);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 1232|      0|	PROTECT(ans = allocVector(type, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1233|      0|	if (n == 0) {
  ------------------
  |  Branch (1233:6): [True: 0, False: 0]
  ------------------
 1234|       |	    /* Can this actually happen? */
 1235|      0|	    UNPROTECT(1); /* ans */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1236|      0|	    break;
 1237|      0|	}
 1238|      0|	int i = 0;
 1239|      0|	SEXP op = CAR(v);
 1240|       |	/* The case of practical relevance is "lhs ~ rhs", which
 1241|       |	 * people tend to split using as.character(), modify, and
 1242|       |	 * paste() back together. However, we might as well
 1243|       |	 * special-case all symbolic operators here. */
 1244|      0|	if (TYPEOF(op) == SYMSXP) {
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1244:6): [True: 0, False: 0]
  ------------------
 1245|      0|	    SET_STRING_ELT(ans, i, PRINTNAME(op));
 1246|      0|	    i++;
 1247|      0|	    v = CDR(v);
 1248|      0|	}
 1249|       |
 1250|       |	/* The distinction between strings and other elements was
 1251|       |	 * here "always", but is really dubious since it makes x <- a
 1252|       |	 * and x <- "a" come out identical. Won't fix just now. */
 1253|      0|	for (SEXP vp = v;  vp != R_NilValue; vp = CDR(vp), i++) {
  ------------------
  |  Branch (1253:21): [True: 0, False: 0]
  ------------------
 1254|      0|	    if (isString(CAR(vp)) && length(CAR(vp)) == 1)
  ------------------
  |  |  966|      0|#define isString		Rf_isString
  ------------------
              	    if (isString(CAR(vp)) && length(CAR(vp)) == 1)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1254:10): [True: 0, False: 0]
  |  Branch (1254:31): [True: 0, False: 0]
  ------------------
 1255|      0|		SET_STRING_ELT(ans, i, STRING_ELT(CAR(vp), 0));
 1256|      0|	    else
 1257|      0|		SET_STRING_ELT(ans, i, STRING_ELT(deparse1line(CAR(vp), false), 0));
  ------------------
  |  | 1884|      0|# define deparse1line		Rf_deparse1line
  ------------------
 1258|      0|	}
 1259|      0|	UNPROTECT(1); /* ans */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1260|      0|	break;
 1261|      0|    }
 1262|     27|    case VECSXP:
  ------------------
  |  |  131|     27|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1262:5): [True: 27, False: 5.51k]
  ------------------
 1263|     27|    case EXPRSXP:
  ------------------
  |  |  132|     27|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1263:5): [True: 0, False: 5.54k]
  ------------------
 1264|     27|	ans = coerceVectorList(v, type);
 1265|     27|	break;
 1266|      0|    case ENVSXP:
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (1266:5): [True: 0, False: 5.54k]
  ------------------
 1267|      0|	error(_("environments cannot be coerced to other types"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("environments cannot be coerced to other types"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1268|      0|	break;
 1269|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1269:5): [True: 0, False: 5.54k]
  ------------------
 1270|     14|    case INTSXP:
  ------------------
  |  |  123|     14|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1270:5): [True: 14, False: 5.53k]
  ------------------
 1271|  2.41k|    case REALSXP:
  ------------------
  |  |  124|  2.41k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1271:5): [True: 2.39k, False: 3.14k]
  ------------------
 1272|  2.41k|    case CPLXSXP:
  ------------------
  |  |  125|  2.41k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1272:5): [True: 0, False: 5.54k]
  ------------------
 1273|  5.37k|    case STRSXP:
  ------------------
  |  |  126|  5.37k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1273:5): [True: 2.96k, False: 2.58k]
  ------------------
 1274|  5.41k|    case RAWSXP:
  ------------------
  |  |  136|  5.41k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1274:5): [True: 43, False: 5.50k]
  ------------------
 1275|       |
 1276|  5.41k|#define COERCE_ERROR_STRING "cannot coerce type '%s' to vector of type '%s'"
 1277|       |
 1278|  5.41k|#define COERCE_ERROR							\
 1279|  5.41k|	error(_(COERCE_ERROR_STRING), R_typeToChar(v), type2char(type))
 1280|       |
 1281|  5.41k|	switch (type) {
 1282|  1.13k|	case SYMSXP:
  ------------------
  |  |  112|  1.13k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1282:2): [True: 1.13k, False: 4.28k]
  ------------------
 1283|  1.13k|	    ans = coerceToSymbol(v);	    break;
 1284|     12|	case LGLSXP:
  ------------------
  |  |  121|     12|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1284:2): [True: 12, False: 5.40k]
  ------------------
 1285|     12|	    ans = coerceToLogical(v);	    break;
 1286|  2.43k|	case INTSXP:
  ------------------
  |  |  123|  2.43k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1286:2): [True: 2.43k, False: 2.98k]
  ------------------
 1287|  2.43k|	    ans = coerceToInteger(v);	    break;
 1288|  1.77k|	case REALSXP:
  ------------------
  |  |  124|  1.77k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1288:2): [True: 1.77k, False: 3.64k]
  ------------------
 1289|  1.77k|	    ans = coerceToReal(v);	    break;
 1290|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1290:2): [True: 0, False: 5.41k]
  ------------------
 1291|      0|	    ans = coerceToComplex(v);	    break;
 1292|     34|	case RAWSXP:
  ------------------
  |  |  136|     34|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1292:2): [True: 34, False: 5.38k]
  ------------------
 1293|     34|	    ans = coerceToRaw(v);	    break;
 1294|     13|	case STRSXP:
  ------------------
  |  |  126|     13|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1294:2): [True: 13, False: 5.40k]
  ------------------
 1295|     13|	    if (ATTRIB(v) == R_NilValue)
  ------------------
  |  Branch (1295:10): [True: 13, False: 0]
  ------------------
 1296|     13|		switch(TYPEOF(v)) {
  ------------------
  |  Branch (1296:10): [True: 13, False: 0]
  ------------------
 1297|      2|		case INTSXP:
  ------------------
  |  |  123|      2|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1297:3): [True: 2, False: 11]
  ------------------
 1298|     13|		case REALSXP:
  ------------------
  |  |  124|     13|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1298:3): [True: 11, False: 2]
  ------------------
 1299|     13|		    ans = R_deferred_coerceToString(v, NULL);
 1300|     13|		    UNPROTECT(1); /* v */
  ------------------
  |  |  358|     13|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1301|     13|		    return ans;
 1302|     13|		}
 1303|      0|	    ans = coerceToString(v);	    break;
 1304|      0|	case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1304:2): [True: 0, False: 5.41k]
  ------------------
 1305|      0|	    ans = coerceToExpression(v);    break;
 1306|     12|	case VECSXP:
  ------------------
  |  |  131|     12|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1306:2): [True: 12, False: 5.40k]
  ------------------
 1307|     12|	    ans = coerceToVectorList(v);    break;
 1308|      0|	case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1308:2): [True: 0, False: 5.41k]
  ------------------
 1309|      0|	    ans = coerceToPairList(v);	    break;
 1310|      0|	default:
  ------------------
  |  Branch (1310:2): [True: 0, False: 5.41k]
  ------------------
 1311|      0|	    COERCE_ERROR;
  ------------------
  |  | 1279|      0|	error(_(COERCE_ERROR_STRING), R_typeToChar(v), type2char(type))
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_(COERCE_ERROR_STRING), R_typeToChar(v), type2char(type))
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |               	error(_(COERCE_ERROR_STRING), R_typeToChar(v), type2char(type))
  |  |  ------------------
  |  |  |  | 1040|      0|#define type2char		Rf_type2char
  |  |  ------------------
  ------------------
 1312|  5.41k|	}
 1313|  5.40k|	break;
 1314|  5.40k|    default:
  ------------------
  |  Branch (1314:5): [True: 0, False: 5.54k]
  ------------------
 1315|      0|	COERCE_ERROR;
  ------------------
  |  | 1279|      0|	error(_(COERCE_ERROR_STRING), R_typeToChar(v), type2char(type))
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_(COERCE_ERROR_STRING), R_typeToChar(v), type2char(type))
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |               	error(_(COERCE_ERROR_STRING), R_typeToChar(v), type2char(type))
  |  |  ------------------
  |  |  |  | 1040|      0|#define type2char		Rf_type2char
  |  |  ------------------
  ------------------
 1316|  5.54k|    }
 1317|  5.53k|    UNPROTECT(1); /* v */
  ------------------
  |  |  358|  5.53k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1318|  5.53k|    return ans;
 1319|  5.54k|}
Rf_CreateTag:
 1324|  6.95M|{
 1325|  6.95M|    if (isNull(x) || isSymbol(x))
  ------------------
  |  |  956|  6.95M|#define isNull			Rf_isNull
  ------------------
                  if (isNull(x) || isSymbol(x))
  ------------------
  |  |  953|  6.95M|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1325:9): [True: 1.93k, False: 6.95M]
  |  Branch (1325:22): [True: 6.95M, False: 0]
  ------------------
 1326|  6.95M|	return x;
 1327|      0|    if (isString(x)
  ------------------
  |  |  966|      0|#define isString		Rf_isString
  ------------------
  |  Branch (1327:9): [True: 0, False: 0]
  ------------------
 1328|      0|	&& length(x) >= 1
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1328:5): [True: 0, False: 0]
  ------------------
 1329|      0|	&& length(STRING_ELT(x, 0)) >= 1) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1329:5): [True: 0, False: 0]
  ------------------
 1330|      0|	x = installTrChar(STRING_ELT(x, 0));
  ------------------
  |  |  937|      0|#define installTrChar		Rf_installTrChar
  ------------------
 1331|      0|    } else
 1332|      0|	x = installTrChar(STRING_ELT(deparse1(x, true, SIMPLEDEPARSE), 0));
  ------------------
  |  |  937|      0|#define installTrChar		Rf_installTrChar
  ------------------
              	x = installTrChar(STRING_ELT(deparse1(x, true, SIMPLEDEPARSE), 0));
  ------------------
  |  | 1881|      0|# define deparse1		Rf_deparse1
  ------------------
              	x = installTrChar(STRING_ELT(deparse1(x, true, SIMPLEDEPARSE), 0));
  ------------------
  |  | 2080|      0|#define SIMPLEDEPARSE		0
  ------------------
 1333|      0|    return x;
 1334|  6.95M|}
do_asatomic:
 1450|   390k|{
 1451|   390k|    check1arg(args, call, "x");
  ------------------
  |  | 1867|   390k|# define check1arg		Rf_check1arg
  ------------------
 1452|       |
 1453|   390k|    char *name = NULL /* -Wall */;
 1454|   390k|    int type = STRSXP;
  ------------------
  |  |  126|   390k|#define STRSXP	    16	  /* string vectors */
  ------------------
 1455|   390k|    switch(PRIMVAL(op)) {
  ------------------
  |  | 1347|   390k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (1347:20): [True: 390k, False: 0]
  |  |  ------------------
  ------------------
 1456|   388k|    case 0:
  ------------------
  |  Branch (1456:5): [True: 388k, False: 2.03k]
  ------------------
 1457|   388k|	name = "as.character"; break;
 1458|    104|    case 1:
  ------------------
  |  Branch (1458:5): [True: 104, False: 390k]
  ------------------
 1459|    104|	name = "as.integer"; type = INTSXP; break;
  ------------------
  |  |  123|    104|#define INTSXP	    13	  /* integer vectors */
  ------------------
 1460|  1.77k|    case 2:
  ------------------
  |  Branch (1460:5): [True: 1.77k, False: 388k]
  ------------------
 1461|  1.77k|	name = "as.double"; type = REALSXP; break;
  ------------------
  |  |  124|  1.77k|#define REALSXP	    14	  /* real variables */
  ------------------
 1462|      0|    case 3:
  ------------------
  |  Branch (1462:5): [True: 0, False: 390k]
  ------------------
 1463|      0|	name = "as.complex"; type = CPLXSXP; break;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
 1464|    125|    case 4:
  ------------------
  |  Branch (1464:5): [True: 125, False: 390k]
  ------------------
 1465|    125|	name = "as.logical"; type = LGLSXP; break;
  ------------------
  |  |  121|    125|#define LGLSXP	    10	  /* logical vectors */
  ------------------
 1466|     34|    case 5:
  ------------------
  |  Branch (1466:5): [True: 34, False: 390k]
  ------------------
 1467|     34|	name = "as.raw"; type = RAWSXP; break;
  ------------------
  |  |  136|     34|#define RAWSXP      24    /* raw bytes */
  ------------------
 1468|   390k|    }
 1469|       |    /* DispatchOrEval internal generic: as.character */
 1470|       |    /* DispatchOrEval internal generic: as.integer */
 1471|       |    /* DispatchOrEval internal generic: as.double */
 1472|       |    /* DispatchOrEval internal generic: as.complex */
 1473|       |    /* DispatchOrEval internal generic: as.logical */
 1474|       |    /* DispatchOrEval internal generic: as.raw */
 1475|   390k|    SEXP ans;
 1476|   390k|    if (DispatchOrEval(call, op, name, args, rho, &ans, 0, 1))
  ------------------
  |  | 1887|   390k|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (1476:9): [True: 18, False: 390k]
  ------------------
 1477|     18|	return(ans);
 1478|       |
 1479|       |    /* Method dispatch has failed, we now just */
 1480|       |    /* run the generic internal code */
 1481|       |
 1482|   390k|    checkArity(op, args);
  ------------------
  |  | 1788|   390k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1483|   390k|    SEXP x = CAR(args);
 1484|   390k|    if(TYPEOF(x) == type) {
  ------------------
  |  Branch (1484:8): [True: 388k, False: 2.16k]
  ------------------
 1485|   388k|	if(ATTRIB(x) == R_NilValue) return x;
  ------------------
  |  Branch (1485:5): [True: 388k, False: 60]
  ------------------
 1486|     60|	ans = MAYBE_REFERENCED(x) ? duplicate(x) : x;
  ------------------
  |  |  251|     60|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 16, False: 44]
  |  |  ------------------
  ------------------
              	ans = MAYBE_REFERENCED(x) ? duplicate(x) : x;
  ------------------
  |  |  909|     16|#define duplicate		Rf_duplicate
  ------------------
 1487|     60|	CLEAR_ATTRIB(ans);
  ------------------
  |  |   66|     60|#define CLEAR_ATTRIB(x) do {\
  |  |   67|     60|  SEXP __x__ = (x); \
  |  |   68|     60|  if (ATTRIB(__x__) != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (68:7): [True: 60, False: 0]
  |  |  ------------------
  |  |   69|     60|    SET_ATTRIB(__x__, R_NilValue); \
  |  |   70|     60|    if (OBJECT(__x__)) SET_OBJECT(__x__, 0); \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 60]
  |  |  ------------------
  |  |   71|     60|    if (IS_S4_OBJECT(__x__)) UNSET_S4_OBJECT(__x__); \
  |  |  ------------------
  |  |  |  Branch (71:9): [True: 0, False: 60]
  |  |  ------------------
  |  |   72|     60|  } \
  |  |   73|     60|} while (0)
  |  |  ------------------
  |  |  |  Branch (73:10): [Folded, False: 60]
  |  |  ------------------
  ------------------
 1488|     60|	return ans;
 1489|   388k|    }
 1490|  2.16k|    ans = ascommon(call, CAR(args), type);
 1491|  2.16k|    CLEAR_ATTRIB(ans);
  ------------------
  |  |   66|  2.16k|#define CLEAR_ATTRIB(x) do {\
  |  |   67|  2.16k|  SEXP __x__ = (x); \
  |  |   68|  2.16k|  if (ATTRIB(__x__) != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (68:7): [True: 0, False: 2.16k]
  |  |  ------------------
  |  |   69|      0|    SET_ATTRIB(__x__, R_NilValue); \
  |  |   70|      0|    if (OBJECT(__x__)) SET_OBJECT(__x__, 0); \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   71|      0|    if (IS_S4_OBJECT(__x__)) UNSET_S4_OBJECT(__x__); \
  |  |  ------------------
  |  |  |  Branch (71:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   72|      0|  } \
  |  |   73|  2.16k|} while (0)
  |  |  ------------------
  |  |  |  Branch (73:10): [Folded, False: 2.16k]
  |  |  ------------------
  ------------------
 1492|  2.16k|    return ans;
 1493|   390k|}
do_asvector:
 1511|    172|{
 1512|    172|    SEXP ans;
 1513|       |    /* DispatchOrEval internal generic: as.vector */
 1514|    172|    if (DispatchOrEval(call, op, "as.vector", args, rho, &ans, 0, 1))
  ------------------
  |  | 1887|    172|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (1514:9): [True: 0, False: 172]
  ------------------
 1515|      0|	return(ans);
 1516|       |
 1517|       |    /* Method dispatch has failed, we now just */
 1518|       |    /* run the generic internal code */
 1519|       |
 1520|    172|    checkArity(op, args);
  ------------------
  |  | 1788|    172|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1521|    172|    if (!isString(CADR(args)) || LENGTH(CADR(args)) != 1)
  ------------------
  |  |  966|    172|#define isString		Rf_isString
  ------------------
  |  Branch (1521:9): [True: 0, False: 172]
  |  Branch (1521:34): [True: 0, False: 172]
  ------------------
 1522|    172|	error_return(R_MSG_mode);
  ------------------
  |  | 1229|      0|#define error_return(msg)	{ Rf_error(msg);	   return R_NilValue; }
  ------------------
 1523|       |
 1524|    172|    SEXP x = CAR(args);
 1525|    172|    int type =
 1526|    172|	(!strcmp("function", CHAR(STRING_ELT(CADR(args), 0))))  /* ASCII */
  ------------------
  |  |  203|    172|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1526:2): [True: 0, False: 172]
  ------------------
 1527|    172|	? CLOSXP
  ------------------
  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  ------------------
 1528|    172|	: str2type(CHAR(STRING_ELT(CADR(args), 0))); /* ASCII */
  ------------------
  |  | 1031|    172|#define str2type		Rf_str2type
  ------------------
              	: str2type(CHAR(STRING_ELT(CADR(args), 0))); /* ASCII */
  ------------------
  |  |  203|    172|#define CHAR(x) R_CHAR(x)
  ------------------
 1529|       |
 1530|       |    /* "any" case added in 2.13.0 */
 1531|    172|    if(type == ANYSXP || TYPEOF(x) == type) {
  ------------------
  |  |  128|    344|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
  |  Branch (1531:8): [True: 0, False: 172]
  |  Branch (1531:26): [True: 1, False: 171]
  ------------------
 1532|      1|	switch(TYPEOF(x)) {
 1533|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1533:2): [True: 0, False: 1]
  ------------------
 1534|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1534:2): [True: 0, False: 1]
  ------------------
 1535|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1535:2): [True: 0, False: 1]
  ------------------
 1536|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1536:2): [True: 0, False: 1]
  ------------------
 1537|      0|	case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1537:2): [True: 0, False: 1]
  ------------------
 1538|      0|	case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1538:2): [True: 0, False: 1]
  ------------------
 1539|      0|	    if(ATTRIB(x) == R_NilValue) return x;
  ------------------
  |  Branch (1539:9): [True: 0, False: 0]
  ------------------
 1540|      0|	    ans  = MAYBE_REFERENCED(x) ? duplicate(x) : x;
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	    ans  = MAYBE_REFERENCED(x) ? duplicate(x) : x;
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 1541|      0|	    CLEAR_ATTRIB(ans);
  ------------------
  |  |   66|      0|#define CLEAR_ATTRIB(x) do {\
  |  |   67|      0|  SEXP __x__ = (x); \
  |  |   68|      0|  if (ATTRIB(__x__) != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   69|      0|    SET_ATTRIB(__x__, R_NilValue); \
  |  |   70|      0|    if (OBJECT(__x__)) SET_OBJECT(__x__, 0); \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   71|      0|    if (IS_S4_OBJECT(__x__)) UNSET_S4_OBJECT(__x__); \
  |  |  ------------------
  |  |  |  Branch (71:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   72|      0|  } \
  |  |   73|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (73:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1542|      0|	    return ans;
 1543|      0|	case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1543:2): [True: 0, False: 1]
  ------------------
 1544|      0|	case VECSXP: {
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1544:2): [True: 0, False: 1]
  ------------------
 1545|      0|	    MAYBE_CACHE_DO_IS_AS_VECTORS_EXPERI;
  ------------------
  |  | 1498|      0|#define MAYBE_CACHE_DO_IS_AS_VECTORS_EXPERI				\
  |  | 1499|      0|do {									\
  |  | 1500|      0|  if(do_is_as_vector_experiments == -1) {				\
  |  |  ------------------
  |  |  |  Branch (1500:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 1501|      0|    char *vector_experi = getenv("_R_IS_AS_VECTOR_EXPERIMENTS_");	\
  |  | 1502|      0|    do_is_as_vector_experiments =					\
  |  | 1503|      0| 	((vector_experi != NULL) && StringTrue(vector_experi)) ? 1 : 0;	\
  |  |  ------------------
  |  |  |  |   52|      0|#define StringTrue    Rf_StringTrue
  |  |  ------------------
  |  |  |  Branch (1503:4): [True: 0, False: 0]
  |  |  |  Branch (1503:31): [True: 0, False: 0]
  |  |  ------------------
  |  | 1504|      0|  }									\
  |  | 1505|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (1505:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1546|      0|	    if(do_is_as_vector_experiments) {
  ------------------
  |  Branch (1546:9): [True: 0, False: 0]
  ------------------
 1547|      0|		if(ATTRIB(x) == R_NilValue) return x;
  ------------------
  |  Branch (1547:6): [True: 0, False: 0]
  ------------------
 1548|      0|		if(OBJECT(x)) return x; // protect e.g.  setClass(., contains="list")
  ------------------
  |  Branch (1548:6): [True: 0, False: 0]
  ------------------
 1549|      0|		SEXP nms = getAttrib(x, R_NamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 1550|      0|		if(nms != R_NilValue && CDR(ATTRIB(x)) == R_NilValue) return x;
  ------------------
  |  Branch (1550:6): [True: 0, False: 0]
  |  Branch (1550:27): [True: 0, False: 0]
  ------------------
 1551|      0|		ans = MAYBE_REFERENCED(x) ? duplicate(x) : x;
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              		ans = MAYBE_REFERENCED(x) ? duplicate(x) : x;
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 1552|      0|		CLEAR_ATTRIB(ans);
  ------------------
  |  |   66|      0|#define CLEAR_ATTRIB(x) do {\
  |  |   67|      0|  SEXP __x__ = (x); \
  |  |   68|      0|  if (ATTRIB(__x__) != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   69|      0|    SET_ATTRIB(__x__, R_NilValue); \
  |  |   70|      0|    if (OBJECT(__x__)) SET_OBJECT(__x__, 0); \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   71|      0|    if (IS_S4_OBJECT(__x__)) UNSET_S4_OBJECT(__x__); \
  |  |  ------------------
  |  |  |  Branch (71:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   72|      0|  } \
  |  |   73|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (73:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1553|      0|		if (nms != R_NilValue)
  ------------------
  |  Branch (1553:7): [True: 0, False: 0]
  ------------------
 1554|      0|		    setAttrib(ans, R_NamesSymbol, nms);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 1555|      0|		return ans;
 1556|      0|	    } else
 1557|      0|		return x;
 1558|      0|	}
 1559|      1|	default:
  ------------------
  |  Branch (1559:2): [True: 1, False: 0]
  ------------------
 1560|      1|	    ;
 1561|      1|	}
 1562|      1|    }
 1563|       |
 1564|    172|    if(IS_S4_OBJECT(x) && TYPEOF(x) == OBJSXP) {
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (1564:8): [True: 0, False: 172]
  |  Branch (1564:27): [True: 0, False: 0]
  ------------------
 1565|      0|	SEXP v = R_getS4DataSlot(x, ANYSXP);
  ------------------
  |  |  128|      0|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
 1566|      0|	if(v == R_NilValue)
  ------------------
  |  Branch (1566:5): [True: 0, False: 0]
  ------------------
 1567|      0|	    error(_("no method for coercing this S4 class to a vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("no method for coercing this S4 class to a vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1568|      0|	x = v;
 1569|      0|    }
 1570|       |
 1571|    172|    switch(type) {/* only those are valid : */
 1572|     57|    case SYMSXP: /* for as.symbol */
  ------------------
  |  |  112|     57|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1572:5): [True: 57, False: 115]
  ------------------
 1573|     57|    case LGLSXP:
  ------------------
  |  |  121|     57|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1573:5): [True: 0, False: 172]
  ------------------
 1574|     57|    case INTSXP:
  ------------------
  |  |  123|     57|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1574:5): [True: 0, False: 172]
  ------------------
 1575|     57|    case REALSXP:
  ------------------
  |  |  124|     57|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1575:5): [True: 0, False: 172]
  ------------------
 1576|     57|    case CPLXSXP:
  ------------------
  |  |  125|     57|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1576:5): [True: 0, False: 172]
  ------------------
 1577|     73|    case STRSXP:
  ------------------
  |  |  126|     73|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1577:5): [True: 16, False: 156]
  ------------------
 1578|     73|    case EXPRSXP: /* for as.expression */
  ------------------
  |  |  132|     73|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1578:5): [True: 0, False: 172]
  ------------------
 1579|    172|    case VECSXP: /* list */
  ------------------
  |  |  131|    172|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1579:5): [True: 99, False: 73]
  ------------------
 1580|    172|    case LISTSXP:/* for as.pairlist */
  ------------------
  |  |  113|    172|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1580:5): [True: 0, False: 172]
  ------------------
 1581|    172|    case CLOSXP: /* non-primitive function */
  ------------------
  |  |  114|    172|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1581:5): [True: 0, False: 172]
  ------------------
 1582|    172|    case RAWSXP:
  ------------------
  |  |  136|    172|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1582:5): [True: 0, False: 172]
  ------------------
 1583|    172|    case ANYSXP: /* any */
  ------------------
  |  |  128|    172|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
  |  Branch (1583:5): [True: 0, False: 172]
  ------------------
 1584|    172|	break;
 1585|      0|    default:
  ------------------
  |  Branch (1585:5): [True: 0, False: 172]
  ------------------
 1586|      0|	error_return(R_MSG_mode);
  ------------------
  |  | 1229|      0|#define error_return(msg)	{ Rf_error(msg);	   return R_NilValue; }
  ------------------
 1587|    172|    }
 1588|    172|    ans = ascommon(call, x, type);
 1589|    172|    switch(TYPEOF(ans)) { /* keep attributes for these: */
 1590|      0|    case NILSXP: /* doesn't have any */
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1590:5): [True: 0, False: 172]
  ------------------
 1591|      0|    case LISTSXP: /* but ascommon fiddled */
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1591:5): [True: 0, False: 172]
  ------------------
 1592|      0|    case LANGSXP:
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (1592:5): [True: 0, False: 172]
  ------------------
 1593|     99|    case VECSXP:
  ------------------
  |  |  131|     99|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1593:5): [True: 99, False: 73]
  ------------------
 1594|     99|    case EXPRSXP:
  ------------------
  |  |  132|     99|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1594:5): [True: 0, False: 172]
  ------------------
 1595|     99|	break;
 1596|     73|    default:
  ------------------
  |  Branch (1596:5): [True: 73, False: 99]
  ------------------
 1597|     73|	CLEAR_ATTRIB(ans);
  ------------------
  |  |   66|     73|#define CLEAR_ATTRIB(x) do {\
  |  |   67|     73|  SEXP __x__ = (x); \
  |  |   68|     73|  if (ATTRIB(__x__) != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (68:7): [True: 16, False: 57]
  |  |  ------------------
  |  |   69|     16|    SET_ATTRIB(__x__, R_NilValue); \
  |  |   70|     16|    if (OBJECT(__x__)) SET_OBJECT(__x__, 0); \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 16]
  |  |  ------------------
  |  |   71|     16|    if (IS_S4_OBJECT(__x__)) UNSET_S4_OBJECT(__x__); \
  |  |  ------------------
  |  |  |  Branch (71:9): [True: 0, False: 16]
  |  |  ------------------
  |  |   72|     16|  } \
  |  |   73|     73|} while (0)
  |  |  ------------------
  |  |  |  Branch (73:10): [Folded, False: 73]
  |  |  ------------------
  ------------------
 1598|     73|	break;
 1599|    172|    }
 1600|    172|    return ans;
 1601|    172|}
do_ascall:
 1732|      2|{
 1733|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1734|      2|    check1arg(args, call, "x");
  ------------------
  |  | 1867|      2|# define check1arg		Rf_check1arg
  ------------------
 1735|       |
 1736|      2|    SEXP ans;
 1737|       |    /* DispatchOrEval internal generic: as.call */
 1738|      2|    if (DispatchOrEval(call, op, "as.call", args, rho, &ans, 0, 1))
  ------------------
  |  | 1887|      2|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (1738:9): [True: 0, False: 2]
  ------------------
 1739|      0|	return(ans);
 1740|       |
 1741|      2|    args = CAR(args);
 1742|      2|    switch (TYPEOF(args)) {
 1743|      0|    case LANGSXP:
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (1743:5): [True: 0, False: 2]
  ------------------
 1744|      0|	ans = args;
 1745|      0|	break;
 1746|      2|    case VECSXP:
  ------------------
  |  |  131|      2|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1746:5): [True: 2, False: 0]
  ------------------
 1747|      2|    case EXPRSXP: {
  ------------------
  |  |  132|      2|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1747:5): [True: 0, False: 2]
  ------------------
 1748|      2|	int n = length(args);
  ------------------
  |  |  987|      2|#define length(x)		Rf_length(x)
  ------------------
 1749|      2|	if(n == 0)
  ------------------
  |  Branch (1749:5): [True: 0, False: 2]
  ------------------
 1750|      0|	    errorcall(call, _("invalid length 0 argument"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("invalid length 0 argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1751|      2|	SEXP names = PROTECT(getAttrib(args, R_NamesSymbol)), ap;
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1752|      2|	PROTECT(ap = ans = allocList(n));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1753|      7|	for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (1753:18): [True: 5, False: 2]
  ------------------
 1754|      5|	    SETCAR(ap, VECTOR_ELT(args, i));
 1755|      5|	    if (names != R_NilValue && !StringBlank(STRING_ELT(names, i)))
  ------------------
  |  | 1034|      0|#define StringBlank		Rf_StringBlank
  ------------------
  |  Branch (1755:10): [True: 0, False: 5]
  |  Branch (1755:33): [True: 0, False: 0]
  ------------------
 1756|      0|		SET_TAG(ap, installTrChar(STRING_ELT(names, i)));
  ------------------
  |  |  937|      0|#define installTrChar		Rf_installTrChar
  ------------------
 1757|      5|	    ap = CDR(ap);
 1758|      5|	}
 1759|      2|	UNPROTECT(2); /* ap, names */
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1760|      2|	break;
 1761|      2|    }
 1762|      0|    case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1762:5): [True: 0, False: 2]
  ------------------
 1763|      0|	ans = duplicate(args);
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 1764|      0|	break;
 1765|      0|    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1765:5): [True: 0, False: 2]
  ------------------
 1766|      0|	errorcall(call, _("as.call(<character>) not feasible; consider str2lang(<char.>)"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("as.call(<character>) not feasible; consider str2lang(<char.>)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1767|      0|	break;
 1768|      0|    default:
  ------------------
  |  Branch (1768:5): [True: 0, False: 2]
  ------------------
 1769|      0|	errorcall(call, _("invalid argument list"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid argument list"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1770|      0|	ans = R_NilValue;
 1771|      2|    }
 1772|      2|    SET_TYPEOF(ans, LANGSXP);
  ------------------
  |  |  117|      2|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
 1773|      2|    SET_TAG(ans, R_NilValue);
 1774|      2|    return ans;
 1775|      2|}
Rf_asLogical2:
 1780|  3.51M|{
 1781|  3.51M|    int warn = 0;
 1782|       |
 1783|  3.51M|    if (isVectorAtomic(x)) {
  ------------------
  |  |  975|  3.51M|#define isVectorAtomic		Rf_isVectorAtomic
  ------------------
  |  Branch (1783:9): [True: 2.34M, False: 1.17M]
  ------------------
 1784|  2.34M|	if (XLENGTH(x) < 1)
  ------------------
  |  Branch (1784:6): [True: 0, False: 2.34M]
  ------------------
 1785|      0|	    return NA_LOGICAL;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
 1786|  2.34M|	if (checking && XLENGTH(x) > 1)
  ------------------
  |  Branch (1786:6): [True: 1.55M, False: 787k]
  |  Branch (1786:18): [True: 0, False: 1.55M]
  ------------------
 1787|      0|	    errorcall(call, _("'length = %lld' in coercion to '%s'"),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("'length = %lld' in coercion to '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1788|      0|		      (long long) XLENGTH(x), "logical(1)");
 1789|  2.34M|	switch (TYPEOF(x)) {
 1790|  2.34M|	case LGLSXP:
  ------------------
  |  |  121|  2.34M|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1790:2): [True: 2.34M, False: 40]
  ------------------
 1791|  2.34M|	    return LOGICAL_ELT(x, 0);
 1792|     40|	case INTSXP:
  ------------------
  |  |  123|     40|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1792:2): [True: 40, False: 2.34M]
  ------------------
 1793|     40|	    return LogicalFromInteger(INTEGER_ELT(x, 0), &warn);
  ------------------
  |  | 1937|     40|# define LogicalFromInteger	Rf_LogicalFromInteger
  ------------------
 1794|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1794:2): [True: 0, False: 2.34M]
  ------------------
 1795|      0|	    return LogicalFromReal(REAL_ELT(x, 0), &warn);
  ------------------
  |  | 1938|      0|# define LogicalFromReal	Rf_LogicalFromReal
  ------------------
 1796|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1796:2): [True: 0, False: 2.34M]
  ------------------
 1797|      0|	    return LogicalFromComplex(COMPLEX_ELT(x, 0), &warn);
  ------------------
  |  | 1936|      0|# define LogicalFromComplex	Rf_LogicalFromComplex
  ------------------
 1798|      0|	case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1798:2): [True: 0, False: 2.34M]
  ------------------
 1799|      0|	    return LogicalFromString(STRING_ELT(x, 0), &warn);
  ------------------
  |  | 1939|      0|# define LogicalFromString	Rf_LogicalFromString
  ------------------
 1800|      0|	case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1800:2): [True: 0, False: 2.34M]
  ------------------
 1801|      0|	    return LogicalFromInteger((int)RAW_ELT(x, 0), &warn);
  ------------------
  |  | 1937|      0|# define LogicalFromInteger	Rf_LogicalFromInteger
  ------------------
 1802|      0|	default:
  ------------------
  |  Branch (1802:2): [True: 0, False: 2.34M]
  ------------------
 1803|      0|	    UNIMPLEMENTED_TYPE("asLogical", x);
 1804|  2.34M|	}
 1805|  2.34M|    } else if(TYPEOF(x) == CHARSXP) {
  ------------------
  |  |  120|  1.17M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (1805:15): [True: 0, False: 1.17M]
  ------------------
 1806|      0|	    return LogicalFromString(x, &warn);
  ------------------
  |  | 1939|      0|# define LogicalFromString	Rf_LogicalFromString
  ------------------
 1807|      0|    }
 1808|  1.17M|    return NA_LOGICAL;
  ------------------
  |  |   55|  1.17M|#define NA_LOGICAL	R_NaInt
  ------------------
 1809|  3.51M|}
Rf_asLogical:
 1812|  1.95M|{
 1813|  1.95M|    return asLogical2(x, /* checking = */ 0, R_NilValue);
  ------------------
  |  |  887|  1.95M|#define asLogical2		Rf_asLogical2
  ------------------
 1814|  1.95M|}
Rf_asRbool:
 1818|  2.89k|{
 1819|  2.89k|    int ans = asLogical2(x, 1, call);
  ------------------
  |  |  887|  2.89k|#define asLogical2		Rf_asLogical2
  ------------------
 1820|  2.89k|    if (ans == NA_LOGICAL)
  ------------------
  |  |   55|  2.89k|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1820:9): [True: 0, False: 2.89k]
  ------------------
 1821|      0|	errorcall(call, _("NA in coercion to boolean"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("NA in coercion to boolean"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1822|  2.89k|    return (Rboolean) ans;
 1823|  2.89k|}
Rf_asBool2:
 1826|  8.94k|{
 1827|  8.94k|    int ans = asLogical2(x, 1, call);
  ------------------
  |  |  887|  8.94k|#define asLogical2		Rf_asLogical2
  ------------------
 1828|  8.94k|    if (ans == NA_LOGICAL)
  ------------------
  |  |   55|  8.94k|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1828:9): [True: 0, False: 8.94k]
  ------------------
 1829|      0|	errorcall(call, _("NA in coercion to boolean"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("NA in coercion to boolean"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1830|  8.94k|    return (bool) ans;
 1831|  8.94k|}
Rf_asInteger:
 1852|  1.18M|{
 1853|  1.18M|    int warn = 0, res;
 1854|       |
 1855|  1.18M|    if (isVectorAtomic(x) && XLENGTH(x) >= 1) {
  ------------------
  |  |  975|  1.18M|#define isVectorAtomic		Rf_isVectorAtomic
  ------------------
  |  Branch (1855:9): [True: 1.18M, False: 64]
  |  Branch (1855:30): [True: 1.18M, False: 0]
  ------------------
 1856|  1.18M|	switch (TYPEOF(x)) {
 1857|      0|        case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1857:9): [True: 0, False: 1.18M]
  ------------------
 1858|      0|            return (int) RAW_ELT(x, 0);
 1859|  2.37k|	case LGLSXP:
  ------------------
  |  |  121|  2.37k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1859:2): [True: 2.37k, False: 1.18M]
  ------------------
 1860|  2.37k|	    return IntegerFromLogical(LOGICAL_ELT(x, 0), &warn);
  ------------------
  |  | 1926|  2.37k|# define IntegerFromLogical	Rf_IntegerFromLogical
  ------------------
 1861|  1.17M|	case INTSXP:
  ------------------
  |  |  123|  1.17M|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1861:2): [True: 1.17M, False: 7.84k]
  ------------------
 1862|  1.17M|	    return INTEGER_ELT(x, 0);
 1863|  5.47k|	case REALSXP:
  ------------------
  |  |  124|  5.47k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1863:2): [True: 5.47k, False: 1.17M]
  ------------------
 1864|  5.47k|	    res = IntegerFromReal(REAL_ELT(x, 0), &warn);
  ------------------
  |  | 1927|  5.47k|# define IntegerFromReal	Rf_IntegerFromReal
  ------------------
 1865|  5.47k|	    CoercionWarning(warn);
  ------------------
  |  | 1870|  5.47k|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
 1866|  5.47k|	    return res;
 1867|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1867:2): [True: 0, False: 1.18M]
  ------------------
 1868|      0|	    res = IntegerFromComplex(COMPLEX_ELT(x, 0), &warn);
  ------------------
  |  | 1925|      0|# define IntegerFromComplex	Rf_IntegerFromComplex
  ------------------
 1869|      0|	    CoercionWarning(warn);
  ------------------
  |  | 1870|      0|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
 1870|      0|	    return res;
 1871|      0|	case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1871:2): [True: 0, False: 1.18M]
  ------------------
 1872|      0|	    res = IntegerFromString(STRING_ELT(x, 0), &warn);
  ------------------
  |  | 1928|      0|# define IntegerFromString	Rf_IntegerFromString
  ------------------
 1873|      0|	    CoercionWarning(warn);
  ------------------
  |  | 1870|      0|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
 1874|      0|	    return res;
 1875|      0|	default:
  ------------------
  |  Branch (1875:2): [True: 0, False: 1.18M]
  ------------------
 1876|      0|	    UNIMPLEMENTED_TYPE("asInteger", x);
 1877|  1.18M|	}
 1878|  1.18M|    } else if(TYPEOF(x) == CHARSXP) {
  ------------------
  |  |  120|     64|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (1878:15): [True: 0, False: 64]
  ------------------
 1879|      0|	res = IntegerFromString(x, &warn);
  ------------------
  |  | 1928|      0|# define IntegerFromString	Rf_IntegerFromString
  ------------------
 1880|      0|	CoercionWarning(warn);
  ------------------
  |  | 1870|      0|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
 1881|      0|	return res;
 1882|      0|    }
 1883|     64|    return NA_INTEGER;
  ------------------
  |  |   56|     64|#define NA_INTEGER	R_NaInt
  ------------------
 1884|  1.18M|}
Rf_asXLength:
 1888|     36|{
 1889|     36|    const R_xlen_t na = -999; /* any negative number should do */
 1890|       |
 1891|     36|    if (isVectorAtomic(x) && XLENGTH(x) >= 1) {
  ------------------
  |  |  975|     36|#define isVectorAtomic		Rf_isVectorAtomic
  ------------------
  |  Branch (1891:9): [True: 36, False: 0]
  |  Branch (1891:30): [True: 36, False: 0]
  ------------------
 1892|     36|	switch (TYPEOF(x)) {
 1893|     12|	case INTSXP:
  ------------------
  |  |  123|     12|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1893:2): [True: 12, False: 24]
  ------------------
 1894|     12|	{
 1895|     12|	    int res = INTEGER_ELT(x, 0);
 1896|     12|	    if (res == NA_INTEGER)
  ------------------
  |  |   56|     12|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1896:10): [True: 0, False: 12]
  ------------------
 1897|      0|		return na;
 1898|     12|	    else
 1899|     12|		return (R_xlen_t) res;
 1900|     12|	}
 1901|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1901:2): [True: 0, False: 36]
  ------------------
 1902|     24|	case REALSXP:
  ------------------
  |  |  124|     24|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1902:2): [True: 24, False: 12]
  ------------------
 1903|     24|	case CPLXSXP:
  ------------------
  |  |  125|     24|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1903:2): [True: 0, False: 36]
  ------------------
 1904|     24|	case STRSXP:
  ------------------
  |  |  126|     24|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1904:2): [True: 0, False: 36]
  ------------------
 1905|     24|	    break;
 1906|      0|	default:
  ------------------
  |  Branch (1906:2): [True: 0, False: 36]
  ------------------
 1907|      0|	    UNIMPLEMENTED_TYPE("asXLength", x);
 1908|     36|	}
 1909|     36|    } else if(TYPEOF(x) != CHARSXP)
  ------------------
  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (1909:15): [True: 0, False: 0]
  ------------------
 1910|      0|	return na;
 1911|       |
 1912|     24|    double d = asReal(x);
  ------------------
  |  |  889|     24|#define asReal			Rf_asReal
  ------------------
 1913|     24|    if (!R_FINITE(d) || d > R_XLEN_T_MAX || d < 0)
  ------------------
  |  |   82|     24|# define R_FINITE(x)    isfinite(x)
  ------------------
                  if (!R_FINITE(d) || d > R_XLEN_T_MAX || d < 0)
  ------------------
  |  |   76|     48|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (1913:9): [True: 0, False: 24]
  |  Branch (1913:25): [True: 0, False: 24]
  |  Branch (1913:45): [True: 2, False: 22]
  ------------------
 1914|      2|	return na;
 1915|     22|    else
 1916|     22|	return (R_xlen_t) d;
 1917|     24|}
Rf_asReal:
 1920|     32|{
 1921|     32|    int warn = 0;
 1922|     32|    double res;
 1923|       |
 1924|     32|    if (isVectorAtomic(x) && XLENGTH(x) >= 1) {
  ------------------
  |  |  975|     32|#define isVectorAtomic		Rf_isVectorAtomic
  ------------------
  |  Branch (1924:9): [True: 30, False: 2]
  |  Branch (1924:30): [True: 30, False: 0]
  ------------------
 1925|     30|	switch (TYPEOF(x)) {
 1926|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1926:2): [True: 0, False: 30]
  ------------------
 1927|      0|	    res = RealFromLogical(LOGICAL_ELT(x, 0), &warn);
  ------------------
  |  | 1981|      0|# define RealFromLogical	Rf_RealFromLogical
  ------------------
 1928|      0|	    CoercionWarning(warn);
  ------------------
  |  | 1870|      0|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
 1929|      0|	    return res;
 1930|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1930:2): [True: 0, False: 30]
  ------------------
 1931|      0|	    res = RealFromInteger(INTEGER_ELT(x, 0), &warn);
  ------------------
  |  | 1980|      0|# define RealFromInteger	Rf_RealFromInteger
  ------------------
 1932|      0|	    CoercionWarning(warn);
  ------------------
  |  | 1870|      0|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
 1933|      0|	    return res;
 1934|     30|	case REALSXP:
  ------------------
  |  |  124|     30|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1934:2): [True: 30, False: 0]
  ------------------
 1935|     30|	    return REAL_ELT(x, 0);
 1936|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1936:2): [True: 0, False: 30]
  ------------------
 1937|      0|	    res = RealFromComplex(COMPLEX_ELT(x, 0), &warn);
  ------------------
  |  | 1979|      0|# define RealFromComplex	Rf_RealFromComplex
  ------------------
 1938|      0|	    CoercionWarning(warn);
  ------------------
  |  | 1870|      0|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
 1939|      0|	    return res;
 1940|      0|	case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1940:2): [True: 0, False: 30]
  ------------------
 1941|      0|	    res = RealFromString(STRING_ELT(x, 0), &warn);
  ------------------
  |  | 1982|      0|# define RealFromString		Rf_RealFromString
  ------------------
 1942|      0|	    CoercionWarning(warn);
  ------------------
  |  | 1870|      0|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
 1943|      0|	    return res;
 1944|      0|	default:
  ------------------
  |  Branch (1944:2): [True: 0, False: 30]
  ------------------
 1945|      0|	    UNIMPLEMENTED_TYPE("asReal", x);
 1946|     30|	}
 1947|     30|    } else if(TYPEOF(x) == CHARSXP) {
  ------------------
  |  |  120|      2|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (1947:15): [True: 0, False: 2]
  ------------------
 1948|      0|	res = RealFromString(x, &warn);
  ------------------
  |  | 1982|      0|# define RealFromString		Rf_RealFromString
  ------------------
 1949|      0|	CoercionWarning(warn);
  ------------------
  |  | 1870|      0|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
 1950|      0|	return res;
 1951|      0|    }
 1952|      2|    return NA_REAL;
  ------------------
  |  |   58|      2|#define NA_REAL		R_NaReal
  ------------------
 1953|     32|}
do_typeof:
 1996|  1.16k|{
 1997|  1.16k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.16k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1998|  1.16k|    if(TYPEOF(CAR(args)) == OBJSXP && ! IS_S4_OBJECT(CAR(args)))
  ------------------
  |  |  137|  2.32k|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (1998:8): [True: 0, False: 1.16k]
  |  Branch (1998:39): [True: 0, False: 0]
  ------------------
 1999|      0|	return mkString("object");
  ------------------
  |  | 1003|      0|#define mkString		Rf_mkString
  ------------------
 2000|  1.16k|    else
 2001|  1.16k|	return type2rstr(TYPEOF(CAR(args)));
  ------------------
  |  | 1041|  1.16k|#define type2rstr		Rf_type2rstr
  ------------------
 2002|  1.16k|}
do_is:
 2008|   392k|{
 2009|   392k|    SEXP ans;
 2010|   392k|    checkArity(op, args);
  ------------------
  |  | 1788|   392k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2011|   392k|    check1arg(args, call, "x");
  ------------------
  |  | 1867|   392k|# define check1arg		Rf_check1arg
  ------------------
 2012|       |
 2013|       |    /* These are all builtins, so we do not need to worry about
 2014|       |       evaluating arguments in DispatchOrEval */
 2015|   392k|    if(PRIMVAL(op) >= 100 && PRIMVAL(op) < 200 && isObject(CAR(args))) {
  ------------------
  |  | 1347|   392k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
                  if(PRIMVAL(op) >= 100 && PRIMVAL(op) < 200 && isObject(CAR(args))) {
  ------------------
  |  | 1347|   387k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
                  if(PRIMVAL(op) >= 100 && PRIMVAL(op) < 200 && isObject(CAR(args))) {
  ------------------
  |  |  959|     18|#define isObject		Rf_isObject
  ------------------
  |  Branch (2015:8): [True: 387k, False: 4.64k]
  |  Branch (2015:30): [True: 18, False: 387k]
  |  Branch (2015:51): [True: 0, False: 18]
  ------------------
 2016|       |	/* This used CHAR(PRINTNAME(CAR(call))), but that is not
 2017|       |	   necessarily correct, e.g. when called from lapply() */
 2018|      0|	const char *nm;
 2019|      0|	switch(PRIMVAL(op)) {
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
 2020|      0|	case 100: nm = "is.numeric"; break;
  ------------------
  |  Branch (2020:2): [True: 0, False: 0]
  ------------------
 2021|      0|	case 101: nm = "is.matrix"; break;
  ------------------
  |  Branch (2021:2): [True: 0, False: 0]
  ------------------
 2022|      0|	case 102: nm = "is.array"; break;
  ------------------
  |  Branch (2022:2): [True: 0, False: 0]
  ------------------
 2023|      0|	default: nm = ""; /* -Wall */
  ------------------
  |  Branch (2023:2): [True: 0, False: 0]
  ------------------
 2024|      0|	}
 2025|       |	/* DispatchOrEval internal generic: is.numeric */
 2026|       |	/* DispatchOrEval internal generic: is.matrix */
 2027|       |	/* DispatchOrEval internal generic: is.array */
 2028|      0|	if(DispatchOrEval(call, op, nm, args, rho, &ans, 0, 1))
  ------------------
  |  | 1887|      0|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (2028:5): [True: 0, False: 0]
  ------------------
 2029|      0|	    return(ans);
 2030|      0|    }
 2031|       |
 2032|   392k|    PROTECT(ans = allocVector(LGLSXP, 1));
  ------------------
  |  |  357|   392k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2033|       |
 2034|   392k|    switch (PRIMVAL(op)) {
  ------------------
  |  | 1347|   392k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
 2035|     74|    case NILSXP:	/* is.null */
  ------------------
  |  |  111|     74|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (2035:5): [True: 74, False: 392k]
  ------------------
 2036|     74|	LOGICAL0(ans)[0] = isNull(CAR(args));
  ------------------
  |  |  956|     74|#define isNull			Rf_isNull
  ------------------
 2037|     74|	break;
 2038|      0|    case LGLSXP:	/* is.logical */
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2038:5): [True: 0, False: 392k]
  ------------------
 2039|      0|	LOGICAL0(ans)[0] = (TYPEOF(CAR(args)) == LGLSXP);
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
 2040|      0|	break;
 2041|      0|    case INTSXP:	/* is.integer */
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2041:5): [True: 0, False: 392k]
  ------------------
 2042|      0|	LOGICAL0(ans)[0] = (TYPEOF(CAR(args)) == INTSXP)
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2042:21): [True: 0, False: 0]
  ------------------
 2043|      0|	    && !inherits(CAR(args), "factor");
  ------------------
  |  |  933|      0|#define inherits		Rf_inherits
  ------------------
  |  Branch (2043:9): [True: 0, False: 0]
  ------------------
 2044|      0|	break;
 2045|      0|    case REALSXP:	/* is.double */
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (2045:5): [True: 0, False: 392k]
  ------------------
 2046|      0|	LOGICAL0(ans)[0] = (TYPEOF(CAR(args)) == REALSXP);
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
 2047|      0|	break;
 2048|      0|    case CPLXSXP:	/* is.complex */
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (2048:5): [True: 0, False: 392k]
  ------------------
 2049|      0|	LOGICAL0(ans)[0] = (TYPEOF(CAR(args)) == CPLXSXP);
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
 2050|      0|	break;
 2051|      2|    case STRSXP:	/* is.character */
  ------------------
  |  |  126|      2|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2051:5): [True: 2, False: 392k]
  ------------------
 2052|      2|	LOGICAL0(ans)[0] = (TYPEOF(CAR(args)) == STRSXP);
  ------------------
  |  |  126|      2|#define STRSXP	    16	  /* string vectors */
  ------------------
 2053|      2|	break;
 2054|      0|    case SYMSXP:	/* is.symbol === is.name */
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (2054:5): [True: 0, False: 392k]
  ------------------
 2055|      0|	if(IS_S4_OBJECT(CAR(args)) && (TYPEOF(CAR(args)) == OBJSXP)) {
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (2055:5): [True: 0, False: 0]
  |  Branch (2055:32): [True: 0, False: 0]
  ------------------
 2056|      0|	    SEXP dot_xData = R_getS4DataSlot(CAR(args), SYMSXP);
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
 2057|      0|	    LOGICAL0(ans)[0] = (TYPEOF(dot_xData) == SYMSXP);
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
 2058|      0|	}
 2059|      0|	else
 2060|      0|	    LOGICAL0(ans)[0] = (TYPEOF(CAR(args)) == SYMSXP);
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
 2061|      0|	break;
 2062|      0|    case ENVSXP:	/* is.environment */
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (2062:5): [True: 0, False: 392k]
  ------------------
 2063|      0|	if(IS_S4_OBJECT(CAR(args)) && (TYPEOF(CAR(args)) == OBJSXP)) {
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (2063:5): [True: 0, False: 0]
  |  Branch (2063:32): [True: 0, False: 0]
  ------------------
 2064|      0|	    SEXP dot_xData = R_getS4DataSlot(CAR(args), ENVSXP);
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
 2065|      0|	    LOGICAL0(ans)[0] = (TYPEOF(dot_xData) == ENVSXP);
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
 2066|      0|	}
 2067|      0|	else
 2068|      0|	    LOGICAL0(ans)[0] = (TYPEOF(CAR(args)) == ENVSXP);
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
 2069|      0|	break;
 2070|  4.36k|    case VECSXP:	/* is.list */
  ------------------
  |  |  131|  4.36k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2070:5): [True: 4.36k, False: 388k]
  ------------------
 2071|  4.36k|	LOGICAL0(ans)[0] = (TYPEOF(CAR(args)) == VECSXP ||
  ------------------
  |  |  131|  8.73k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2071:22): [True: 1.18k, False: 3.18k]
  ------------------
 2072|  3.18k|			    TYPEOF(CAR(args)) == LISTSXP);
  ------------------
  |  |  113|  3.18k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2072:8): [True: 0, False: 3.18k]
  ------------------
 2073|  4.36k|	break;
 2074|    118|    case LISTSXP:	/* is.pairlist */
  ------------------
  |  |  113|    118|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2074:5): [True: 118, False: 392k]
  ------------------
 2075|    118|	LOGICAL0(ans)[0] = (TYPEOF(CAR(args)) == LISTSXP ||
  ------------------
  |  |  113|    236|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2075:22): [True: 0, False: 118]
  ------------------
 2076|    118|			    TYPEOF(CAR(args)) == NILSXP);/* pairlist() -> NULL */
  ------------------
  |  |  111|    118|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (2076:8): [True: 0, False: 118]
  ------------------
 2077|    118|	break;
 2078|     72|    case EXPRSXP:	/* is.expression */
  ------------------
  |  |  132|     72|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (2078:5): [True: 72, False: 392k]
  ------------------
 2079|     72|	LOGICAL0(ans)[0] = TYPEOF(CAR(args)) == EXPRSXP;
  ------------------
  |  |  132|     72|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
 2080|     72|	break;
 2081|      0|    case RAWSXP:	/* is.raw */
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (2081:5): [True: 0, False: 392k]
  ------------------
 2082|      0|	LOGICAL0(ans)[0] = (TYPEOF(CAR(args)) == RAWSXP);
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
 2083|      0|	break;
 2084|       |
 2085|      2|    case 50:		/* is.object */
  ------------------
  |  Branch (2085:5): [True: 2, False: 392k]
  ------------------
 2086|      2|	LOGICAL0(ans)[0] = OBJECT(CAR(args));
 2087|      2|	break;
 2088|      5|    case 51:		/* isS4 */
  ------------------
  |  Branch (2088:5): [True: 5, False: 392k]
  ------------------
 2089|      5|	LOGICAL0(ans)[0] = IS_S4_OBJECT(CAR(args)) != 0;
 2090|      5|	break;
 2091|       |/* no longer used: is.data.frame is R code
 2092|       |    case 80:
 2093|       |	LOGICAL0(ans)[0] = isDataFrame(CAR(args));
 2094|       |	break;
 2095|       |*/
 2096|       |
 2097|      6|    case 100:		/* is.numeric */
  ------------------
  |  Branch (2097:5): [True: 6, False: 392k]
  ------------------
 2098|      6|	LOGICAL0(ans)[0] = isNumeric(CAR(args)) &&
  ------------------
  |  |  957|      6|#define isNumeric		Rf_isNumeric
  ------------------
  |  Branch (2098:21): [True: 6, False: 0]
  ------------------
 2099|      6|	    !isLogical(CAR(args));  /* isNumeric excludes factors */
  ------------------
  |  |  952|      6|#define isLogical		Rf_isLogical
  ------------------
  |  Branch (2099:6): [True: 2, False: 4]
  ------------------
 2100|      6|	break;
 2101|     12|    case 101:		/* is.matrix */
  ------------------
  |  Branch (2101:5): [True: 12, False: 392k]
  ------------------
 2102|     12|	LOGICAL0(ans)[0] = isMatrix(CAR(args));
  ------------------
  |  |  954|     12|#define isMatrix		Rf_isMatrix
  ------------------
 2103|     12|	break;
 2104|      0|    case 102:		/* is.array */
  ------------------
  |  Branch (2104:5): [True: 0, False: 392k]
  ------------------
 2105|      0|	LOGICAL0(ans)[0] = isArray(CAR(args));
  ------------------
  |  |  940|      0|#define isArray			Rf_isArray
  ------------------
 2106|      0|	break;
 2107|       |
 2108|  1.02k|    case 200:		/* is.atomic */
  ------------------
  |  Branch (2108:5): [True: 1.02k, False: 391k]
  ------------------
 2109|  1.02k|	switch(TYPEOF(CAR(args))) {
 2110|       |#ifdef S_compatible_BUT_UNDESIRABLE
 2111|       |	case NILSXP:
 2112|       |	    /* NULL is atomic (S compatibly), but not in isVectorAtomic(.) */
 2113|       |#endif
 2114|      0|	case CHARSXP:
  ------------------
  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (2114:2): [True: 0, False: 1.02k]
  ------------------
 2115|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2115:2): [True: 0, False: 1.02k]
  ------------------
 2116|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2116:2): [True: 0, False: 1.02k]
  ------------------
 2117|  1.00k|	case REALSXP:
  ------------------
  |  |  124|  1.00k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (2117:2): [True: 1.00k, False: 24]
  ------------------
 2118|  1.00k|	case CPLXSXP:
  ------------------
  |  |  125|  1.00k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (2118:2): [True: 0, False: 1.02k]
  ------------------
 2119|  1.02k|	case STRSXP:
  ------------------
  |  |  126|  1.02k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2119:2): [True: 24, False: 1.00k]
  ------------------
 2120|  1.02k|	case RAWSXP:
  ------------------
  |  |  136|  1.02k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (2120:2): [True: 0, False: 1.02k]
  ------------------
 2121|  1.02k|	    LOGICAL0(ans)[0] = 1;
 2122|  1.02k|	    break;
 2123|      0|	default:
  ------------------
  |  Branch (2123:2): [True: 0, False: 1.02k]
  ------------------
 2124|      0|	    LOGICAL0(ans)[0] = 0;
 2125|      0|	    break;
 2126|  1.02k|	}
 2127|  1.02k|	break;
 2128|  1.02k|    case 201:		/* is.recursive */
  ------------------
  |  Branch (2128:5): [True: 0, False: 392k]
  ------------------
 2129|      0|	switch(TYPEOF(CAR(args))) {
 2130|      0|	case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2130:2): [True: 0, False: 0]
  ------------------
 2131|      0|	case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2131:2): [True: 0, False: 0]
  ------------------
 2132|      0|	case CLOSXP:
  ------------------
  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (2132:2): [True: 0, False: 0]
  ------------------
 2133|      0|	case ENVSXP:
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (2133:2): [True: 0, False: 0]
  ------------------
 2134|      0|	case PROMSXP:
  ------------------
  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2134:2): [True: 0, False: 0]
  ------------------
 2135|      0|	case LANGSXP:
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (2135:2): [True: 0, False: 0]
  ------------------
 2136|      0|	case SPECIALSXP:
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (2136:2): [True: 0, False: 0]
  ------------------
 2137|      0|	case BUILTINSXP:
  ------------------
  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (2137:2): [True: 0, False: 0]
  ------------------
 2138|      0|	case DOTSXP:
  ------------------
  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (2138:2): [True: 0, False: 0]
  ------------------
 2139|      0|	case ANYSXP:
  ------------------
  |  |  128|      0|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
  |  Branch (2139:2): [True: 0, False: 0]
  ------------------
 2140|      0|	case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (2140:2): [True: 0, False: 0]
  ------------------
 2141|       |	// Not recursive, as long as not subsettable (on the R level)
 2142|       |	// case EXTPTRSXP:
 2143|       |	// case BCODESXP:
 2144|       |	// case WEAKREFSXP:
 2145|      0|	    LOGICAL0(ans)[0] = 1;
 2146|      0|	    break;
 2147|      0|	default:
  ------------------
  |  Branch (2147:2): [True: 0, False: 0]
  ------------------
 2148|      0|	    LOGICAL0(ans)[0] = 0;
 2149|      0|	    break;
 2150|      0|	}
 2151|      0|	break;
 2152|       |
 2153|     72|    case 300:		/* is.call */
  ------------------
  |  Branch (2153:5): [True: 72, False: 392k]
  ------------------
 2154|     72|	LOGICAL0(ans)[0] = TYPEOF(CAR(args)) == LANGSXP;
  ------------------
  |  |  117|     72|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
 2155|     72|	break;
 2156|      0|    case 301:		/* is.language */
  ------------------
  |  Branch (2156:5): [True: 0, False: 392k]
  ------------------
 2157|      0|	LOGICAL0(ans)[0] = (TYPEOF(CAR(args)) == SYMSXP ||
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (2157:22): [True: 0, False: 0]
  ------------------
 2158|      0|			    TYPEOF(CAR(args)) == LANGSXP ||
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (2158:8): [True: 0, False: 0]
  ------------------
 2159|      0|			    TYPEOF(CAR(args)) == EXPRSXP);
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (2159:8): [True: 0, False: 0]
  ------------------
 2160|      0|	break;
 2161|   386k|    case 302:		/* is.function */
  ------------------
  |  Branch (2161:5): [True: 386k, False: 5.75k]
  ------------------
 2162|   386k|	LOGICAL0(ans)[0] = isFunction(CAR(args));
  ------------------
  |  |  948|   386k|#define isFunction		Rf_isFunction
  ------------------
 2163|   386k|	break;
 2164|       |
 2165|      0|    case 999:		/* is.single */
  ------------------
  |  Branch (2165:5): [True: 0, False: 392k]
  ------------------
 2166|      0|	errorcall(call, _("type \"single\" unimplemented in R"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("type \"single\" unimplemented in R"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2167|      0|    default:
  ------------------
  |  Branch (2167:5): [True: 0, False: 392k]
  ------------------
 2168|      0|	errorcall(call, _("unimplemented predicate"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("unimplemented predicate"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2169|   392k|    }
 2170|   392k|    UNPROTECT(1);
  ------------------
  |  |  358|   392k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2171|   392k|    return (ans);
 2172|   392k|}
do_isvector:
 2181|  1.36k|{
 2182|  1.36k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.36k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2183|  1.36k|    SEXP x = CAR(args);
 2184|  1.36k|    if (!isString(CADR(args)) || LENGTH(CADR(args)) != 1)
  ------------------
  |  |  966|  1.36k|#define isString		Rf_isString
  ------------------
  |  Branch (2184:9): [True: 0, False: 1.36k]
  |  Branch (2184:34): [True: 0, False: 1.36k]
  ------------------
 2185|  1.36k|	error_return(R_MSG_mode);
  ------------------
  |  | 1229|      0|#define error_return(msg)	{ Rf_error(msg);	   return R_NilValue; }
  ------------------
 2186|       |
 2187|  1.36k|    const char *stype = CHAR(STRING_ELT(CADR(args), 0)); // 'mode' in R ; ASCII
  ------------------
  |  |  203|  1.36k|#define CHAR(x) R_CHAR(x)
  ------------------
 2188|       |
 2189|       |    /* "name" and "symbol" are synonymous */
 2190|  1.36k|    if (streql(stype, "name"))
  ------------------
  |  | 1498|  1.36k|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 1.36k]
  |  |  ------------------
  ------------------
 2191|      0|      stype = "symbol";
 2192|       |
 2193|  1.36k|    SEXP ans = PROTECT(allocVector(LGLSXP, 1));
  ------------------
  |  |  357|  1.36k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2194|  1.36k|    bool any = streql(stype, "any");
  ------------------
  |  | 1498|  1.36k|#define streql(s, t)	(!strcmp((s), (t)))
  ------------------
 2195|  1.36k|    if (any) {
  ------------------
  |  Branch (2195:9): [True: 1.36k, False: 0]
  ------------------
 2196|       |	/* isVector is inlined, means atomic or VECSXP or EXPRSXP */
 2197|  1.36k|	LOGICAL0(ans)[0] = isVector(x);
  ------------------
  |  |  974|  1.36k|#define isVector		Rf_isVector
  ------------------
 2198|  1.36k|    }
 2199|      0|    else if (streql(stype, "numeric")) {
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2200|      0|	LOGICAL0(ans)[0] = (isNumeric(x) && !isLogical(x));
  ------------------
  |  |  957|      0|#define isNumeric		Rf_isNumeric
  ------------------
              	LOGICAL0(ans)[0] = (isNumeric(x) && !isLogical(x));
  ------------------
  |  |  952|      0|#define isLogical		Rf_isLogical
  ------------------
  |  Branch (2200:22): [True: 0, False: 0]
  |  Branch (2200:38): [True: 0, False: 0]
  ------------------
 2201|      0|    }
 2202|       |    /* So this allows any type, including undocumented ones such as
 2203|       |       "closure", but not aliases such as "name" and "function". */
 2204|      0|    else if (streql(stype, R_typeToChar(x))) {
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2205|      0|	LOGICAL0(ans)[0] = 1;
 2206|      0|    }
 2207|      0|    else
 2208|      0|	LOGICAL0(ans)[0] = 0;
 2209|       |
 2210|  1.36k|    if (LOGICAL0(ans)[0]) {
  ------------------
  |  Branch (2210:9): [True: 1.30k, False: 54]
  ------------------
 2211|  1.30k|      bool IS_vector = false;
 2212|  1.30k|      MAYBE_CACHE_DO_IS_AS_VECTORS_EXPERI;
  ------------------
  |  | 1498|  1.30k|#define MAYBE_CACHE_DO_IS_AS_VECTORS_EXPERI				\
  |  | 1499|  1.30k|do {									\
  |  | 1500|  1.30k|  if(do_is_as_vector_experiments == -1) {				\
  |  |  ------------------
  |  |  |  Branch (1500:6): [True: 2, False: 1.30k]
  |  |  ------------------
  |  | 1501|      2|    char *vector_experi = getenv("_R_IS_AS_VECTOR_EXPERIMENTS_");	\
  |  | 1502|      2|    do_is_as_vector_experiments =					\
  |  | 1503|      2| 	((vector_experi != NULL) && StringTrue(vector_experi)) ? 1 : 0;	\
  |  |  ------------------
  |  |  |  |   52|      0|#define StringTrue    Rf_StringTrue
  |  |  ------------------
  |  |  |  Branch (1503:4): [True: 0, False: 2]
  |  |  |  Branch (1503:31): [True: 0, False: 0]
  |  |  ------------------
  |  | 1504|      2|  }									\
  |  | 1505|  1.30k|} while(0)
  |  |  ------------------
  |  |  |  Branch (1505:9): [Folded, False: 1.30k]
  |  |  ------------------
  ------------------
 2213|  1.30k|      if(do_is_as_vector_experiments) {
  ------------------
  |  Branch (2213:10): [True: 0, False: 1.30k]
  ------------------
 2214|      0|	if((IS_vector = any && isVectorList(x) && OBJECT(x))) {
  ------------------
  |  |  977|      0|#define isVectorList		Rf_isVectorList
  ------------------
  |  Branch (2214:5): [True: 0, False: 0]
  |  Branch (2214:18): [True: 0, False: 0]
  |  Branch (2214:25): [True: 0, False: 0]
  |  Branch (2214:44): [True: 0, False: 0]
  ------------------
 2215|       |	    // use of is.vector(.) to check for non-matrix/array => try dim(.) :
 2216|      0|	  static SEXP op_dim = NULL;
 2217|      0|	  if (op_dim == NULL)
  ------------------
  |  Branch (2217:8): [True: 0, False: 0]
  ------------------
 2218|      0|	      op_dim = R_Primitive("dim");
 2219|      0|	  SEXP args = PROTECT(list1(x));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2220|      0|	  IS_vector = isNull(do_dim(call, op_dim, args, rho));
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
 2221|      0|	  UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2222|      0|	}
 2223|      0|      }
 2224|  1.30k|      if(IS_vector) {
  ------------------
  |  Branch (2224:10): [True: 0, False: 1.30k]
  ------------------
 2225|       |	  // list or expression w/ is.object() and no dim(): stay TRUE
 2226|  1.30k|      } else if (ATTRIB(x) != R_NilValue) {
  ------------------
  |  Branch (2226:18): [True: 88, False: 1.22k]
  ------------------
 2227|       |	/* We allow a "names" attribute on any vector. */
 2228|     88|	SEXP a = ATTRIB(x);
 2229|    124|	while(a != R_NilValue) {
  ------------------
  |  Branch (2229:8): [True: 96, False: 28]
  ------------------
 2230|     96|	    if (TAG(a) != R_NamesSymbol) {
  ------------------
  |  Branch (2230:10): [True: 60, False: 36]
  ------------------
 2231|     60|		LOGICAL0(ans)[0] = 0;
 2232|     60|		break;
 2233|     60|	    }
 2234|     36|	    a = CDR(a);
 2235|     36|	}
 2236|     88|      }
 2237|  1.30k|    }
 2238|  1.36k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.36k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2239|  1.36k|    return (ans);
 2240|  1.36k|}
do_isna:
 2267|   771k|{
 2268|   771k|    SEXP ans, x;
 2269|   771k|    R_xlen_t i, n;
 2270|       |
 2271|   771k|    checkArity(op, args);
  ------------------
  |  | 1788|   771k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2272|   771k|    check1arg(args, call, "x");
  ------------------
  |  | 1867|   771k|# define check1arg		Rf_check1arg
  ------------------
 2273|       |
 2274|       |    /* DispatchOrEval internal generic: is.na */
 2275|   771k|    if (DispatchOrEval(call, op, "is.na", args, rho, &ans, 1, 1))
  ------------------
  |  | 1887|   771k|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (2275:9): [True: 0, False: 771k]
  ------------------
 2276|      0|	return(ans);
 2277|   771k|    PROTECT(args = ans);
  ------------------
  |  |  357|   771k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2278|       |#ifdef stringent_is
 2279|       |    if (!isList(CAR(args)) && !isVector(CAR(args)))
 2280|       |	errorcall_return(call, "is.na " R_MSG_list_vec);
 2281|       |
 2282|       |#endif
 2283|   771k|    x = CAR(args);
 2284|   771k|    n = xlength(x);
  ------------------
  |  | 1049|   771k|#define xlength(x)		Rf_xlength(x)
  ------------------
 2285|   771k|    PROTECT(ans = allocVector(LGLSXP, n));
  ------------------
  |  |  357|   771k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2286|   771k|    int *pa = LOGICAL(ans);
 2287|   771k|    switch (TYPEOF(x)) {
 2288|    216|    case LGLSXP:
  ------------------
  |  |  121|    216|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2288:5): [True: 216, False: 771k]
  ------------------
 2289|    432|       for (i = 0; i < n; i++)
  ------------------
  |  Branch (2289:20): [True: 216, False: 216]
  ------------------
 2290|    216|	   pa[i] = (LOGICAL_ELT(x, i) == NA_LOGICAL);
  ------------------
  |  |   55|    216|#define NA_LOGICAL	R_NaInt
  ------------------
 2291|    216|	break;
 2292|   770k|    case INTSXP:
  ------------------
  |  |  123|   770k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2292:5): [True: 770k, False: 778]
  ------------------
 2293|  1.54M|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (2293:14): [True: 770k, False: 770k]
  ------------------
 2294|   770k|	    pa[i] = (INTEGER_ELT(x, i) == NA_INTEGER);
  ------------------
  |  |   56|   770k|#define NA_INTEGER	R_NaInt
  ------------------
 2295|   770k|	break;
 2296|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (2296:5): [True: 0, False: 771k]
  ------------------
 2297|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (2297:14): [True: 0, False: 0]
  ------------------
 2298|      0|	    pa[i] = ISNAN(REAL_ELT(x, i));
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  ------------------
 2299|      0|	break;
 2300|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (2300:5): [True: 0, False: 771k]
  ------------------
 2301|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (2301:14): [True: 0, False: 0]
  ------------------
 2302|      0|	    Rcomplex v = COMPLEX_ELT(x, i);
 2303|      0|	    pa[i] = (ISNAN(v.r) || ISNAN(v.i));
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	    pa[i] = (ISNAN(v.r) || ISNAN(v.i));
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2304|      0|	}
 2305|      0|	break;
 2306|    562|    case STRSXP:
  ------------------
  |  |  126|    562|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2306:5): [True: 562, False: 771k]
  ------------------
 2307|  3.74k|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (2307:14): [True: 3.17k, False: 562]
  ------------------
 2308|  3.17k|	    pa[i] = (STRING_ELT(x, i) == NA_STRING);
  ------------------
  |  |  433|  3.17k|#define NA_STRING	R_NaString
  ------------------
 2309|    562|	break;
 2310|       |
 2311|       |/* Same code for LISTSXP and VECSXP : */
 2312|      0|#define LIST_VEC_NA(s)							\
 2313|      0|	if (!isVector(s) || length(s) != 1)				\
 2314|      0|	    pa[i] = 0;							\
 2315|      0|	else {								\
 2316|      0|		switch (TYPEOF(s)) {					\
 2317|      0|		case LGLSXP:						\
 2318|      0|		case INTSXP:						\
 2319|      0|		    pa[i] = (INTEGER_ELT(s, 0) == NA_INTEGER);		\
 2320|      0|		    break;						\
 2321|      0|		case REALSXP:						\
 2322|      0|		    pa[i] = ISNAN(REAL_ELT(s, 0));			\
 2323|      0|		    break;						\
 2324|      0|		case STRSXP:						\
 2325|      0|		    pa[i] = (STRING_ELT(s, 0) == NA_STRING);		\
 2326|      0|		    break;						\
 2327|      0|		case CPLXSXP:						\
 2328|      0|		    {							\
 2329|      0|			Rcomplex v = COMPLEX_ELT(s, 0);			\
 2330|      0|			pa[i] = (ISNAN(v.r) || ISNAN(v.i));		\
 2331|      0|		    }							\
 2332|      0|		    break;						\
 2333|      0|		default:						\
 2334|      0|		    pa[i] = 0;						\
 2335|      0|		}							\
 2336|      0|	}
 2337|       |
 2338|      0|    case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2338:5): [True: 0, False: 771k]
  ------------------
 2339|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (2339:14): [True: 0, False: 0]
  ------------------
 2340|      0|	    LIST_VEC_NA(CAR(x));
  ------------------
  |  | 2313|      0|	if (!isVector(s) || length(s) != 1)				\
  |  |  ------------------
  |  |  |  |  974|      0|#define isVector		Rf_isVector
  |  |  ------------------
  |  |               	if (!isVector(s) || length(s) != 1)				\
  |  |  ------------------
  |  |  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  ------------------
  |  |  |  Branch (2313:6): [True: 0, False: 0]
  |  |  |  Branch (2313:22): [True: 0, False: 0]
  |  |  ------------------
  |  | 2314|      0|	    pa[i] = 0;							\
  |  | 2315|      0|	else {								\
  |  | 2316|      0|		switch (TYPEOF(s)) {					\
  |  | 2317|      0|		case LGLSXP:						\
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (2317:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 2318|      0|		case INTSXP:						\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (2318:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 2319|      0|		    pa[i] = (INTEGER_ELT(s, 0) == NA_INTEGER);		\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  | 2320|      0|		    break;						\
  |  | 2321|      0|		case REALSXP:						\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (2321:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 2322|      0|		    pa[i] = ISNAN(REAL_ELT(s, 0));			\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  | 2323|      0|		    break;						\
  |  | 2324|      0|		case STRSXP:						\
  |  |  ------------------
  |  |  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (2324:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 2325|      0|		    pa[i] = (STRING_ELT(s, 0) == NA_STRING);		\
  |  |  ------------------
  |  |  |  |  433|      0|#define NA_STRING	R_NaString
  |  |  ------------------
  |  | 2326|      0|		    break;						\
  |  | 2327|      0|		case CPLXSXP:						\
  |  |  ------------------
  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |  |  Branch (2327:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 2328|      0|		    {							\
  |  | 2329|      0|			Rcomplex v = COMPLEX_ELT(s, 0);			\
  |  | 2330|      0|			pa[i] = (ISNAN(v.r) || ISNAN(v.i));		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               			pa[i] = (ISNAN(v.r) || ISNAN(v.i));		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2331|      0|		    }							\
  |  | 2332|      0|		    break;						\
  |  | 2333|      0|		default:						\
  |  |  ------------------
  |  |  |  Branch (2333:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 2334|      0|		    pa[i] = 0;						\
  |  | 2335|      0|		}							\
  |  | 2336|      0|	}
  ------------------
 2341|      0|	    x = CDR(x);
 2342|      0|	}
 2343|      0|	break;
 2344|      0|    case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2344:5): [True: 0, False: 771k]
  ------------------
 2345|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (2345:14): [True: 0, False: 0]
  ------------------
 2346|      0|	    SEXP s = VECTOR_ELT(x, i);
 2347|      0|	    LIST_VEC_NA(s);
  ------------------
  |  | 2313|      0|	if (!isVector(s) || length(s) != 1)				\
  |  |  ------------------
  |  |  |  |  974|      0|#define isVector		Rf_isVector
  |  |  ------------------
  |  |               	if (!isVector(s) || length(s) != 1)				\
  |  |  ------------------
  |  |  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  ------------------
  |  |  |  Branch (2313:6): [True: 0, False: 0]
  |  |  |  Branch (2313:22): [True: 0, False: 0]
  |  |  ------------------
  |  | 2314|      0|	    pa[i] = 0;							\
  |  | 2315|      0|	else {								\
  |  | 2316|      0|		switch (TYPEOF(s)) {					\
  |  | 2317|      0|		case LGLSXP:						\
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (2317:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 2318|      0|		case INTSXP:						\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (2318:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 2319|      0|		    pa[i] = (INTEGER_ELT(s, 0) == NA_INTEGER);		\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  | 2320|      0|		    break;						\
  |  | 2321|      0|		case REALSXP:						\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (2321:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 2322|      0|		    pa[i] = ISNAN(REAL_ELT(s, 0));			\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  | 2323|      0|		    break;						\
  |  | 2324|      0|		case STRSXP:						\
  |  |  ------------------
  |  |  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (2324:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 2325|      0|		    pa[i] = (STRING_ELT(s, 0) == NA_STRING);		\
  |  |  ------------------
  |  |  |  |  433|      0|#define NA_STRING	R_NaString
  |  |  ------------------
  |  | 2326|      0|		    break;						\
  |  | 2327|      0|		case CPLXSXP:						\
  |  |  ------------------
  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |  |  Branch (2327:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 2328|      0|		    {							\
  |  | 2329|      0|			Rcomplex v = COMPLEX_ELT(s, 0);			\
  |  | 2330|      0|			pa[i] = (ISNAN(v.r) || ISNAN(v.i));		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               			pa[i] = (ISNAN(v.r) || ISNAN(v.i));		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2331|      0|		    }							\
  |  | 2332|      0|		    break;						\
  |  | 2333|      0|		default:						\
  |  |  ------------------
  |  |  |  Branch (2333:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 2334|      0|		    pa[i] = 0;						\
  |  | 2335|      0|		}							\
  |  | 2336|      0|	}
  ------------------
 2348|      0|	}
 2349|      0|	break;
 2350|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (2350:5): [True: 0, False: 771k]
  ------------------
 2351|       |	/* no such thing as a raw NA */
 2352|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (2352:14): [True: 0, False: 0]
  ------------------
 2353|      0|	    pa[i] = 0;
 2354|      0|	break;
 2355|      0|    case NILSXP: break;
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (2355:5): [True: 0, False: 771k]
  ------------------
 2356|      0|    default:
  ------------------
  |  Branch (2356:5): [True: 0, False: 771k]
  ------------------
 2357|      0|	warningcall(call, _("%s() applied to non-(list or vector) of type '%s'"),
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              	warningcall(call, _("%s() applied to non-(list or vector) of type '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2358|      0|		    "is.na", R_typeToChar(x));
 2359|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (2359:14): [True: 0, False: 0]
  ------------------
 2360|      0|	    pa[i] = 0;
 2361|   771k|    }
 2362|       |
 2363|   771k|    copyDimAndNames(x, ans);
 2364|   771k|    UNPROTECT(2); /* args, ans */
  ------------------
  |  |  358|   771k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2365|   771k|    return ans;
 2366|   771k|}
do_anyNA:
 2483|  1.02k|{
 2484|  1.02k|    SEXP ans;
 2485|  1.02k|    static SEXP do_anyNA_formals = NULL;
 2486|       |
 2487|  1.02k|    if (length(args) < 1 || length(args) > 2)
  ------------------
  |  |  987|  1.02k|#define length(x)		Rf_length(x)
  ------------------
                  if (length(args) < 1 || length(args) > 2)
  ------------------
  |  |  987|  1.02k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (2487:9): [True: 0, False: 1.02k]
  |  Branch (2487:29): [True: 0, False: 1.02k]
  ------------------
 2488|      0|	errorcall(call, "anyNA takes 1 or 2 arguments");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 2489|       |
 2490|       |    /* DispatchOrEval internal generic: anyNA */
 2491|  1.02k|    if (DispatchOrEval(call, op, "anyNA", args, rho, &ans, 0, 1))
  ------------------
  |  | 1887|  1.02k|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (2491:9): [True: 0, False: 1.02k]
  ------------------
 2492|      0|	return ans;
 2493|       |
 2494|  1.02k|    if(length(args) == 1) {
  ------------------
  |  |  987|  1.02k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (2494:8): [True: 1.02k, False: 0]
  ------------------
 2495|  1.02k|	check1arg(args, call, "x");
  ------------------
  |  | 1867|  1.02k|# define check1arg		Rf_check1arg
  ------------------
 2496|  1.02k|	ans = ScalarLogical(anyNA(call, op, args, rho));
  ------------------
  |  | 1023|  1.02k|#define ScalarLogical		Rf_ScalarLogical
  ------------------
 2497|  1.02k|   } else {
 2498|       |	/* This is a primitive, so we manage argument matching ourselves.
 2499|       |	   But this takes a little time.
 2500|       |	 */
 2501|      0|	if (do_anyNA_formals == NULL)
  ------------------
  |  Branch (2501:6): [True: 0, False: 0]
  ------------------
 2502|      0|	    do_anyNA_formals = allocFormalsList2(install("x"),
  ------------------
  |  |  865|      0|#define allocFormalsList2	Rf_allocFormalsList2
  ------------------
              	    do_anyNA_formals = allocFormalsList2(install("x"),
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 2503|      0|						 R_RecursiveSymbol);
 2504|      0|	PROTECT(args = matchArgs_NR(do_anyNA_formals, args, call));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2505|      0|	if(CADR(args) ==  R_MissingArg) SETCADR(args, ScalarLogical(FALSE));
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  |  Branch (2505:5): [True: 0, False: 0]
  ------------------
 2506|      0|	ans = ScalarLogical(anyNA(call, op, args, rho));
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
 2507|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2508|      0|    }
 2509|  1.02k|    return ans;
 2510|  1.02k|}
do_isfinite:
 2563|  1.77k|{
 2564|  1.77k|    SEXP ans, x, names, dims;
 2565|  1.77k|    R_xlen_t i, n;
 2566|  1.77k|    int nprotect = 0;
 2567|       |
 2568|  1.77k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.77k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2569|  1.77k|    check1arg(args, call, "x");
  ------------------
  |  | 1867|  1.77k|# define check1arg		Rf_check1arg
  ------------------
 2570|       |
 2571|       |    /* DispatchOrEval internal generic: is.finite */
 2572|  1.77k|    if (DispatchOrEval(call, op, "is.finite", args, rho, &ans, 0, 1))
  ------------------
  |  | 1887|  1.77k|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (2572:9): [True: 0, False: 1.77k]
  ------------------
 2573|      0|	return(ans);
 2574|       |#ifdef stringent_is
 2575|       |    if (!isList(CAR(args)) && !isVector(CAR(args)))
 2576|       |	errorcall_return(call, "is.finite " R_MSG_list_vec);
 2577|       |#endif
 2578|  1.77k|    x = CAR(args);
 2579|  1.77k|    n = xlength(x);
  ------------------
  |  | 1049|  1.77k|#define xlength(x)		Rf_xlength(x)
  ------------------
 2580|  1.77k|    PROTECT(ans = allocVector(LGLSXP, n));
  ------------------
  |  |  357|  1.77k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2581|  1.77k|    nprotect++;
 2582|  1.77k|    int *pa = LOGICAL(ans);
 2583|  1.77k|    if (isVector(x)) {
  ------------------
  |  |  974|  1.77k|#define isVector		Rf_isVector
  ------------------
  |  Branch (2583:9): [True: 1.77k, False: 0]
  ------------------
 2584|  1.77k|	dims = getAttrib(x, R_DimSymbol);
  ------------------
  |  |  924|  1.77k|#define getAttrib		Rf_getAttrib
  ------------------
 2585|  1.77k|	if (isArray(x))
  ------------------
  |  |  940|  1.77k|#define isArray			Rf_isArray
  ------------------
  |  Branch (2585:6): [True: 0, False: 1.77k]
  ------------------
 2586|      0|	    PROTECT(names = getAttrib(x, R_DimNamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2587|  1.77k|	else
 2588|  1.77k|	    PROTECT(names = getAttrib(x, R_NamesSymbol));
  ------------------
  |  |  357|  1.77k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2589|  1.77k|	nprotect++;
 2590|  1.77k|    }
 2591|      0|    else dims = names = R_NilValue;
 2592|  1.77k|    switch (TYPEOF(x)) {
 2593|      0|    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2593:5): [True: 0, False: 1.77k]
  ------------------
 2594|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (2594:5): [True: 0, False: 1.77k]
  ------------------
 2595|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (2595:5): [True: 0, False: 1.77k]
  ------------------
 2596|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (2596:14): [True: 0, False: 0]
  ------------------
 2597|      0|	    pa[i] = 0;
 2598|      0|	break;
 2599|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2599:5): [True: 0, False: 1.77k]
  ------------------
 2600|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2600:5): [True: 0, False: 1.77k]
  ------------------
 2601|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (2601:14): [True: 0, False: 0]
  ------------------
 2602|      0|	    pa[i] = (INTEGER_ELT(x, i) != NA_INTEGER);
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
 2603|      0|	break;
 2604|  1.77k|    case REALSXP:
  ------------------
  |  |  124|  1.77k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (2604:5): [True: 1.77k, False: 0]
  ------------------
 2605|   618k|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (2605:14): [True: 617k, False: 1.77k]
  ------------------
 2606|   617k|	    pa[i] = R_FINITE(REAL_ELT(x, i));
  ------------------
  |  |   82|   617k|# define R_FINITE(x)    isfinite(x)
  ------------------
 2607|  1.77k|	break;
 2608|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (2608:5): [True: 0, False: 1.77k]
  ------------------
 2609|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (2609:14): [True: 0, False: 0]
  ------------------
 2610|      0|	    Rcomplex v = COMPLEX_ELT(x, i);
 2611|      0|	    pa[i] = (R_FINITE(v.r) && R_FINITE(v.i));
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
              	    pa[i] = (R_FINITE(v.r) && R_FINITE(v.i));
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (2611:15): [True: 0, False: 0]
  |  Branch (2611:32): [True: 0, False: 0]
  ------------------
 2612|      0|	}
 2613|      0|	break;
 2614|      0|    default:
  ------------------
  |  Branch (2614:5): [True: 0, False: 1.77k]
  ------------------
 2615|      0|	errorcall(call, _("default method not implemented for type '%s'"),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("default method not implemented for type '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2616|      0|		  R_typeToChar(x));
 2617|  1.77k|    }
 2618|  1.77k|    if (dims != R_NilValue)
  ------------------
  |  Branch (2618:9): [True: 0, False: 1.77k]
  ------------------
 2619|      0|	setAttrib(ans, R_DimSymbol, dims);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 2620|  1.77k|    if (names != R_NilValue) {
  ------------------
  |  Branch (2620:9): [True: 0, False: 1.77k]
  ------------------
 2621|      0|	if (isArray(x))
  ------------------
  |  |  940|      0|#define isArray			Rf_isArray
  ------------------
  |  Branch (2621:6): [True: 0, False: 0]
  ------------------
 2622|      0|	    setAttrib(ans, R_DimNamesSymbol, names);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 2623|      0|	else
 2624|      0|	    setAttrib(ans, R_NamesSymbol, names);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 2625|      0|    }
 2626|  1.77k|    UNPROTECT(nprotect);
  ------------------
  |  |  358|  1.77k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2627|  1.77k|    return ans;
 2628|  1.77k|}
do_docall:
 2734|  1.16k|{
 2735|  1.16k|    SEXP c, fun, names, envir;
 2736|  1.16k|    int i, n;
 2737|       |    /* RCNTXT *cptr; */
 2738|       |
 2739|  1.16k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.16k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2740|       |
 2741|  1.16k|    fun = CAR(args);
 2742|  1.16k|    envir = CADDR(args);
 2743|  1.16k|    args = CADR(args);
 2744|       |
 2745|       |    /* must be a string or a function
 2746|       |       zero-length string check used to be here but install gives
 2747|       |       better error message.
 2748|       |     */
 2749|  1.16k|    if(!(isFunction(fun) || (isString(fun) && length(fun) == 1)))
  ------------------
  |  |  948|  1.16k|#define isFunction		Rf_isFunction
  ------------------
                  if(!(isFunction(fun) || (isString(fun) && length(fun) == 1)))
  ------------------
  |  |  966|  1.16k|#define isString		Rf_isString
  ------------------
                  if(!(isFunction(fun) || (isString(fun) && length(fun) == 1)))
  ------------------
  |  |  987|  1.16k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (2749:10): [True: 0, False: 1.16k]
  |  Branch (2749:30): [True: 1.16k, False: 0]
  |  Branch (2749:47): [True: 1.16k, False: 0]
  ------------------
 2750|      0|	error(_("'what' must be a function or character string"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'what' must be a function or character string"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2751|       |
 2752|       |#ifdef __maybe_in_the_future__
 2753|       |    if (!isNull(args) && !isVectorList(args))
 2754|       |	error(_("'%s' must be a list or expression"), "args");
 2755|       |#else
 2756|  1.16k|    if (!isNull(args) && !isNewList(args))
  ------------------
  |  |  956|  1.16k|#define isNull			Rf_isNull
  ------------------
                  if (!isNull(args) && !isNewList(args))
  ------------------
  |  |  955|  1.16k|#define isNewList		Rf_isNewList
  ------------------
  |  Branch (2756:9): [True: 1.16k, False: 0]
  |  Branch (2756:26): [True: 0, False: 1.16k]
  ------------------
 2757|      0|	error(_("'%s' must be a list"), "args");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'%s' must be a list"), "args");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2758|  1.16k|#endif
 2759|       |
 2760|  1.16k|    if (!isEnvironment(envir))
  ------------------
  |  |  944|  1.16k|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (2760:9): [True: 0, False: 1.16k]
  ------------------
 2761|      0|	error(_("'envir' must be an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'envir' must be an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2762|       |
 2763|  1.16k|    n = length(args);
  ------------------
  |  |  987|  1.16k|#define length(x)		Rf_length(x)
  ------------------
 2764|  1.16k|    PROTECT(names = getAttrib(args, R_NamesSymbol));
  ------------------
  |  |  357|  1.16k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2765|       |
 2766|  1.16k|    PROTECT(c = call = allocLang(n + 1));
  ------------------
  |  |  357|  1.16k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2767|  1.16k|    if( isString(fun) ) {
  ------------------
  |  |  966|  1.16k|#define isString		Rf_isString
  ------------------
  |  Branch (2767:9): [True: 1.16k, False: 0]
  ------------------
 2768|  1.16k|	const char *str = translateChar(STRING_ELT(fun, 0));
  ------------------
  |  | 1037|  1.16k|#define translateChar		Rf_translateChar
  ------------------
 2769|  1.16k|	if (streql(str, ".Internal")) error("illegal usage");
  ------------------
  |  | 1498|  1.16k|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 1.16k]
  |  |  ------------------
  ------------------
              	if (streql(str, ".Internal")) error("illegal usage");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 2770|  1.16k|	SETCAR(c, install(str));
  ------------------
  |  |  934|  1.16k|#define install			Rf_install
  ------------------
 2771|  1.16k|    } else {
 2772|      0|	if(TYPEOF(fun) == SPECIALSXP && streql(PRIMNAME(fun), ".Internal"))
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
              	if(TYPEOF(fun) == SPECIALSXP && streql(PRIMNAME(fun), ".Internal"))
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (2772:5): [True: 0, False: 0]
  ------------------
 2773|      0|	    error("illegal usage");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 2774|      0|	SETCAR(c, fun);
 2775|      0|    }
 2776|  1.16k|    c = CDR(c);
 2777|  1.17k|    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (2777:17): [True: 14, False: 1.16k]
  ------------------
 2778|     14|#ifndef NEW
 2779|     14|	SETCAR(c, VECTOR_ELT(args, i));
 2780|       |#else
 2781|       |	SETCAR(c, mkPROMISE(VECTOR_ELT(args, i), rho));
 2782|       |	SET_PRVALUE(CAR(c), VECTOR_ELT(args, i));
 2783|       |#endif
 2784|     14|	if (ItemName(names, (int)i) != R_NilValue)
  ------------------
  |  | 1932|     14|# define ItemName		Rf_ItemName
  ------------------
  |  Branch (2784:6): [True: 0, False: 14]
  ------------------
 2785|      0|	    SET_TAG(c, installTrChar(ItemName(names, i)));
  ------------------
  |  |  937|      0|#define installTrChar		Rf_installTrChar
  ------------------
              	    SET_TAG(c, installTrChar(ItemName(names, i)));
  ------------------
  |  | 1932|      0|# define ItemName		Rf_ItemName
  ------------------
 2786|     14|	c = CDR(c);
 2787|     14|    }
 2788|  1.16k|    call = eval(call, envir);
  ------------------
  |  |  913|  1.16k|#define eval			Rf_eval
  ------------------
 2789|       |
 2790|  1.16k|    UNPROTECT(2); /* c, names */
  ------------------
  |  |  358|  1.16k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2791|  1.16k|    return call;
 2792|  1.16k|}
Rf_substitute:
 2808|  1.73k|{
 2809|  1.73k|    SEXP t;
 2810|  1.73k|    switch (TYPEOF(lang)) {
 2811|     64|    case PROMSXP:
  ------------------
  |  |  116|     64|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2811:5): [True: 64, False: 1.67k]
  ------------------
 2812|     64|	return substitute(PREXPR(lang), rho);
  ------------------
  |  | 1035|     64|#define substitute		Rf_substitute
  ------------------
              	return substitute(PREXPR(lang), rho);
  ------------------
  |  |  720|     64|#define PREXPR(e) R_PromiseExpr(e)
  ------------------
 2813|  1.57k|    case SYMSXP:
  ------------------
  |  |  112|  1.57k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (2813:5): [True: 1.57k, False: 168]
  ------------------
 2814|  1.57k|	if (rho != R_NilValue) {
  ------------------
  |  Branch (2814:6): [True: 1.50k, False: 64]
  ------------------
 2815|  1.50k|	    t = R_findVarInFrame( rho, lang);
 2816|  1.50k|	    if (t != R_UnboundValue) {
  ------------------
  |  Branch (2816:10): [True: 1.43k, False: 72]
  ------------------
 2817|  1.43k|		if (TYPEOF(t) == PROMSXP) {
  ------------------
  |  |  116|  1.43k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2817:7): [True: 1.43k, False: 0]
  ------------------
 2818|  1.43k|		    do {
 2819|  1.43k|			t = PREXPR(t);
  ------------------
  |  |  720|  1.43k|#define PREXPR(e) R_PromiseExpr(e)
  ------------------
 2820|  1.43k|		    } while(TYPEOF(t) == PROMSXP);
  ------------------
  |  |  116|  1.43k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2820:15): [True: 0, False: 1.43k]
  ------------------
 2821|       |		    /* make sure code will not be modified: */
 2822|  1.43k|		    ENSURE_NAMEDMAX(t);
 2823|  1.43k|		    return t;
 2824|  1.43k|		}
 2825|      0|		else if (TYPEOF(t) == DOTSXP)
  ------------------
  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (2825:12): [True: 0, False: 0]
  ------------------
 2826|      0|		    error(_("'...' used in an incorrect context"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("'...' used in an incorrect context"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2827|      0|		if (rho != R_GlobalEnv)
  ------------------
  |  Branch (2827:7): [True: 0, False: 0]
  ------------------
 2828|      0|		    return t;
 2829|      0|	    }
 2830|  1.50k|	}
 2831|    136|	return (lang);
 2832|     88|    case LANGSXP:
  ------------------
  |  |  117|     88|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (2832:5): [True: 88, False: 1.65k]
  ------------------
 2833|     88|	return substituteList(lang, rho);
  ------------------
  |  | 1996|     88|# define substituteList		Rf_substituteList
  ------------------
 2834|     16|    default:
  ------------------
  |  Branch (2834:5): [True: 16, False: 1.72k]
  ------------------
 2835|     16|	return (lang);
 2836|  1.73k|    }
 2837|  1.73k|}
Rf_substituteList:
 2844|  1.48k|{
 2845|  1.48k|    SEXP h, p = R_NilValue, res = R_NilValue;
 2846|       |
 2847|  1.48k|    if (isNull(el)) return el;
  ------------------
  |  |  956|  1.48k|#define isNull			Rf_isNull
  ------------------
  |  Branch (2847:9): [True: 0, False: 1.48k]
  ------------------
 2848|       |
 2849|  3.13k|    while (el != R_NilValue) {
  ------------------
  |  Branch (2849:12): [True: 1.64k, False: 1.48k]
  ------------------
 2850|       |	/* walk along the pairlist, substituting elements.
 2851|       |	   res is the result
 2852|       |	   p is the current last element
 2853|       |	   h is the element currently being processed
 2854|       |	 */
 2855|  1.64k|	if (CAR(el) == R_DotsSymbol) {
  ------------------
  |  Branch (2855:6): [True: 0, False: 1.64k]
  ------------------
 2856|      0|	    if (rho == R_NilValue)
  ------------------
  |  Branch (2856:10): [True: 0, False: 0]
  ------------------
 2857|      0|		h = R_UnboundValue;	/* so there is no substitution below */
 2858|      0|	    else
 2859|      0|		h = R_findVarInFrame(rho, CAR(el));
 2860|      0|	    if (h == R_UnboundValue)
  ------------------
  |  Branch (2860:10): [True: 0, False: 0]
  ------------------
 2861|      0|		h = LCONS(R_DotsSymbol, R_NilValue);
  ------------------
  |  |  310|      0|#define LCONS(a, b)	Rf_lcons((a), (b))		/* language lists */
  ------------------
 2862|      0|	    else if (h == R_NilValue  || h == R_MissingArg)
  ------------------
  |  Branch (2862:15): [True: 0, False: 0]
  |  Branch (2862:35): [True: 0, False: 0]
  ------------------
 2863|      0|		h = R_NilValue;
 2864|      0|	    else if (TYPEOF(h) == DOTSXP) {
  ------------------
  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (2864:15): [True: 0, False: 0]
  ------------------
 2865|      0|		PROTECT(h);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2866|      0|		h = substituteList(h, R_NilValue);
  ------------------
  |  | 1996|      0|# define substituteList		Rf_substituteList
  ------------------
 2867|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2868|      0|	    } else
 2869|      0|		error(_("'...' used in an incorrect context"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("'...' used in an incorrect context"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2870|  1.64k|	} else {
 2871|  1.64k|	    h = substitute(CAR(el), rho);
  ------------------
  |  | 1035|  1.64k|#define substitute		Rf_substitute
  ------------------
 2872|  1.64k|	    ENSURE_NAMEDMAX(h);
 2873|  1.64k|	    if (isLanguage(el))
  ------------------
  |  |  950|  1.64k|#define isLanguage		Rf_isLanguage
  ------------------
  |  Branch (2873:10): [True: 88, False: 1.55k]
  ------------------
 2874|     88|		h = LCONS(h, R_NilValue);
  ------------------
  |  |  310|     88|#define LCONS(a, b)	Rf_lcons((a), (b))		/* language lists */
  ------------------
 2875|  1.55k|	    else
 2876|  1.55k|		h = CONS(h, R_NilValue);
  ------------------
  |  |  309|  1.55k|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 2877|  1.64k|	    SET_TAG(h, TAG(el));
 2878|  1.64k|	}
 2879|  1.64k|	if (h != R_NilValue) {
  ------------------
  |  Branch (2879:6): [True: 1.64k, False: 0]
  ------------------
 2880|  1.64k|	    if (res == R_NilValue)
  ------------------
  |  Branch (2880:10): [True: 1.48k, False: 156]
  ------------------
 2881|  1.48k|		PROTECT(res = h);
  ------------------
  |  |  357|  1.48k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2882|    156|	    else
 2883|    156|		SETCDR(p, h);
 2884|       |	    /* now set 'p': dots might have expanded to a list of length > 1 */
 2885|  1.64k|	    while (CDR(h) != R_NilValue) h = CDR(h);
  ------------------
  |  Branch (2885:13): [True: 0, False: 1.64k]
  ------------------
 2886|  1.64k|	    p = h;
 2887|  1.64k|	}
 2888|  1.64k|	el = CDR(el);
 2889|  1.64k|    }
 2890|  1.48k|    if(res != R_NilValue) UNPROTECT(1);
  ------------------
  |  |  358|  1.48k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  |  Branch (2890:8): [True: 1.48k, False: 0]
  ------------------
 2891|  1.48k|    return res;
 2892|  1.48k|}
do_substitute:
 2897|  1.39k|{
 2898|  1.39k|    SEXP argList, env, s, t;
 2899|  1.39k|    static SEXP do_substitute_formals = NULL;
 2900|       |
 2901|  1.39k|    if (do_substitute_formals == NULL)
  ------------------
  |  Branch (2901:9): [True: 2, False: 1.39k]
  ------------------
 2902|      2|	do_substitute_formals = allocFormalsList2(install("expr"),
  ------------------
  |  |  865|      2|#define allocFormalsList2	Rf_allocFormalsList2
  ------------------
              	do_substitute_formals = allocFormalsList2(install("expr"),
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 2903|      2|						  install("env"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 2904|       |
 2905|       |    /* argument matching */
 2906|  1.39k|    PROTECT(argList = matchArgs_NR(do_substitute_formals, args, call));
  ------------------
  |  |  357|  1.39k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2907|       |
 2908|       |    /* set up the environment for substitution */
 2909|  1.39k|    if (CADR(argList) == R_MissingArg)
  ------------------
  |  Branch (2909:9): [True: 1.39k, False: 0]
  ------------------
 2910|  1.39k|	env = rho;
 2911|      0|    else
 2912|      0|	env = eval(CADR(argList), rho);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 2913|  1.39k|    if (env == R_GlobalEnv)	/* For historical reasons, don't substitute in R_GlobalEnv */
  ------------------
  |  Branch (2913:9): [True: 0, False: 1.39k]
  ------------------
 2914|      0|	env = R_NilValue;
 2915|  1.39k|    else if (TYPEOF(env) == VECSXP)
  ------------------
  |  |  131|  1.39k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2915:14): [True: 0, False: 1.39k]
  ------------------
 2916|      0|	env = NewEnvironment(R_NilValue, VectorToPairList(env), R_BaseEnv);
  ------------------
  |  | 1961|      0|# define NewEnvironment		Rf_NewEnvironment
  ------------------
              	env = NewEnvironment(R_NilValue, VectorToPairList(env), R_BaseEnv);
  ------------------
  |  | 1046|      0|#define VectorToPairList	Rf_VectorToPairList
  ------------------
 2917|  1.39k|    else if (TYPEOF(env) == LISTSXP)
  ------------------
  |  |  113|  1.39k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2917:14): [True: 0, False: 1.39k]
  ------------------
 2918|      0|	env = NewEnvironment(R_NilValue, duplicate(env), R_BaseEnv);
  ------------------
  |  | 1961|      0|# define NewEnvironment		Rf_NewEnvironment
  ------------------
              	env = NewEnvironment(R_NilValue, duplicate(env), R_BaseEnv);
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 2919|  1.39k|    if (env != R_NilValue && TYPEOF(env) != ENVSXP)
  ------------------
  |  |  115|  1.39k|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (2919:9): [True: 1.39k, False: 0]
  |  Branch (2919:30): [True: 0, False: 1.39k]
  ------------------
 2920|      0|	errorcall(call, _("invalid environment specified"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid environment specified"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2921|       |
 2922|  1.39k|    PROTECT(env);
  ------------------
  |  |  357|  1.39k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2923|  1.39k|    PROTECT(t = CONS(duplicate(CAR(argList)), R_NilValue));
  ------------------
  |  |  357|  1.39k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2924|  1.39k|    s = substituteList(t, env);
  ------------------
  |  | 1996|  1.39k|# define substituteList		Rf_substituteList
  ------------------
 2925|  1.39k|    UNPROTECT(3);
  ------------------
  |  |  358|  1.39k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2926|  1.39k|    return CAR(s);
 2927|  1.39k|}
do_quote:
 2931|   385k|{
 2932|   385k|    checkArity(op, args);
  ------------------
  |  | 1788|   385k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2933|   385k|    check1arg(args, call, "expr");
  ------------------
  |  | 1867|   385k|# define check1arg		Rf_check1arg
  ------------------
 2934|   385k|    SEXP val = CAR(args);
 2935|       |    /* Make sure expression has NAMED == NAMEDMAX before being returning
 2936|       |       in order to avoid modification of source code */
 2937|   385k|    ENSURE_NAMEDMAX(val);
 2938|   385k|    return(val);
 2939|   385k|}
R_do_set_class:
 3093|     85|{
 3094|     85|    checkArity(op, args);
  ------------------
  |  | 1788|     85|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 3095|     85|    check1arg(args, call, "x");
  ------------------
  |  | 1867|     85|# define check1arg		Rf_check1arg
  ------------------
 3096|       |
 3097|     85|    if (MAYBE_SHARED(CAR(args)) ||
  ------------------
  |  Branch (3097:9): [True: 0, False: 85]
  ------------------
 3098|     85|	((! IS_ASSIGNMENT_CALL(call)) && MAYBE_REFERENCED(CAR(args))))
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (3098:3): [True: 0, False: 85]
  ------------------
 3099|      0|	SETCAR(args, shallow_duplicate(CAR(args)));
  ------------------
  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 3100|     85|    SEXP ans = R_set_class(CAR(args), CADR(args), call);
 3101|     85|    SETTER_CLEAR_NAMED(CAR(args));
 3102|     85|    return ans;
 3103|     85|}
coerce.c:coercePairList:
  971|     99|{
  972|     99|    SEXP rval= R_NilValue, vp;
  973|     99|    if (type == EXPRSXP) {
  ------------------
  |  |  132|     99|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (973:9): [True: 0, False: 99]
  ------------------
  974|      0|	PROTECT(rval = allocVector(type, 1));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  975|      0|	SET_VECTOR_ELT(rval, 0, v);
  976|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  977|      0|	return rval;
  978|      0|    }
  979|     99|    else if (type == STRSXP) {
  ------------------
  |  |  126|     99|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (979:14): [True: 12, False: 87]
  ------------------
  980|     12|	int i, n = length(v);
  ------------------
  |  |  987|     12|#define length(x)		Rf_length(x)
  ------------------
  981|     12|	PROTECT(rval = allocVector(type, n));
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
  982|     12|	for (vp = v, i = 0; vp != R_NilValue; vp = CDR(vp), i++) {
  ------------------
  |  Branch (982:22): [True: 0, False: 12]
  ------------------
  983|      0|	    if (isString(CAR(vp)) && length(CAR(vp)) == 1)
  ------------------
  |  |  966|      0|#define isString		Rf_isString
  ------------------
              	    if (isString(CAR(vp)) && length(CAR(vp)) == 1)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (983:10): [True: 0, False: 0]
  |  Branch (983:31): [True: 0, False: 0]
  ------------------
  984|      0|		SET_STRING_ELT(rval, i, STRING_ELT(CAR(vp), 0));
  985|      0|	    else
  986|      0|		SET_STRING_ELT(rval, i, STRING_ELT(deparse1line(CAR(vp), false), 0));
  ------------------
  |  | 1884|      0|# define deparse1line		Rf_deparse1line
  ------------------
  987|      0|	}
  988|     12|    }
  989|     87|    else if (type == VECSXP) {
  ------------------
  |  |  131|     87|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (989:14): [True: 87, False: 0]
  ------------------
  990|     87|	rval = PairToVectorList(v);
  ------------------
  |  | 1010|     87|#define PairToVectorList	Rf_PairToVectorList
  ------------------
  991|     87|	return rval;
  992|     87|    }
  993|      0|    else if (isVectorizable(v)) {
  ------------------
  |  |  976|      0|#define isVectorizable		Rf_isVectorizable
  ------------------
  |  Branch (993:14): [True: 0, False: 0]
  ------------------
  994|      0|	int i, n = length(v);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  995|      0|	PROTECT(rval = allocVector(type, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  996|      0|	switch (type) {
  997|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (997:2): [True: 0, False: 0]
  ------------------
  998|      0|	    for (i = 0, vp = v; i < n; i++, vp = CDR(vp))
  ------------------
  |  Branch (998:26): [True: 0, False: 0]
  ------------------
  999|      0|		LOGICAL0(rval)[i] = asLogical(CAR(vp));
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
 1000|      0|	    break;
 1001|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1001:2): [True: 0, False: 0]
  ------------------
 1002|      0|	    for (i = 0, vp = v; i < n; i++, vp = CDR(vp))
  ------------------
  |  Branch (1002:26): [True: 0, False: 0]
  ------------------
 1003|      0|		INTEGER0(rval)[i] = asInteger(CAR(vp));
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
 1004|      0|	    break;
 1005|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1005:2): [True: 0, False: 0]
  ------------------
 1006|      0|	    for (i = 0, vp = v; i < n; i++, vp = CDR(vp))
  ------------------
  |  Branch (1006:26): [True: 0, False: 0]
  ------------------
 1007|      0|		REAL0(rval)[i] = asReal(CAR(vp));
  ------------------
  |  |  889|      0|#define asReal			Rf_asReal
  ------------------
 1008|      0|	    break;
 1009|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1009:2): [True: 0, False: 0]
  ------------------
 1010|      0|	    for (i = 0, vp = v; i < n; i++, vp = CDR(vp))
  ------------------
  |  Branch (1010:26): [True: 0, False: 0]
  ------------------
 1011|      0|		COMPLEX0(rval)[i] = asComplex(CAR(vp));
  ------------------
  |  |  884|      0|#define asComplex		Rf_asComplex
  ------------------
 1012|      0|	    break;
 1013|      0|	case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1013:2): [True: 0, False: 0]
  ------------------
 1014|      0|	    for (i = 0, vp = v; i < n; i++, vp = CDR(vp))
  ------------------
  |  Branch (1014:26): [True: 0, False: 0]
  ------------------
 1015|      0|		RAW0(rval)[i] = (Rbyte) asInteger(CAR(vp));
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
 1016|      0|	    break;
 1017|      0|	default:
  ------------------
  |  Branch (1017:2): [True: 0, False: 0]
  ------------------
 1018|      0|	    UNIMPLEMENTED_TYPE("coercePairList", v);
 1019|      0|	}
 1020|      0|    }
 1021|      0|    else
 1022|      0|	error(_("'%s' object cannot be coerced to type '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'%s' object cannot be coerced to type '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1023|      0|	      R_typeToChar(v), type2char(type));
  ------------------
  |  | 1040|      0|#define type2char		Rf_type2char
  ------------------
 1024|       |
 1025|       |    /* If any tags are non-null then we */
 1026|       |    /* need to add a names attribute. */
 1027|     12|    bool has_nms = false;
 1028|     12|    for (vp = v; vp != R_NilValue; vp = CDR(vp))
  ------------------
  |  Branch (1028:18): [True: 0, False: 12]
  ------------------
 1029|      0|	if (TAG(vp) != R_NilValue) {
  ------------------
  |  Branch (1029:6): [True: 0, False: 0]
  ------------------
 1030|      0|	    has_nms = true;
 1031|      0|	    break;
 1032|      0|	}
 1033|       |
 1034|     12|    if (has_nms) {
  ------------------
  |  Branch (1034:9): [True: 0, False: 12]
  ------------------
 1035|      0|	SEXP names = allocVector(STRSXP, length(v));
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	SEXP names = allocVector(STRSXP, length(v));
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
              	SEXP names = allocVector(STRSXP, length(v));
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 1036|      0|	int i;
 1037|      0|	for (vp = v, i = 0; vp != R_NilValue; vp = CDR(vp), i++)
  ------------------
  |  Branch (1037:22): [True: 0, False: 0]
  ------------------
 1038|      0|	    if (TAG(vp) != R_NilValue)
  ------------------
  |  Branch (1038:10): [True: 0, False: 0]
  ------------------
 1039|      0|		SET_STRING_ELT(names, i, PRINTNAME(TAG(vp)));
 1040|      0|	setAttrib(rval, R_NamesSymbol, names);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 1041|      0|    }
 1042|     12|    UNPROTECT(1);
  ------------------
  |  |  358|     12|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1043|     12|    return rval;
 1044|     99|}
coerce.c:coerceVectorList:
 1048|     27|{
 1049|     27|    int warn = 0, tmp;
 1050|     27|    R_xlen_t i, n;
 1051|     27|    SEXP rval, names;
 1052|       |
 1053|     27|    names = v;
 1054|     27|    rval = R_NilValue;	/* -Wall */
 1055|       |
 1056|       |    /* expression -> list, new in R 2.4.0 */
 1057|     27|    if (type == VECSXP && TYPEOF(v) == EXPRSXP) {
  ------------------
  |  |  131|     54|#define VECSXP	    19	  /* generic vectors */
  ------------------
                  if (type == VECSXP && TYPEOF(v) == EXPRSXP) {
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1057:9): [True: 0, False: 27]
  |  Branch (1057:27): [True: 0, False: 0]
  ------------------
 1058|       |	/* This is sneaky but saves us rewriting a lot of the duplicate code */
 1059|      0|	rval = MAYBE_REFERENCED(v) ? duplicate(v) : v;
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	rval = MAYBE_REFERENCED(v) ? duplicate(v) : v;
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 1060|      0|	SET_TYPEOF(rval, VECSXP);
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
 1061|      0|	return rval;
 1062|      0|    }
 1063|       |
 1064|     27|    if (type == EXPRSXP && TYPEOF(v) == VECSXP) {
  ------------------
  |  |  132|     54|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
                  if (type == EXPRSXP && TYPEOF(v) == VECSXP) {
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1064:9): [True: 0, False: 27]
  |  Branch (1064:28): [True: 0, False: 0]
  ------------------
 1065|      0|	rval = MAYBE_REFERENCED(v) ? duplicate(v) : v;
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	rval = MAYBE_REFERENCED(v) ? duplicate(v) : v;
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 1066|      0|	SET_TYPEOF(rval, EXPRSXP);
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
 1067|      0|	return rval;
 1068|      0|    }
 1069|       |
 1070|     27|    if (type == STRSXP) {
  ------------------
  |  |  126|     27|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1070:9): [True: 16, False: 11]
  ------------------
 1071|     16|	n = xlength(v);
  ------------------
  |  | 1049|     16|#define xlength(x)		Rf_xlength(x)
  ------------------
 1072|     16|	PROTECT(rval = allocVector(type, n));
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1073|       |#ifdef R_MEMORY_PROFILING
 1074|       |	if (RTRACE(v)){
 1075|       |	   memtrace_report(v, rval);
 1076|       |	   SET_RTRACE(rval,1);
 1077|       |	}
 1078|       |#endif
 1079|     48|	for (i = 0; i < n;  i++) {
  ------------------
  |  Branch (1079:14): [True: 32, False: 16]
  ------------------
 1080|     32|	    if (isString(VECTOR_ELT(v, i)) && xlength(VECTOR_ELT(v, i)) == 1)
  ------------------
  |  |  966|     32|#define isString		Rf_isString
  ------------------
              	    if (isString(VECTOR_ELT(v, i)) && xlength(VECTOR_ELT(v, i)) == 1)
  ------------------
  |  | 1049|     32|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (1080:10): [True: 32, False: 0]
  |  Branch (1080:40): [True: 32, False: 0]
  ------------------
 1081|     32|		SET_STRING_ELT(rval, i, STRING_ELT(VECTOR_ELT(v, i), 0));
 1082|       |#if 0
 1083|       |	    /* this will make as.character(list(s)) not backquote
 1084|       |	     * non-syntactic name s. It is not entirely clear that
 1085|       |	     * that is really desirable though....
 1086|       |	     */
 1087|       |	    else if (isSymbol(VECTOR_ELT(v, i)))
 1088|       |		SET_STRING_ELT(rval, i, PRINTNAME(VECTOR_ELT(v, i)));
 1089|       |#endif
 1090|      0|	    else
 1091|      0|		SET_STRING_ELT(rval, i,
 1092|      0|			       STRING_ELT(deparse1line_ex(VECTOR_ELT(v, i),
 1093|      0|							  false, NICE_NAMES),
  ------------------
  |  | 2078|      0|#define NICE_NAMES             	1024
  ------------------
 1094|      0|					  0));
 1095|     32|	}
 1096|     16|    }
 1097|     11|    else if (type == LISTSXP) {
  ------------------
  |  |  113|     11|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1097:14): [True: 0, False: 11]
  ------------------
 1098|      0|	rval = VectorToPairList(v);
  ------------------
  |  | 1046|      0|#define VectorToPairList	Rf_VectorToPairList
  ------------------
 1099|      0|	return rval;
 1100|      0|    }
 1101|     11|    else if (isVectorizable(v)) {
  ------------------
  |  |  976|     11|#define isVectorizable		Rf_isVectorizable
  ------------------
  |  Branch (1101:14): [True: 11, False: 0]
  ------------------
 1102|     11|	n = xlength(v);
  ------------------
  |  | 1049|     11|#define xlength(x)		Rf_xlength(x)
  ------------------
 1103|     11|	PROTECT(rval = allocVector(type, n));
  ------------------
  |  |  357|     11|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1104|     11|	switch (type) {
 1105|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1105:2): [True: 0, False: 11]
  ------------------
 1106|      0|	    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (1106:18): [True: 0, False: 0]
  ------------------
 1107|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
 1108|      0|		LOGICAL0(rval)[i] = asLogical(VECTOR_ELT(v, i));
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
 1109|      0|	    }
 1110|      0|	    break;
 1111|     11|	case INTSXP:
  ------------------
  |  |  123|     11|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1111:2): [True: 11, False: 0]
  ------------------
 1112|    239|	    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (1112:18): [True: 228, False: 11]
  ------------------
 1113|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
 1114|    228|		INTEGER0(rval)[i] = asInteger(VECTOR_ELT(v, i));
  ------------------
  |  |  885|    228|#define asInteger		Rf_asInteger
  ------------------
 1115|    228|	    }
 1116|     11|	    break;
 1117|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1117:2): [True: 0, False: 11]
  ------------------
 1118|      0|	    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (1118:18): [True: 0, False: 0]
  ------------------
 1119|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
 1120|      0|		REAL0(rval)[i] = asReal(VECTOR_ELT(v, i));
  ------------------
  |  |  889|      0|#define asReal			Rf_asReal
  ------------------
 1121|      0|	    }
 1122|      0|	    break;
 1123|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1123:2): [True: 0, False: 11]
  ------------------
 1124|      0|	    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (1124:18): [True: 0, False: 0]
  ------------------
 1125|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
 1126|      0|		COMPLEX0(rval)[i] = asComplex(VECTOR_ELT(v, i));
  ------------------
  |  |  884|      0|#define asComplex		Rf_asComplex
  ------------------
 1127|      0|	    }
 1128|      0|	    break;
 1129|      0|	case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1129:2): [True: 0, False: 11]
  ------------------
 1130|      0|	    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (1130:18): [True: 0, False: 0]
  ------------------
 1131|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
 1132|      0|		tmp = asInteger(VECTOR_ELT(v, i));
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
 1133|      0|		if (tmp < 0 || tmp > 255) { /* includes NA_INTEGER */
  ------------------
  |  Branch (1133:7): [True: 0, False: 0]
  |  Branch (1133:18): [True: 0, False: 0]
  ------------------
 1134|      0|		    tmp = 0;
 1135|      0|		    warn |= WARN_RAW;
  ------------------
  |  |   51|      0|#define WARN_RAW  8
  ------------------
 1136|      0|		}
 1137|      0|		RAW0(rval)[i] = (Rbyte) tmp;
 1138|      0|	    }
 1139|      0|	    break;
 1140|      0|	default:
  ------------------
  |  Branch (1140:2): [True: 0, False: 11]
  ------------------
 1141|      0|	    UNIMPLEMENTED_TYPE("coerceVectorList", v);
 1142|     11|	}
 1143|     11|    }
 1144|      0|    else
 1145|      0|	error(_("'%s' object cannot be coerced to type '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'%s' object cannot be coerced to type '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1146|      0|	      "list", type2char(type));
  ------------------
  |  | 1040|      0|#define type2char		Rf_type2char
  ------------------
 1147|       |
 1148|     27|    if (warn) CoercionWarning(warn);
  ------------------
  |  | 1870|      0|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
  |  Branch (1148:9): [True: 0, False: 27]
  ------------------
 1149|     27|    names = getAttrib(v, R_NamesSymbol);
  ------------------
  |  |  924|     27|#define getAttrib		Rf_getAttrib
  ------------------
 1150|     27|    if (names != R_NilValue)
  ------------------
  |  Branch (1150:9): [True: 16, False: 11]
  ------------------
 1151|     16|	setAttrib(rval, R_NamesSymbol, names);
  ------------------
  |  | 1027|     16|#define setAttrib		Rf_setAttrib
  ------------------
 1152|     27|    UNPROTECT(1);
  ------------------
  |  |  358|     27|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1153|     27|    return rval;
 1154|     27|}
coerce.c:coerceToSymbol:
  417|  1.13k|{
  418|  1.13k|    SEXP ans = R_NilValue;
  419|  1.13k|    int warn = 0;
  420|  1.13k|    if (length(v) <= 0)
  ------------------
  |  |  987|  1.13k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (420:9): [True: 0, False: 1.13k]
  ------------------
  421|      0|	error(_("invalid data of mode '%s' (too short)"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid data of mode '%s' (too short)"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  422|      0|	      R_typeToChar(v));
  423|  1.13k|    PROTECT(v);
  ------------------
  |  |  357|  1.13k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  424|  1.13k|    switch(TYPEOF(v)) {
  425|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (425:5): [True: 0, False: 1.13k]
  ------------------
  426|      0|	ans = StringFromLogical(LOGICAL_ELT(v, 0));
  ------------------
  |  | 1991|      0|# define StringFromLogical	Rf_StringFromLogical
  ------------------
  427|      0|	break;
  428|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (428:5): [True: 0, False: 1.13k]
  ------------------
  429|      0|	ans = StringFromInteger(INTEGER_ELT(v, 0), &warn);
  ------------------
  |  | 1990|      0|# define StringFromInteger	Rf_StringFromInteger
  ------------------
  430|      0|	break;
  431|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (431:5): [True: 0, False: 1.13k]
  ------------------
  432|      0|	ans = StringFromReal(REAL_ELT(v, 0), &warn);
  ------------------
  |  | 1992|      0|# define StringFromReal		Rf_StringFromReal
  ------------------
  433|      0|	break;
  434|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (434:5): [True: 0, False: 1.13k]
  ------------------
  435|      0|	ans = StringFromComplex(COMPLEX_ELT(v, 0), &warn);
  ------------------
  |  | 1989|      0|# define StringFromComplex	Rf_StringFromComplex
  ------------------
  436|      0|	break;
  437|  1.13k|    case STRSXP:
  ------------------
  |  |  126|  1.13k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (437:5): [True: 1.13k, False: 0]
  ------------------
  438|  1.13k|	ans = STRING_ELT(v, 0);
  439|  1.13k|	break;
  440|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (440:5): [True: 0, False: 1.13k]
  ------------------
  441|      0|	ans = StringFromRaw(RAW_ELT(v, 0), &warn);
  442|      0|	break;
  443|      0|    default:
  ------------------
  |  Branch (443:5): [True: 0, False: 1.13k]
  ------------------
  444|      0|	UNIMPLEMENTED_TYPE("coerceToSymbol", v);
  445|  1.13k|    }
  446|  1.13k|    PROTECT(ans);
  ------------------
  |  |  357|  1.13k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  447|  1.13k|    if (warn) CoercionWarning(warn);/*2000/10/23*/
  ------------------
  |  | 1870|      0|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
  |  Branch (447:9): [True: 0, False: 1.13k]
  ------------------
  448|  1.13k|    ans = installTrChar(ans);
  ------------------
  |  |  937|  1.13k|#define installTrChar		Rf_installTrChar
  ------------------
  449|  1.13k|    UNPROTECT(2); /* ans, v */
  ------------------
  |  |  358|  1.13k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  450|  1.13k|    return ans;
  451|  1.13k|}
coerce.c:coerceToLogical:
  454|     12|{
  455|     12|    SEXP ans;
  456|     12|    int warn = 0;
  457|     12|    R_xlen_t i, n;
  458|     12|    PROTECT(ans = allocVector(LGLSXP, n = XLENGTH(v)));
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
  459|     12|    int *pa = LOGICAL(ans);
  460|       |#ifdef R_MEMORY_PROFILING
  461|       |    if (RTRACE(v)){
  462|       |       memtrace_report(v,ans);
  463|       |       SET_RTRACE(ans,1);
  464|       |    }
  465|       |#endif
  466|     12|    SHALLOW_DUPLICATE_ATTRIB(ans, v);
  ------------------
  |  |   58|     12|#define SHALLOW_DUPLICATE_ATTRIB(to, from) do {\
  |  |   59|     12|  SEXP __from__ = (from); \
  |  |   60|     12|  if (ATTRIB(__from__) != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (60:7): [True: 12, False: 0]
  |  |  ------------------
  |  |   61|     12|    SEXP __to__ = (to); \
  |  |   62|     12|    (SHALLOW_DUPLICATE_ATTRIB)(__to__, __from__);	\
  |  |   63|     12|  } \
  |  |   64|     12|} while (0)
  |  |  ------------------
  |  |  |  Branch (64:10): [Folded, False: 12]
  |  |  ------------------
  ------------------
  467|     12|    switch (TYPEOF(v)) {
  468|     12|    case INTSXP:
  ------------------
  |  |  123|     12|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (468:5): [True: 12, False: 0]
  ------------------
  469|     48|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (469:14): [True: 36, False: 12]
  ------------------
  470|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  471|     36|	    pa[i] = LogicalFromInteger(INTEGER_ELT(v, i), &warn);
  ------------------
  |  | 1937|     36|# define LogicalFromInteger	Rf_LogicalFromInteger
  ------------------
  472|     36|	}
  473|     12|	break;
  474|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (474:5): [True: 0, False: 12]
  ------------------
  475|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (475:14): [True: 0, False: 0]
  ------------------
  476|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  477|      0|	    pa[i] = LogicalFromReal(REAL_ELT(v, i), &warn);
  ------------------
  |  | 1938|      0|# define LogicalFromReal	Rf_LogicalFromReal
  ------------------
  478|      0|	}
  479|      0|	break;
  480|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (480:5): [True: 0, False: 12]
  ------------------
  481|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (481:14): [True: 0, False: 0]
  ------------------
  482|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  483|      0|	    pa[i] = LogicalFromComplex(COMPLEX_ELT(v, i), &warn);
  ------------------
  |  | 1936|      0|# define LogicalFromComplex	Rf_LogicalFromComplex
  ------------------
  484|      0|	}
  485|      0|	break;
  486|      0|    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (486:5): [True: 0, False: 12]
  ------------------
  487|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (487:14): [True: 0, False: 0]
  ------------------
  488|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  489|      0|	    pa[i] = LogicalFromString(STRING_ELT(v, i), &warn);
  ------------------
  |  | 1939|      0|# define LogicalFromString	Rf_LogicalFromString
  ------------------
  490|      0|	}
  491|      0|	break;
  492|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (492:5): [True: 0, False: 12]
  ------------------
  493|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (493:14): [True: 0, False: 0]
  ------------------
  494|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  495|      0|	    pa[i] = LogicalFromInteger((int)RAW_ELT(v, i), &warn);
  ------------------
  |  | 1937|      0|# define LogicalFromInteger	Rf_LogicalFromInteger
  ------------------
  496|      0|	}
  497|      0|	break;
  498|      0|    default:
  ------------------
  |  Branch (498:5): [True: 0, False: 12]
  ------------------
  499|      0|	UNIMPLEMENTED_TYPE("coerceToLogical", v);
  500|     12|    }
  501|     12|    if (warn) CoercionWarning(warn);
  ------------------
  |  | 1870|      0|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
  |  Branch (501:9): [True: 0, False: 12]
  ------------------
  502|     12|    UNPROTECT(1);
  ------------------
  |  |  358|     12|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  503|     12|    return ans;
  504|     12|}
coerce.c:coerceToInteger:
  507|  2.43k|{
  508|  2.43k|    SEXP ans;
  509|  2.43k|    int warn = 0;
  510|  2.43k|    R_xlen_t i, n;
  511|  2.43k|    PROTECT(ans = allocVector(INTSXP, n = XLENGTH(v)));
  ------------------
  |  |  357|  2.43k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  512|  2.43k|    int *pa = INTEGER(ans);
  513|       |#ifdef R_MEMORY_PROFILING
  514|       |    if (RTRACE(v)){
  515|       |       memtrace_report(v,ans);
  516|       |       SET_RTRACE(ans,1);
  517|       |    }
  518|       |#endif
  519|  2.43k|    SHALLOW_DUPLICATE_ATTRIB(ans, v);
  ------------------
  |  |   58|  2.43k|#define SHALLOW_DUPLICATE_ATTRIB(to, from) do {\
  |  |   59|  2.43k|  SEXP __from__ = (from); \
  |  |   60|  2.43k|  if (ATTRIB(__from__) != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (60:7): [True: 0, False: 2.43k]
  |  |  ------------------
  |  |   61|      0|    SEXP __to__ = (to); \
  |  |   62|      0|    (SHALLOW_DUPLICATE_ATTRIB)(__to__, __from__);	\
  |  |   63|      0|  } \
  |  |   64|  2.43k|} while (0)
  |  |  ------------------
  |  |  |  Branch (64:10): [Folded, False: 2.43k]
  |  |  ------------------
  ------------------
  520|  2.43k|    switch (TYPEOF(v)) {
  521|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (521:5): [True: 0, False: 2.43k]
  ------------------
  522|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (522:14): [True: 0, False: 0]
  ------------------
  523|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  524|      0|	    pa[i] = IntegerFromLogical(LOGICAL_ELT(v, i), &warn);
  ------------------
  |  | 1926|      0|# define IntegerFromLogical	Rf_IntegerFromLogical
  ------------------
  525|      0|	}
  526|      0|	break;
  527|  2.35k|    case REALSXP:
  ------------------
  |  |  124|  2.35k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (527:5): [True: 2.35k, False: 85]
  ------------------
  528|  4.70k|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (528:14): [True: 2.35k, False: 2.35k]
  ------------------
  529|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  530|  2.35k|	    pa[i] = IntegerFromReal(REAL_ELT(v, i), &warn);
  ------------------
  |  | 1927|  2.35k|# define IntegerFromReal	Rf_IntegerFromReal
  ------------------
  531|  2.35k|	}
  532|  2.35k|	break;
  533|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (533:5): [True: 0, False: 2.43k]
  ------------------
  534|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (534:14): [True: 0, False: 0]
  ------------------
  535|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  536|      0|	    pa[i] = IntegerFromComplex(COMPLEX_ELT(v, i), &warn);
  ------------------
  |  | 1925|      0|# define IntegerFromComplex	Rf_IntegerFromComplex
  ------------------
  537|      0|	}
  538|      0|	break;
  539|     42|    case STRSXP:
  ------------------
  |  |  126|     42|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (539:5): [True: 42, False: 2.39k]
  ------------------
  540|    162|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (540:14): [True: 120, False: 42]
  ------------------
  541|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  542|    120|	    pa[i] = IntegerFromString(STRING_ELT(v, i), &warn);
  ------------------
  |  | 1928|    120|# define IntegerFromString	Rf_IntegerFromString
  ------------------
  543|    120|	}
  544|     42|	break;
  545|     43|    case RAWSXP:
  ------------------
  |  |  136|     43|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (545:5): [True: 43, False: 2.39k]
  ------------------
  546|  49.4k|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (546:14): [True: 49.4k, False: 43]
  ------------------
  547|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  548|  49.4k|	    pa[i] = (int)RAW_ELT(v, i);
  549|  49.4k|	}
  550|     43|	break;
  551|      0|    default:
  ------------------
  |  Branch (551:5): [True: 0, False: 2.43k]
  ------------------
  552|      0|	UNIMPLEMENTED_TYPE("coerceToInteger", v);
  553|  2.43k|    }
  554|  2.43k|    if (warn) CoercionWarning(warn);
  ------------------
  |  | 1870|      0|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
  |  Branch (554:9): [True: 0, False: 2.43k]
  ------------------
  555|  2.43k|    UNPROTECT(1);
  ------------------
  |  |  358|  2.43k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  556|  2.43k|    return ans;
  557|  2.43k|}
coerce.c:coerceToReal:
  560|  1.77k|{
  561|  1.77k|    SEXP ans;
  562|  1.77k|    int warn = 0;
  563|  1.77k|    R_xlen_t i, n;
  564|  1.77k|    PROTECT(ans = allocVector(REALSXP, n = XLENGTH(v)));
  ------------------
  |  |  357|  1.77k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  565|  1.77k|    double *pa = REAL(ans);
  566|       |#ifdef R_MEMORY_PROFILING
  567|       |    if (RTRACE(v)){
  568|       |       memtrace_report(v,ans);
  569|       |       SET_RTRACE(ans,1);
  570|       |    }
  571|       |#endif
  572|  1.77k|    SHALLOW_DUPLICATE_ATTRIB(ans, v);
  ------------------
  |  |   58|  1.77k|#define SHALLOW_DUPLICATE_ATTRIB(to, from) do {\
  |  |   59|  1.77k|  SEXP __from__ = (from); \
  |  |   60|  1.77k|  if (ATTRIB(__from__) != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (60:7): [True: 0, False: 1.77k]
  |  |  ------------------
  |  |   61|      0|    SEXP __to__ = (to); \
  |  |   62|      0|    (SHALLOW_DUPLICATE_ATTRIB)(__to__, __from__);	\
  |  |   63|      0|  } \
  |  |   64|  1.77k|} while (0)
  |  |  ------------------
  |  |  |  Branch (64:10): [Folded, False: 1.77k]
  |  |  ------------------
  ------------------
  573|  1.77k|    switch (TYPEOF(v)) {
  574|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (574:5): [True: 0, False: 1.77k]
  ------------------
  575|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (575:14): [True: 0, False: 0]
  ------------------
  576|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  577|      0|	    pa[i] = RealFromLogical(LOGICAL_ELT(v, i), &warn);
  ------------------
  |  | 1981|      0|# define RealFromLogical	Rf_RealFromLogical
  ------------------
  578|      0|	}
  579|      0|	break;
  580|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (580:5): [True: 0, False: 1.77k]
  ------------------
  581|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (581:14): [True: 0, False: 0]
  ------------------
  582|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  583|      0|	    pa[i] = RealFromInteger(INTEGER_ELT(v, i), &warn);
  ------------------
  |  | 1980|      0|# define RealFromInteger	Rf_RealFromInteger
  ------------------
  584|      0|	}
  585|      0|	break;
  586|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (586:5): [True: 0, False: 1.77k]
  ------------------
  587|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (587:14): [True: 0, False: 0]
  ------------------
  588|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  589|      0|	    pa[i] = RealFromComplex(COMPLEX_ELT(v, i), &warn);
  ------------------
  |  | 1979|      0|# define RealFromComplex	Rf_RealFromComplex
  ------------------
  590|      0|	}
  591|      0|	break;
  592|  1.77k|    case STRSXP:
  ------------------
  |  |  126|  1.77k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (592:5): [True: 1.77k, False: 0]
  ------------------
  593|   618k|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (593:14): [True: 617k, False: 1.77k]
  ------------------
  594|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  595|   617k|	    pa[i] = RealFromString(STRING_ELT(v, i), &warn);
  ------------------
  |  | 1982|   617k|# define RealFromString		Rf_RealFromString
  ------------------
  596|   617k|	}
  597|  1.77k|	break;
  598|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (598:5): [True: 0, False: 1.77k]
  ------------------
  599|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (599:14): [True: 0, False: 0]
  ------------------
  600|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  601|      0|	    pa[i] = RealFromInteger((int)RAW_ELT(v, i), &warn);
  ------------------
  |  | 1980|      0|# define RealFromInteger	Rf_RealFromInteger
  ------------------
  602|      0|	}
  603|      0|	break;
  604|      0|    default:
  ------------------
  |  Branch (604:5): [True: 0, False: 1.77k]
  ------------------
  605|      0|	UNIMPLEMENTED_TYPE("coerceToReal", v);
  606|  1.77k|    }
  607|  1.77k|    if (warn) CoercionWarning(warn);
  ------------------
  |  | 1870|  1.14k|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
  |  Branch (607:9): [True: 1.14k, False: 629]
  ------------------
  608|  1.77k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.77k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  609|  1.77k|    return ans;
  610|  1.77k|}
coerce.c:coerceToRaw:
  666|     34|{
  667|     34|    SEXP ans;
  668|     34|    int warn = 0, tmp;
  669|     34|    R_xlen_t i, n;
  670|       |
  671|     34|    PROTECT(ans = allocVector(RAWSXP, n = XLENGTH(v)));
  ------------------
  |  |  357|     34|#define PROTECT(s)	Rf_protect(s)
  ------------------
  672|     34|    Rbyte *pa = RAW(ans);
  673|       |#ifdef R_MEMORY_PROFILING
  674|       |    if (RTRACE(v)){
  675|       |       memtrace_report(v,ans);
  676|       |       SET_RTRACE(ans,1);
  677|       |    }
  678|       |#endif
  679|     34|    SHALLOW_DUPLICATE_ATTRIB(ans, v);
  ------------------
  |  |   58|     34|#define SHALLOW_DUPLICATE_ATTRIB(to, from) do {\
  |  |   59|     34|  SEXP __from__ = (from); \
  |  |   60|     34|  if (ATTRIB(__from__) != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (60:7): [True: 0, False: 34]
  |  |  ------------------
  |  |   61|      0|    SEXP __to__ = (to); \
  |  |   62|      0|    (SHALLOW_DUPLICATE_ATTRIB)(__to__, __from__);	\
  |  |   63|      0|  } \
  |  |   64|     34|} while (0)
  |  |  ------------------
  |  |  |  Branch (64:10): [Folded, False: 34]
  |  |  ------------------
  ------------------
  680|     34|    switch (TYPEOF(v)) {
  681|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (681:5): [True: 0, False: 34]
  ------------------
  682|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (682:14): [True: 0, False: 0]
  ------------------
  683|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  684|      0|	    tmp = IntegerFromLogical(LOGICAL_ELT(v, i), &warn);
  ------------------
  |  | 1926|      0|# define IntegerFromLogical	Rf_IntegerFromLogical
  ------------------
  685|      0|	    if(tmp == NA_INTEGER) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (685:9): [True: 0, False: 0]
  ------------------
  686|      0|		tmp = 0;
  687|      0|		warn |= WARN_RAW;
  ------------------
  |  |   51|      0|#define WARN_RAW  8
  ------------------
  688|      0|	    }
  689|      0|	    pa[i] = (Rbyte) tmp;
  690|      0|	}
  691|      0|	break;
  692|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (692:5): [True: 0, False: 34]
  ------------------
  693|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (693:14): [True: 0, False: 0]
  ------------------
  694|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  695|      0|	    tmp = INTEGER_ELT(v, i);
  696|      0|	    if(tmp == NA_INTEGER || tmp < 0 || tmp > 255) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (696:9): [True: 0, False: 0]
  |  Branch (696:30): [True: 0, False: 0]
  |  Branch (696:41): [True: 0, False: 0]
  ------------------
  697|      0|		tmp = 0;
  698|      0|		warn |= WARN_RAW;
  ------------------
  |  |   51|      0|#define WARN_RAW  8
  ------------------
  699|      0|	    }
  700|      0|	    pa[i] = (Rbyte) tmp;
  701|      0|	}
  702|      0|	break;
  703|     34|    case REALSXP:
  ------------------
  |  |  124|     34|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (703:5): [True: 34, False: 0]
  ------------------
  704|     68|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (704:14): [True: 34, False: 34]
  ------------------
  705|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  706|     34|	    tmp = IntegerFromReal(REAL_ELT(v, i), &warn);
  ------------------
  |  | 1927|     34|# define IntegerFromReal	Rf_IntegerFromReal
  ------------------
  707|     34|	    if(tmp == NA_INTEGER || tmp < 0 || tmp > 255) {
  ------------------
  |  |   56|     68|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (707:9): [True: 0, False: 34]
  |  Branch (707:30): [True: 0, False: 34]
  |  Branch (707:41): [True: 0, False: 34]
  ------------------
  708|      0|		tmp = 0;
  709|      0|		warn |= WARN_RAW;
  ------------------
  |  |   51|      0|#define WARN_RAW  8
  ------------------
  710|      0|	    }
  711|     34|	    pa[i] = (Rbyte) tmp;
  712|     34|	}
  713|     34|	break;
  714|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (714:5): [True: 0, False: 34]
  ------------------
  715|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (715:14): [True: 0, False: 0]
  ------------------
  716|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  717|      0|	    tmp = IntegerFromComplex(COMPLEX_ELT(v, i), &warn);
  ------------------
  |  | 1925|      0|# define IntegerFromComplex	Rf_IntegerFromComplex
  ------------------
  718|      0|	    if(tmp == NA_INTEGER || tmp < 0 || tmp > 255) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (718:9): [True: 0, False: 0]
  |  Branch (718:30): [True: 0, False: 0]
  |  Branch (718:41): [True: 0, False: 0]
  ------------------
  719|      0|		tmp = 0;
  720|      0|		warn |= WARN_RAW;
  ------------------
  |  |   51|      0|#define WARN_RAW  8
  ------------------
  721|      0|	    }
  722|      0|	    pa[i] = (Rbyte) tmp;
  723|      0|	}
  724|      0|	break;
  725|      0|    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (725:5): [True: 0, False: 34]
  ------------------
  726|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (726:14): [True: 0, False: 0]
  ------------------
  727|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  728|      0|	    tmp = IntegerFromString(STRING_ELT(v, i), &warn);
  ------------------
  |  | 1928|      0|# define IntegerFromString	Rf_IntegerFromString
  ------------------
  729|      0|	    if(tmp == NA_INTEGER || tmp < 0 || tmp > 255) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (729:9): [True: 0, False: 0]
  |  Branch (729:30): [True: 0, False: 0]
  |  Branch (729:41): [True: 0, False: 0]
  ------------------
  730|      0|		tmp = 0;
  731|      0|		warn |= WARN_RAW;
  ------------------
  |  |   51|      0|#define WARN_RAW  8
  ------------------
  732|      0|	    }
  733|      0|	    pa[i] = (Rbyte) tmp;
  734|      0|	}
  735|      0|	break;
  736|      0|    default:
  ------------------
  |  Branch (736:5): [True: 0, False: 34]
  ------------------
  737|      0|	UNIMPLEMENTED_TYPE("coerceToRaw", v);
  738|     34|    }
  739|     34|    if (warn) CoercionWarning(warn);
  ------------------
  |  | 1870|      0|# define CoercionWarning       	Rf_CoercionWarning
  ------------------
  |  Branch (739:9): [True: 0, False: 34]
  ------------------
  740|     34|    UNPROTECT(1);
  ------------------
  |  |  358|     34|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  741|     34|    return ans;
  742|     34|}
coerce.c:coerceToVectorList:
  854|     12|{
  855|     12|    SEXP ans, tmp;
  856|     12|    R_xlen_t i, n;
  857|     12|    n = xlength(v);
  ------------------
  |  | 1049|     12|#define xlength(x)		Rf_xlength(x)
  ------------------
  858|     12|    PROTECT(ans = allocVector(VECSXP, n));
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
  859|       |#ifdef R_MEMORY_PROFILING
  860|       |    if (RTRACE(v)){
  861|       |       memtrace_report(v,ans);
  862|       |       SET_RTRACE(ans,1);
  863|       |    }
  864|       |#endif
  865|     12|    switch (TYPEOF(v)) {
  866|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (866:5): [True: 0, False: 12]
  ------------------
  867|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (867:14): [True: 0, False: 0]
  ------------------
  868|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  869|      0|	    SET_VECTOR_ELT(ans, i, ScalarLogical(LOGICAL_ELT(v, i)));
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  870|      0|	}
  871|      0|	break;
  872|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (872:5): [True: 0, False: 12]
  ------------------
  873|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (873:14): [True: 0, False: 0]
  ------------------
  874|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  875|      0|	    SET_VECTOR_ELT(ans, i, ScalarInteger(INTEGER_ELT(v, i)));
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  876|      0|	}
  877|      0|	break;
  878|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (878:5): [True: 0, False: 12]
  ------------------
  879|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (879:14): [True: 0, False: 0]
  ------------------
  880|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  881|      0|	    SET_VECTOR_ELT(ans, i, ScalarReal(REAL_ELT(v, i)));
  ------------------
  |  | 1024|      0|#define ScalarReal		Rf_ScalarReal
  ------------------
  882|      0|	}
  883|      0|	break;
  884|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (884:5): [True: 0, False: 12]
  ------------------
  885|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (885:14): [True: 0, False: 0]
  ------------------
  886|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  887|      0|	    SET_VECTOR_ELT(ans, i, ScalarComplex(COMPLEX_ELT(v, i)));
  ------------------
  |  | 1021|      0|#define ScalarComplex		Rf_ScalarComplex
  ------------------
  888|      0|	}
  889|      0|	break;
  890|     12|    case STRSXP:
  ------------------
  |  |  126|     12|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (890:5): [True: 12, False: 0]
  ------------------
  891|  2.61k|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (891:14): [True: 2.59k, False: 12]
  ------------------
  892|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  893|  2.59k|	    SET_VECTOR_ELT(ans, i, ScalarString(STRING_ELT(v, i)));
  ------------------
  |  | 1025|  2.59k|#define ScalarString		Rf_ScalarString
  ------------------
  894|  2.59k|	}
  895|     12|	break;
  896|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (896:5): [True: 0, False: 12]
  ------------------
  897|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (897:14): [True: 0, False: 0]
  ------------------
  898|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  899|      0|	    SET_VECTOR_ELT(ans, i, ScalarRaw(RAW_ELT(v, i)));
  ------------------
  |  | 1026|      0|#define ScalarRaw		Rf_ScalarRaw
  ------------------
  900|      0|	}
  901|      0|	break;
  902|      0|    case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (902:5): [True: 0, False: 12]
  ------------------
  903|      0|    case LANGSXP:
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (903:5): [True: 0, False: 12]
  ------------------
  904|      0|	tmp = v;
  905|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (905:14): [True: 0, False: 0]
  ------------------
  906|      0|	    SET_VECTOR_ELT(ans, i, CAR(tmp));
  907|      0|	    tmp = CDR(tmp);
  908|      0|	}
  909|      0|	break;
  910|      0|    default:
  ------------------
  |  Branch (910:5): [True: 0, False: 12]
  ------------------
  911|      0|	UNIMPLEMENTED_TYPE("coerceToVectorList", v);
  912|     12|    }
  913|     12|    tmp = getAttrib(v, R_NamesSymbol);
  ------------------
  |  |  924|     12|#define getAttrib		Rf_getAttrib
  ------------------
  914|     12|    if (tmp != R_NilValue)
  ------------------
  |  Branch (914:9): [True: 12, False: 0]
  ------------------
  915|     12|	setAttrib(ans, R_NamesSymbol, tmp);
  ------------------
  |  | 1027|     12|#define setAttrib		Rf_setAttrib
  ------------------
  916|     12|    UNPROTECT(1);
  ------------------
  |  |  358|     12|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  917|     12|    return (ans);
  918|     12|}
coerce.c:ascommon:
 1373|  2.33k|{
 1374|       |    /* -> as.vector(..) or as.XXX(.) : coerce 'u' to 'type' : */
 1375|       |    /* code assumes u is protected */
 1376|       |
 1377|  2.33k|    if (type == CLOSXP) {
  ------------------
  |  |  114|  2.33k|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1377:9): [True: 0, False: 2.33k]
  ------------------
 1378|      0|	return asFunction(u);
 1379|      0|    }
 1380|  2.33k|    else if (isVector(u) || isList(u) || isLanguage(u)
  ------------------
  |  |  974|  2.33k|#define isVector		Rf_isVector
  ------------------
                  else if (isVector(u) || isList(u) || isLanguage(u)
  ------------------
  |  |  951|    343|#define isList			Rf_isList
  ------------------
                  else if (isVector(u) || isList(u) || isLanguage(u)
  ------------------
  |  |  950|    340|#define isLanguage		Rf_isLanguage
  ------------------
  |  Branch (1380:14): [True: 1.99k, False: 343]
  |  Branch (1380:29): [True: 3, False: 340]
  |  Branch (1380:42): [True: 84, False: 256]
  ------------------
 1381|  2.07k|	     || (isSymbol(u) && type == EXPRSXP)) {
  ------------------
  |  |  953|    256|#define isSymbol		Rf_isSymbol
  ------------------
              	     || (isSymbol(u) && type == EXPRSXP)) {
  ------------------
  |  |  132|    256|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1381:11): [True: 256, False: 0]
  |  Branch (1381:26): [True: 0, False: 256]
  ------------------
 1382|  2.07k|	SEXP v;
 1383|  2.07k|	if (type != ANYSXP && TYPEOF(u) != type) v = coerceVector(u, type);
  ------------------
  |  |  128|  4.15k|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
              	if (type != ANYSXP && TYPEOF(u) != type) v = coerceVector(u, type);
  ------------------
  |  |  895|  2.07k|#define coerceVector		Rf_coerceVector
  ------------------
  |  Branch (1383:6): [True: 2.07k, False: 0]
  |  Branch (1383:24): [True: 2.07k, False: 0]
  ------------------
 1384|      0|	else v = u;
 1385|       |
 1386|       |	/* drop attributes() and class() in some cases for as.pairlist:
 1387|       |	   But why?  (And who actually coerces to pairlists?)
 1388|       |	 */
 1389|  2.07k|	if ((type == LISTSXP) &&
  ------------------
  |  |  113|  2.07k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1389:6): [True: 0, False: 2.07k]
  ------------------
 1390|      0|	    !(TYPEOF(u) == LANGSXP || TYPEOF(u) == LISTSXP ||
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
              	    !(TYPEOF(u) == LANGSXP || TYPEOF(u) == LISTSXP ||
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1390:8): [True: 0, False: 0]
  |  Branch (1390:32): [True: 0, False: 0]
  ------------------
 1391|      0|	      TYPEOF(u) == EXPRSXP || TYPEOF(u) == VECSXP)) {
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
              	      TYPEOF(u) == EXPRSXP || TYPEOF(u) == VECSXP)) {
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1391:8): [True: 0, False: 0]
  |  Branch (1391:32): [True: 0, False: 0]
  ------------------
 1392|      0|	    if (MAYBE_REFERENCED(v)) v = shallow_duplicate(v);
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	    if (MAYBE_REFERENCED(v)) v = shallow_duplicate(v);
  ------------------
  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 1393|      0|	    CLEAR_ATTRIB(v);
  ------------------
  |  |   66|      0|#define CLEAR_ATTRIB(x) do {\
  |  |   67|      0|  SEXP __x__ = (x); \
  |  |   68|      0|  if (ATTRIB(__x__) != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (68:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   69|      0|    SET_ATTRIB(__x__, R_NilValue); \
  |  |   70|      0|    if (OBJECT(__x__)) SET_OBJECT(__x__, 0); \
  |  |  ------------------
  |  |  |  Branch (70:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   71|      0|    if (IS_S4_OBJECT(__x__)) UNSET_S4_OBJECT(__x__); \
  |  |  ------------------
  |  |  |  Branch (71:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   72|      0|  } \
  |  |   73|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (73:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1394|      0|	}
 1395|  2.07k|	return v;
 1396|  2.07k|    }
 1397|    256|    else if (isSymbol(u) && type == STRSXP)
  ------------------
  |  |  953|    256|#define isSymbol		Rf_isSymbol
  ------------------
                  else if (isSymbol(u) && type == STRSXP)
  ------------------
  |  |  126|    256|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1397:14): [True: 256, False: 0]
  |  Branch (1397:29): [True: 255, False: 1]
  ------------------
 1398|    255|	return ScalarString(PRINTNAME(u));
  ------------------
  |  | 1025|    255|#define ScalarString		Rf_ScalarString
  ------------------
 1399|      1|    else if (isSymbol(u) && type == SYMSXP)
  ------------------
  |  |  953|      1|#define isSymbol		Rf_isSymbol
  ------------------
                  else if (isSymbol(u) && type == SYMSXP)
  ------------------
  |  |  112|      1|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1399:14): [True: 1, False: 0]
  |  Branch (1399:29): [True: 1, False: 0]
  ------------------
 1400|      1|	return u;
 1401|      0|    else if (isSymbol(u) && type == VECSXP) {
  ------------------
  |  |  953|      0|#define isSymbol		Rf_isSymbol
  ------------------
                  else if (isSymbol(u) && type == VECSXP) {
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1401:14): [True: 0, False: 0]
  |  Branch (1401:29): [True: 0, False: 0]
  ------------------
 1402|      0|	SEXP v = allocVector(VECSXP, 1);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	SEXP v = allocVector(VECSXP, 1);
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
 1403|      0|	SET_VECTOR_ELT(v, 0, u);
 1404|      0|	return v;
 1405|      0|    }
 1406|      0|    else errorcall(call, _(COERCE_ERROR_STRING),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
                  else errorcall(call, _(COERCE_ERROR_STRING),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1407|      0|		   R_typeToChar(u), type2char(type));
  ------------------
  |  | 1040|      0|#define type2char		Rf_type2char
  ------------------
 1408|      0|    return u;/* -Wall */
 1409|  2.33k|}
coerce.c:copyDimAndNames:
 2243|   771k|{
 2244|   771k|    if (isVector(x)) {
  ------------------
  |  |  974|   771k|#define isVector		Rf_isVector
  ------------------
  |  Branch (2244:9): [True: 771k, False: 0]
  ------------------
 2245|       |	/* PROTECT/UNPROTECT are probably not needed here */
 2246|   771k|	SEXP dims, names;
 2247|   771k|	PROTECT(dims = getAttrib(x, R_DimSymbol));
  ------------------
  |  |  357|   771k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2248|   771k|	if (dims != R_NilValue)
  ------------------
  |  Branch (2248:6): [True: 0, False: 771k]
  ------------------
 2249|      0|	    setAttrib(ans, R_DimSymbol, dims);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 2250|   771k|	UNPROTECT(1);
  ------------------
  |  |  358|   771k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2251|   771k|	if (isArray(x)) {
  ------------------
  |  |  940|   771k|#define isArray			Rf_isArray
  ------------------
  |  Branch (2251:6): [True: 0, False: 771k]
  ------------------
 2252|      0|	    PROTECT(names = getAttrib(x, R_DimNamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2253|      0|	    if (names != R_NilValue)
  ------------------
  |  Branch (2253:10): [True: 0, False: 0]
  ------------------
 2254|      0|		setAttrib(ans, R_DimNamesSymbol, names);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 2255|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2256|      0|	}
 2257|   771k|	else {
 2258|   771k|	    PROTECT(names = getAttrib(x, R_NamesSymbol));
  ------------------
  |  |  357|   771k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2259|   771k|	    if (names != R_NilValue)
  ------------------
  |  Branch (2259:10): [True: 492, False: 771k]
  ------------------
 2260|    492|		setAttrib(ans, R_NamesSymbol, names);
  ------------------
  |  | 1027|    492|#define setAttrib		Rf_setAttrib
  ------------------
 2261|   771k|	    UNPROTECT(1);
  ------------------
  |  |  358|   771k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2262|   771k|	}
 2263|   771k|    }
 2264|   771k|}
coerce.c:anyNA:
 2377|  1.02k|{
 2378|  1.02k|    SEXP x = CAR(args);
 2379|  1.02k|    SEXPTYPE xT = TYPEOF(x);
 2380|  1.02k|    bool isList =  (bool) (xT == VECSXP || xT == LISTSXP),
  ------------------
  |  |  131|  2.05k|#define VECSXP	    19	  /* generic vectors */
  ------------------
                  bool isList =  (bool) (xT == VECSXP || xT == LISTSXP),
  ------------------
  |  |  113|  1.02k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2380:28): [True: 0, False: 1.02k]
  |  Branch (2380:44): [True: 0, False: 1.02k]
  ------------------
 2381|  1.02k|	recursive = false;
 2382|       |
 2383|  1.02k|    if (isList && length(args) > 1) recursive = asRbool(CADR(args), call);
  ------------------
  |  |  951|  2.05k|#define isList			Rf_isList
  |  |  ------------------
  |  |  |  Branch (951:18): [True: 0, False: 1.02k]
  |  |  ------------------
  ------------------
                  if (isList && length(args) > 1) recursive = asRbool(CADR(args), call);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
                  if (isList && length(args) > 1) recursive = asRbool(CADR(args), call);
  ------------------
  |  | 1861|      0|# define asRbool		Rf_asRbool
  ------------------
  |  Branch (2383:19): [True: 0, False: 0]
  ------------------
 2384|  1.02k|    if (OBJECT(x) || (isList && !recursive)) {
  ------------------
  |  |  951|  2.05k|#define isList			Rf_isList
  |  |  ------------------
  |  |  |  Branch (951:18): [True: 0, False: 1.02k]
  |  |  ------------------
  ------------------
  |  Branch (2384:9): [True: 0, False: 1.02k]
  |  Branch (2384:33): [True: 0, False: 0]
  ------------------
 2385|      0|	SEXP e0 = PROTECT(lang2(install("is.na"), x));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2386|      0|	SEXP e = PROTECT(lang2(install("any"), e0));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2387|      0|	SEXP res = PROTECT(eval(e, env));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2388|      0|	int ans = asLogical(res);
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
 2389|      0|	UNPROTECT(3);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2390|      0|	return ans == 1; // so NA answer is false.
 2391|      0|    }
 2392|       |
 2393|  1.02k|    R_xlen_t i, n = xlength(x);
  ------------------
  |  | 1049|  1.02k|#define xlength(x)		Rf_xlength(x)
  ------------------
 2394|  1.02k|    switch (xT) {
 2395|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (2395:5): [True: 0, False: 1.02k]
  ------------------
 2396|      0|    {
 2397|      0|	if(REAL_NO_NA(x))
  ------------------
  |  Branch (2397:5): [True: 0, False: 0]
  ------------------
 2398|      0|	    return false;
 2399|      0|	ITERATE_BY_REGION(x, xD, i, nbatch, double, REAL, {
  ------------------
  |  |  251|      0|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|      0|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|      0|				  strt, nfull, expr) do {		\
  |  |  |  |  221|      0|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|      0|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|      0|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|      0|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|      0|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|      0|	    px += strt;							\
  |  |  |  |  227|      0|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|      0|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  229|      0|	    }                                                           \
  |  |  |  |  230|      0|	}								\
  |  |  |  |  231|      0|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|      0|					strt, nfull, expr);		\
  |  |  |  |  233|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|      0|				  0, XLENGTH(sx), expr);		\
  |  |  254|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2400|      0|		for (R_xlen_t k = 0; k < nbatch; k++)
 2401|      0|		    if (ISNAN(xD[k]))
 2402|      0|			return true;
 2403|      0|	    });
 2404|      0|	break;
 2405|      0|    }
 2406|     66|    case INTSXP:
  ------------------
  |  |  123|     66|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2406:5): [True: 66, False: 960]
  ------------------
 2407|     66|    {
 2408|     66|	if(INTEGER_NO_NA(x))
  ------------------
  |  Branch (2408:5): [True: 0, False: 66]
  ------------------
 2409|      0|	    return false;
 2410|     66|	ITERATE_BY_REGION(x, xI, i, nbatch, int, INTEGER, {
  ------------------
  |  |  251|     66|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|     66|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|     66|				  strt, nfull, expr) do {		\
  |  |  |  |  221|     66|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|     66|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 66, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|     66|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|     66|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|     66|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|     66|	    px += strt;							\
  |  |  |  |  227|     66|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 66, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|  1.09k|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 0, False: 258]
  |  |  |  |  |  Branch (228:10): [True: 258, False: 66]
  |  |  |  |  ------------------
  |  |  |  |  229|     66|	    }                                                           \
  |  |  |  |  230|     66|	}								\
  |  |  |  |  231|     66|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|     66|					strt, nfull, expr);		\
  |  |  |  |  233|     66|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 66]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|     66|				  0, XLENGTH(sx), expr);		\
  |  |  254|     66|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 66]
  |  |  ------------------
  ------------------
 2411|     66|		for (R_xlen_t k = 0; k < nbatch; k++)
 2412|     66|		    if (xI[k] == NA_INTEGER)
 2413|     66|			return true;
 2414|     66|	    });
 2415|     66|	break;
 2416|     66|    }
 2417|    952|    case LGLSXP:
  ------------------
  |  |  121|    952|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2417:5): [True: 952, False: 74]
  ------------------
 2418|    952|    {
 2419|  1.90k|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (2419:14): [True: 952, False: 952]
  ------------------
 2420|    952|	    if (LOGICAL_ELT(x, i) == NA_LOGICAL) return true;
  ------------------
  |  |   55|    952|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (2420:10): [True: 0, False: 952]
  ------------------
 2421|    952|	break;
 2422|    952|    }
 2423|    952|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (2423:5): [True: 0, False: 1.02k]
  ------------------
 2424|      0|    {
 2425|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (2425:14): [True: 0, False: 0]
  ------------------
 2426|      0|	    Rcomplex v = COMPLEX_ELT(x, i);
 2427|      0|	    if (ISNAN(v.r) || ISNAN(v.i)) return true;
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	    if (ISNAN(v.r) || ISNAN(v.i)) return true;
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2428|      0|	}
 2429|      0|	break;
 2430|      0|    }
 2431|      8|    case STRSXP:
  ------------------
  |  |  126|      8|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2431:5): [True: 8, False: 1.01k]
  ------------------
 2432|     28|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (2432:14): [True: 20, False: 8]
  ------------------
 2433|     20|	    if (STRING_ELT(x, i) == NA_STRING) return true;
  ------------------
  |  |  433|     20|#define NA_STRING	R_NaString
  ------------------
  |  Branch (2433:10): [True: 0, False: 20]
  ------------------
 2434|      8|	break;
 2435|      8|    case RAWSXP: /* no such thing as a raw NA:  is.na(.) gives false always */
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (2435:5): [True: 0, False: 1.02k]
  ------------------
 2436|      0|	return false;
 2437|      0|    case NILSXP: // is.na() gives a warning..., but we do not.
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (2437:5): [True: 0, False: 1.02k]
  ------------------
 2438|      0|	return false;
 2439|       |    // The next two cases are only used if recursive = true
 2440|      0|    case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2440:5): [True: 0, False: 1.02k]
  ------------------
 2441|      0|    {
 2442|      0|	SEXP call2, args2, ans;
 2443|      0|	args2 = PROTECT(shallow_duplicate(args));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2444|      0|	call2 = PROTECT(shallow_duplicate(call));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2445|      0|	for (i = 0; i < n; i++, x = CDR(x)) {
  ------------------
  |  Branch (2445:14): [True: 0, False: 0]
  ------------------
 2446|      0|	    SETCAR(args2, CAR(x)); SETCADR(call2, CAR(x));
 2447|       |	    /* DispatchOrEval internal generic: anyNA */
 2448|      0|	    if ((DispatchOrEval(call2, op, "anyNA", args2, env, &ans, 0, 1)
  ------------------
  |  | 1887|      0|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (2448:11): [True: 0, False: 0]
  ------------------
 2449|      0|		 && asLogical(ans)) || anyNA(call2, op, args2, env)) {
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
  |  Branch (2449:7): [True: 0, False: 0]
  |  Branch (2449:26): [True: 0, False: 0]
  ------------------
 2450|      0|		UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2451|      0|		return true;
 2452|      0|	    }
 2453|      0|	}
 2454|      0|	UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2455|      0|	break;
 2456|      0|    }
 2457|      0|    case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2457:5): [True: 0, False: 1.02k]
  ------------------
 2458|      0|    {
 2459|      0|	SEXP call2, args2, ans;
 2460|      0|	args2 = PROTECT(shallow_duplicate(args));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2461|      0|	call2 = PROTECT(shallow_duplicate(call));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2462|      0|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (2462:14): [True: 0, False: 0]
  ------------------
 2463|      0|	    SETCAR(args2, VECTOR_ELT(x, i)); SETCADR(call2, VECTOR_ELT(x, i));
 2464|       |	    /* DispatchOrEval internal generic: anyNA */
 2465|      0|	    if ((DispatchOrEval(call2, op, "anyNA", args2, env, &ans, 0, 1)
  ------------------
  |  | 1887|      0|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (2465:11): [True: 0, False: 0]
  ------------------
 2466|      0|		 && asLogical(ans)) || anyNA(call2, op, args2, env)) {
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
  |  Branch (2466:7): [True: 0, False: 0]
  |  Branch (2466:26): [True: 0, False: 0]
  ------------------
 2467|      0|		UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2468|      0|		return true;
 2469|      0|	    }
 2470|      0|	}
 2471|      0|	UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2472|      0|	break;
 2473|      0|    }
 2474|       |
 2475|      0|    default:
  ------------------
  |  Branch (2475:5): [True: 0, False: 1.02k]
  ------------------
 2476|      0|	error("anyNA() applied to non-(list or vector) of type '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 2477|      0|	      R_typeToChar(x));
 2478|  1.02k|    }
 2479|  1.02k|    return false;
 2480|  1.02k|} // anyNA()
coerce.c:R_set_class:
 3005|     85|{
 3006|     85|    int nProtect = 0;
 3007|       |    // use of zero-length vector used to be documented.
 3008|     85|    if(!length(value)) { // usually NULL
  ------------------
  |  |  987|     85|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (3008:8): [True: 2, False: 83]
  ------------------
 3009|      2|	setAttrib(obj, R_ClassSymbol, value);
  ------------------
  |  | 1027|      2|#define setAttrib		Rf_setAttrib
  ------------------
 3010|      2|	if(IS_S4_OBJECT(obj)) /* NULL class is only valid for S3 objects */
  ------------------
  |  Branch (3010:5): [True: 0, False: 2]
  ------------------
 3011|      0|	  do_unsetS4(obj, value);
 3012|      2|	return obj;
 3013|      2|    }
 3014|     83|    if(TYPEOF(value) != STRSXP) {
  ------------------
  |  |  126|     83|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (3014:8): [True: 0, False: 83]
  ------------------
 3015|      0|	SEXP dup;
 3016|       |	/* assumes value is protected, which it is in R_do_set_class */
 3017|      0|	PROTECT(dup = duplicate(value));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3018|      0|	PROTECT(value = coerceVector(dup, STRSXP));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3019|      0|	nProtect += 2;
 3020|      0|	if(length(value) == 0)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (3020:5): [True: 0, False: 0]
  ------------------
 3021|      0|	    error(_("invalid replacement object to be a class string"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid replacement object to be a class string"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3022|      0|    }
 3023|       |    // length(value) >= 1
 3024|     83|    const char *valueString = CHAR(asChar(value)); /* ASCII ; the *first* in case of multiple strings */
  ------------------
  |  |  203|     83|#define CHAR(x) R_CHAR(x)
  ------------------
 3025|     83|    if(!strcmp("matrix", valueString)) { // value : just "matrix" or  c("matrix", "<some>" [, ...])
  ------------------
  |  Branch (3025:8): [True: 0, False: 83]
  ------------------
 3026|      0|	if(length(getAttrib(obj, R_DimSymbol)) != 2)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (3026:5): [True: 0, False: 0]
  ------------------
 3027|      0|	    error(_("invalid to set the class to matrix unless the dimension attribute is of length 2 (was %d)"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid to set the class to matrix unless the dimension attribute is of length 2 (was %d)"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3028|      0|		  length(getAttrib(obj, R_DimSymbol)));
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 3029|      0|	if(length(value) == 1 ||
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (3029:5): [True: 0, False: 0]
  ------------------
 3030|      0|	   (length(value) == 2 && !strcmp("array", CHAR(STRING_ELT(value, 1)))))
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
              	   (length(value) == 2 && !strcmp("array", CHAR(STRING_ELT(value, 1)))))
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (3030:6): [True: 0, False: 0]
  |  Branch (3030:28): [True: 0, False: 0]
  ------------------
 3031|      0|	{ // "matrix"  or  c("matrix", "array") :
 3032|      0|	    setAttrib(obj, R_ClassSymbol, R_NilValue); // NULL;  and that's not for S4:
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 3033|      0|	    if(IS_S4_OBJECT(obj))
  ------------------
  |  Branch (3033:9): [True: 0, False: 0]
  ------------------
 3034|      0|		do_unsetS4(obj, value);
 3035|      0|	    goto done_set_class;
 3036|      0|	}
 3037|      0|    }
 3038|       |
 3039|     83|    if(length(value) > 1) { // multiple strings ==> S3
  ------------------
  |  |  987|     83|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (3039:8): [True: 18, False: 65]
  ------------------
 3040|     18|        setAttrib(obj, R_ClassSymbol, value);
  ------------------
  |  | 1027|     18|#define setAttrib		Rf_setAttrib
  ------------------
 3041|     18|	if(IS_S4_OBJECT(obj)) /*  multiple strings only valid for S3 objects */
  ------------------
  |  Branch (3041:5): [True: 0, False: 18]
  ------------------
 3042|      0|	    do_unsetS4(obj, value);
 3043|     65|    } else { // length(value) == 1 -- use valueString
 3044|     65|	int whichType = class2type(valueString);
 3045|     65|	SEXPTYPE valueType = (whichType == -1) ? (SEXPTYPE) -1
  ------------------
  |  Branch (3045:23): [True: 65, False: 0]
  ------------------
 3046|     65|	    : classTable[whichType].sexp;
 3047|       |	// SEXP cur_class = PROTECT(R_data_class(obj, FALSE)); nProtect++;
 3048|       |	/*  assigning type as a class deletes an explicit class attribute. */
 3049|     65|	if(valueType != (SEXPTYPE)-1) {
  ------------------
  |  Branch (3049:5): [True: 0, False: 65]
  ------------------
 3050|      0|	    setAttrib(obj, R_ClassSymbol, R_NilValue);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 3051|      0|	    if(IS_S4_OBJECT(obj)) /* NULL class is only valid for S3 objects */
  ------------------
  |  Branch (3051:9): [True: 0, False: 0]
  ------------------
 3052|      0|	      do_unsetS4(obj, value);
 3053|      0|	    if(classTable[whichType].canChange) {
  ------------------
  |  Branch (3053:9): [True: 0, False: 0]
  ------------------
 3054|      0|		PROTECT(obj = ascommon(call, obj, valueType));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3055|      0|		nProtect++;
 3056|      0|	    }
 3057|      0|	    else if(valueType != TYPEOF(obj))
  ------------------
  |  Branch (3057:14): [True: 0, False: 0]
  ------------------
 3058|      0|		error(_("\"%s\" can only be set as the class if the object has this type; found \"%s\""),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("\"%s\" can only be set as the class if the object has this type; found \"%s\""),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3059|      0|		      valueString, R_typeToChar(obj));
 3060|       |	    /* else, leave alone */
 3061|      0|	}
 3062|     65|	else if(!strcmp("numeric", valueString)) {
  ------------------
  |  Branch (3062:10): [True: 0, False: 65]
  ------------------
 3063|      0|	    setAttrib(obj, R_ClassSymbol, R_NilValue);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 3064|      0|	    if(IS_S4_OBJECT(obj)) /* NULL class is only valid for S3 objects */
  ------------------
  |  Branch (3064:9): [True: 0, False: 0]
  ------------------
 3065|      0|	      do_unsetS4(obj, value);
 3066|      0|	    switch(TYPEOF(obj)) {
 3067|      0|	    case INTSXP: case REALSXP: break;
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
              	    case INTSXP: case REALSXP: break;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (3067:6): [True: 0, False: 0]
  |  Branch (3067:19): [True: 0, False: 0]
  ------------------
 3068|      0|	    default: PROTECT(obj = coerceVector(obj, REALSXP));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  |  Branch (3068:6): [True: 0, False: 0]
  ------------------
 3069|      0|		nProtect++;
 3070|      0|	    }
 3071|      0|	}
 3072|       |	/* the next 2 special cases mirror the special code in
 3073|       |	 * R_data_class */
 3074|     65|	else if(!strcmp("array", valueString)) {
  ------------------
  |  Branch (3074:10): [True: 0, False: 65]
  ------------------
 3075|      0|	    if(length(getAttrib(obj, R_DimSymbol)) <= 0)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (3075:9): [True: 0, False: 0]
  ------------------
 3076|      0|		error(_("cannot set class to \"array\" unless the dimension attribute has length > 0"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("cannot set class to \"array\" unless the dimension attribute has length > 0"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3077|      0|	    setAttrib(obj, R_ClassSymbol, R_NilValue);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 3078|      0|	    if(IS_S4_OBJECT(obj)) /* NULL class is only valid for S3 objects */
  ------------------
  |  Branch (3078:9): [True: 0, False: 0]
  ------------------
 3079|      0|	      UNSET_S4_OBJECT(obj);
 3080|      0|	}
 3081|     65|	else { /* set the class but don't do the coercion; that's
 3082|       |		  supposed to be done by an as() method */
 3083|     65|	    setAttrib(obj, R_ClassSymbol, value);
  ------------------
  |  | 1027|     65|#define setAttrib		Rf_setAttrib
  ------------------
 3084|     65|	}
 3085|     65|    }
 3086|       |
 3087|     83|done_set_class:
 3088|     83|    UNPROTECT(nProtect);
  ------------------
  |  |  358|     83|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3089|     83|    return obj;
 3090|     83|}
coerce.c:class2type:
 2966|     65|{
 2967|       |    /* return the type if the class string is one of the basic types, else -1.
 2968|       |       Note that this is NOT str2type:  only certain types are defined to be basic
 2969|       |       classes; e.g., "language" is a type but many classes correspond to objects of
 2970|       |       this type.
 2971|       |    */
 2972|     65|    int i; char *si;
 2973|    910|    for(i = 0; ; i++) {
 2974|    910|	si = classTable[i].s;
 2975|    910|	if(!si)
  ------------------
  |  Branch (2975:5): [True: 65, False: 845]
  ------------------
 2976|     65|	    return -1;
 2977|    845|	if(!strcmp(s, si))
  ------------------
  |  Branch (2977:5): [True: 0, False: 845]
  ------------------
 2978|      0|	    return i;
 2979|    845|    }
 2980|       |    /* cannot get here return -1; */
 2981|     65|}

Rg_set_col_ptrs:
   41|      2|{
   42|      2|    ptr_RGBpar3 = f1;
   43|      2|    ptr_col2name = f2;
   44|      2|    ptr_R_GE_str2col = f3;
   45|      2|    ptr_savePalette = f4;
   46|      2|}

getConnection:
  210|    194|{
  211|    194|    Rconnection con = NULL;
  212|       |
  213|    194|    if(n < 0 || n >= NCONNECTIONS || n == NA_INTEGER ||
  ------------------
  |  |   56|    388|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (213:8): [True: 0, False: 194]
  |  Branch (213:17): [True: 0, False: 194]
  |  Branch (213:38): [True: 0, False: 194]
  ------------------
  214|    194|       !(con = Connections[n]))
  ------------------
  |  Branch (214:8): [True: 0, False: 194]
  ------------------
  215|      0|	error(_("invalid connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  216|    194|    return con;
  217|       |
  218|    194|}
Rf_set_iconv:
  395|     88|{
  396|     88|    void *tmp;
  397|       |
  398|       |    /* need to test if this is text, open for reading to writing or both,
  399|       |       and set inconv and/or outconv */
  400|     88|    if(!con->text || !strlen(con->encname) ||
  ------------------
  |  Branch (400:8): [True: 72, False: 16]
  |  Branch (400:22): [True: 0, False: 16]
  ------------------
  401|     88|       strcmp(con->encname, "native.enc") == 0) {
  ------------------
  |  Branch (401:8): [True: 16, False: 0]
  ------------------
  402|     88|	con->UTF8out = FALSE;
  403|     88|	return;
  404|     88|    }
  405|      0|    if(con->canread) {
  ------------------
  |  Branch (405:8): [True: 0, False: 0]
  ------------------
  406|      0|	size_t onb = 50;
  407|      0|	char *ob = con->oconvbuff;
  408|       |	/* UTF8out is set in readLines() and scan()
  409|       |	   Was Windows-only until 2.12.0, but we now require iconv.
  410|       |	 */
  411|      0|	Rboolean useUTF8 = !utf8locale && con->UTF8out;
  ------------------
  |  Branch (411:21): [True: 0, False: 0]
  |  Branch (411:36): [True: 0, False: 0]
  ------------------
  412|      0|	const char *enc =
  413|      0|	    streql(con->encname, "UTF-8-BOM") ? "UTF-8" : con->encname;
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  414|      0|	tmp = Riconv_open(useUTF8 ? "UTF-8" : "", enc);
  ------------------
  |  Branch (414:20): [True: 0, False: 0]
  ------------------
  415|      0|	if(tmp != (void *)-1) con->inconv = tmp;
  ------------------
  |  Branch (415:5): [True: 0, False: 0]
  ------------------
  416|      0|	else set_iconv_error(con, con->encname, useUTF8 ? "UTF-8" : "");
  ------------------
  |  Branch (416:42): [True: 0, False: 0]
  ------------------
  417|      0|	con->EOF_signalled = FALSE;
  418|       |	/* initialize state, and prepare any initial bytes */
  419|      0|	Riconv(tmp, NULL, NULL, &ob, &onb);
  420|      0|	con->navail = (short)(50-onb); con->inavail = 0;
  421|       |	/* libiconv can handle BOM marks on Windows Unicode files, but
  422|       |	   glibc's iconv cannot. Aargh ... */
  423|      0|	if(streql(con->encname, "UCS-2LE") ||
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  424|      0|	   streql(con->encname, "UTF-16LE")) con->inavail = -2;
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  425|       |	/* Discard BOM */
  426|      0|	if(streql(con->encname, "UTF-8-BOM")) con->inavail = -3;
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  427|      0|    }
  428|      0|    if(con->canwrite) {
  ------------------
  |  Branch (428:8): [True: 0, False: 0]
  ------------------
  429|      0|	size_t onb = 25;
  430|      0|	char *ob = con->init_out;
  431|      0|	tmp = Riconv_open(con->encname, "");
  432|      0|	if(tmp != (void *)-1) con->outconv = tmp;
  ------------------
  |  Branch (432:5): [True: 0, False: 0]
  ------------------
  433|      0|	else set_iconv_error(con, con->encname, "");
  434|       |	/* initialize state, and prepare any initial bytes */
  435|      0|	Riconv(tmp, NULL, NULL, &ob, &onb);
  436|      0|	ob[25-onb] = '\0';
  437|      0|    }
  438|      0|}
dummy_fgetc:
  547|  15.8k|{
  548|  15.8k|    if(con->inconv) {
  ------------------
  |  Branch (548:8): [True: 0, False: 15.8k]
  ------------------
  549|      0|	while(con->navail <= 0) {
  ------------------
  |  Branch (549:8): [True: 0, False: 0]
  ------------------
  550|      0|	    unsigned int i, inew = 0;
  551|      0|	    char *p, *ob;
  552|      0|	    const char *ib;
  553|      0|	    size_t inb, onb, res;
  554|      0|	    Rboolean checkBOM = FALSE, checkBOM8 = FALSE;
  555|       |
  556|      0|	    if(con->EOF_signalled) return R_EOF;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (556:9): [True: 0, False: 0]
  ------------------
  557|      0|	    if (con->inavail < 0) {
  ------------------
  |  Branch (557:10): [True: 0, False: 0]
  ------------------
  558|      0|		switch(con->inavail) {
  ------------------
  |  Branch (558:10): [True: 0, False: 0]
  ------------------
  559|      0|		case -2:
  ------------------
  |  Branch (559:3): [True: 0, False: 0]
  ------------------
  560|      0|		    con->inavail = 0;
  561|      0|		    checkBOM = TRUE;
  562|      0|		    break;
  563|      0|		case -3:
  ------------------
  |  Branch (563:3): [True: 0, False: 0]
  ------------------
  564|      0|		    con->inavail = 0;
  565|      0|		    checkBOM8 = TRUE;
  566|      0|		    break;
  567|      0|		case -21:
  ------------------
  |  Branch (567:3): [True: 0, False: 0]
  ------------------
  568|      0|		    con->inavail = 1;
  569|      0|		    checkBOM = TRUE;
  570|      0|		    break;
  571|      0|		case -31:
  ------------------
  |  Branch (571:3): [True: 0, False: 0]
  ------------------
  572|      0|		    con->inavail = 1;
  573|      0|		    checkBOM8 = TRUE;
  574|      0|		    break;
  575|      0|		case -32:
  ------------------
  |  Branch (575:3): [True: 0, False: 0]
  ------------------
  576|      0|		    con->inavail = 2;
  577|      0|		    checkBOM8 = TRUE;
  578|      0|		    break;
  579|      0|		}
  580|      0|	    }
  581|      0|	    p = con->iconvbuff + con->inavail;
  582|      0|	    for(i = con->inavail; i < 25; i++) {
  ------------------
  |  Branch (582:28): [True: 0, False: 0]
  ------------------
  583|      0|		int c = (con->buff)
  ------------------
  |  Branch (583:11): [True: 0, False: 0]
  ------------------
  584|      0|		    ? buff_fgetc(con)
  585|      0|		    : con->fgetc_internal(con);
  586|      0|		if(c == R_EOF)
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (586:6): [True: 0, False: 0]
  ------------------
  587|       |		    /* Do not set EOF_signalled, because subsequent reads from
  588|       |		       a non-blocking connections may succeed (PR18555). */
  589|      0|		    break;
  590|      0|		*p++ = (char) c;
  591|      0|		con->inavail++;
  592|      0|		inew++;
  593|      0|		if(!con->buff && (c == '\n' || c == '\r'))
  ------------------
  |  Branch (593:6): [True: 0, False: 0]
  |  Branch (593:21): [True: 0, False: 0]
  |  Branch (593:34): [True: 0, False: 0]
  ------------------
  594|       |		    /* Possibly a line separator: better stop filling in the
  595|       |		       encoding conversion buffer if not buffering the input
  596|       |		       anyway, as not to confuse interactive applications
  597|       |		       (PR17634).
  598|       |		    */
  599|      0|		    break;
  600|      0|	    }
  601|      0|	    if (checkBOM || checkBOM8) {
  ------------------
  |  Branch (601:10): [True: 0, False: 0]
  |  Branch (601:22): [True: 0, False: 0]
  ------------------
  602|       |		/* Handle the case of partial BOMs, e.g. in non-blocking
  603|       |		   connections, when we do not have enough data to tell
  604|       |		   whether there is a BOM or not.  Indicate by negative
  605|       |		   con->inavail which BOM still needs to be checked and
  606|       |		   how many bytes were already checked. */
  607|      0|		if(con->inavail == 0) {
  ------------------
  |  Branch (607:6): [True: 0, False: 0]
  ------------------
  608|      0|		    if (checkBOM)
  ------------------
  |  Branch (608:11): [True: 0, False: 0]
  ------------------
  609|      0|			con->inavail = -2;
  610|      0|		    else if (checkBOM8)
  ------------------
  |  Branch (610:16): [True: 0, False: 0]
  ------------------
  611|      0|			con->inavail = -3;
  612|      0|		    return R_EOF;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  613|      0|		}
  614|      0|		if (con->inavail == 1) {
  ------------------
  |  Branch (614:7): [True: 0, False: 0]
  ------------------
  615|      0|		    if (checkBOM && (((int)con->iconvbuff[0] & 0xff) == 255)) {
  ------------------
  |  Branch (615:11): [True: 0, False: 0]
  |  Branch (615:23): [True: 0, False: 0]
  ------------------
  616|      0|			con->inavail = -21;
  617|      0|			return R_EOF;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  618|      0|		    }
  619|      0|		    if (checkBOM8 && con->iconvbuff[0] == '\xef') {
  ------------------
  |  Branch (619:11): [True: 0, False: 0]
  |  Branch (619:24): [True: 0, False: 0]
  ------------------
  620|      0|			con->inavail = -31;
  621|      0|			return R_EOF;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  622|      0|		    }
  623|      0|		}
  624|      0|		if (con->inavail == 2 && checkBOM8 &&
  ------------------
  |  Branch (624:7): [True: 0, False: 0]
  |  Branch (624:28): [True: 0, False: 0]
  ------------------
  625|      0|		    con->iconvbuff[1] == '\xbb') {
  ------------------
  |  Branch (625:7): [True: 0, False: 0]
  ------------------
  626|       |
  627|      0|		    con->inavail = -32;
  628|      0|		    return R_EOF;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  629|      0|		}
  630|      0|	    }
  631|      0|	    if(inew == 0) return R_EOF;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (631:9): [True: 0, False: 0]
  ------------------
  632|      0|	    if(checkBOM && con->inavail >= 2 &&
  ------------------
  |  Branch (632:9): [True: 0, False: 0]
  |  Branch (632:21): [True: 0, False: 0]
  ------------------
  633|      0|	       ((int)con->iconvbuff[0] & 0xff) == 255 &&
  ------------------
  |  Branch (633:9): [True: 0, False: 0]
  ------------------
  634|      0|	       ((int)con->iconvbuff[1] & 0xff) == 254) {
  ------------------
  |  Branch (634:9): [True: 0, False: 0]
  ------------------
  635|      0|		con->inavail -= (short) 2;
  636|      0|		memmove(con->iconvbuff, con->iconvbuff+2, con->inavail);
  637|      0|	    }
  638|      0|	    if(checkBOM8 && con->inavail >= 3 &&
  ------------------
  |  Branch (638:9): [True: 0, False: 0]
  |  Branch (638:22): [True: 0, False: 0]
  ------------------
  639|      0|	       !memcmp(con->iconvbuff, "\xef\xbb\xbf", 3)) {
  ------------------
  |  Branch (639:9): [True: 0, False: 0]
  ------------------
  640|      0|		con->inavail -= (short) 3;
  641|      0|		memmove(con->iconvbuff, con->iconvbuff+3, con->inavail);
  642|      0|	    }
  643|      0|	    ib = con->iconvbuff; inb = con->inavail;
  644|      0|	    ob = con->oconvbuff; onb = 50;
  645|      0|	    errno = 0;
  646|      0|	    res = Riconv(con->inconv, &ib, &inb, &ob, &onb);
  647|      0|	    con->inavail = (short) inb;
  648|      0|	    con->next = con->oconvbuff;
  649|      0|	    con->navail = (short)(50 - onb);
  650|      0|	    if(res == (size_t)-1) { /* an error condition */
  ------------------
  |  Branch (650:9): [True: 0, False: 0]
  ------------------
  651|      0|		if(errno == EINVAL || errno == E2BIG) {
  ------------------
  |  Branch (651:6): [True: 0, False: 0]
  |  Branch (651:25): [True: 0, False: 0]
  ------------------
  652|       |		    /* incomplete input char or no space in output buffer */
  653|      0|		    memmove(con->iconvbuff, ib, inb);
  654|      0|		} else {/*  EILSEQ invalid input */
  655|      0|		    Riconv(con->inconv, NULL, NULL, NULL, NULL);
  656|      0|		    warning(_("invalid input found on input connection '%s'"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		    warning(_("invalid input found on input connection '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  657|      0|			    con->description);
  658|      0|		    con->inavail = 0;
  659|       |		    /* Set to prevent reading any more bytes from input,
  660|       |		       possibly those following the invalid bytes currently
  661|       |		       encountered. */
  662|      0|		    con->EOF_signalled = TRUE;
  663|      0|		}
  664|      0|	    }
  665|      0|	}
  666|      0|	con->navail--;
  667|       |	/* the cast prevents sign extension of 0xFF to -1 (R_EOF) */
  668|      0|	return (unsigned char)*con->next++;
  669|  15.8k|    } else if (con->buff)
  ------------------
  |  Branch (669:16): [True: 15.8k, False: 0]
  ------------------
  670|  15.8k|	return buff_fgetc(con);
  671|      0|    else
  672|      0|	return con->fgetc_internal(con);
  673|  15.8k|}
Rf_init_con:
  709|     94|{
  710|     94|    strcpy(new->description, description);
  711|     94|    new->enc = enc;
  712|     94|    strncpy(new->mode, mode, 4); new->mode[4] = '\0';
  713|     94|    new->isopen = new->incomplete = new->blocking = new->isGzcon = FALSE;
  714|     94|    new->canread = new->canwrite = TRUE; /* in principle */
  715|     94|    new->canseek = FALSE;
  716|     94|    new->text = TRUE;
  717|     94|    new->open = &null_open;
  718|     94|    new->close = &null_close;
  719|     94|    new->destroy = &null_destroy;
  720|     94|    new->vfprintf = &null_vfprintf;
  721|     94|    new->fgetc = new->fgetc_internal = &null_fgetc;
  722|     94|    new->seek = &null_seek;
  723|     94|    new->truncate = &null_truncate;
  724|     94|    new->fflush = &null_fflush;
  725|     94|    new->read = &null_read;
  726|     94|    new->write = &null_write;
  727|     94|    new->nPushBack = 0;
  728|     94|    new->save = new->save2 = -1000;
  729|     94|    new->private = NULL;
  730|     94|    new->inconv = new->outconv = NULL;
  731|     94|    new->UTF8out = FALSE;
  732|     94|    new->buff = NULL;
  733|     94|    new->buff_pos = new->buff_stored_len = new->buff_len = 0;
  734|       |    /* increment id, avoid NULL */
  735|     94|    current_id = (void *)((size_t) current_id+1);
  736|     94|    if(!current_id) current_id = (void *) 1;
  ------------------
  |  Branch (736:8): [True: 0, False: 94]
  ------------------
  737|     94|    new->id = current_id;
  738|     94|    new->ex_ptr = NULL;
  739|     94|    new->status = NA_INTEGER;
  ------------------
  |  |   56|     94|#define NA_INTEGER	R_NaInt
  ------------------
  740|     94|}
R_IsDirPath:
  800|     72|{
  801|     72|#ifdef HAVE_SYS_STAT_H
  802|       |# ifdef Win32
  803|       |    /* to support > 2GB files */
  804|       |    struct _stati64 sb;
  805|       |    if (!_stati64(path, &sb) && (sb.st_mode & S_IFDIR))
  806|       |	return TRUE;
  807|       |    /* This is FALSE for D: */
  808|       |# else
  809|     72|    struct stat sb;
  810|     72|    if (!stat(path, &sb) && S_ISDIR(sb.st_mode))
  ------------------
  |  Branch (810:9): [True: 72, False: 0]
  |  Branch (810:29): [True: 0, False: 72]
  ------------------
  811|      0|	return TRUE;
  812|     72|# endif
  813|     72|#endif
  814|     72|    return FALSE;
  815|     72|}
do_gzfile:
 2738|     72|{
 2739|     72|    SEXP sfile, sopen, ans, class, enc;
 2740|     72|    const char *file, *open;
 2741|     72|    int ncon, compress = 9;
 2742|     72|    Rconnection con = NULL;
 2743|     72|    int type = PRIMVAL(op);
  ------------------
  |  | 1347|     72|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
 2744|     72|    int subtype = 0;
 2745|       |
 2746|     72|    checkArity(op, args);
  ------------------
  |  | 1788|     72|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2747|     72|    sfile = CAR(args);
 2748|     72|    if(!isString(sfile) || LENGTH(sfile) != 1 ||
  ------------------
  |  |  966|     72|#define isString		Rf_isString
  ------------------
  |  Branch (2748:8): [True: 0, False: 72]
  |  Branch (2748:28): [True: 0, False: 72]
  ------------------
 2749|     72|       STRING_ELT(sfile, 0) == NA_STRING)
  ------------------
  |  |  433|     72|#define NA_STRING	R_NaString
  ------------------
  |  Branch (2749:8): [True: 0, False: 72]
  ------------------
 2750|      0|	error(_("invalid '%s' argument"), "description");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "description");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2751|     72|    if(LENGTH(sfile) > 1)
  ------------------
  |  Branch (2751:8): [True: 0, False: 72]
  ------------------
 2752|      0|	warning(_("only first element of 'description' argument used"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("only first element of 'description' argument used"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2753|     72|    file = translateCharFP(STRING_ELT(sfile, 0));
  ------------------
  |  | 1998|     72|# define translateCharFP	Rf_translateCharFP
  ------------------
 2754|     72|    sopen = CADR(args);
 2755|     72|    if(!isString(sopen) || LENGTH(sopen) != 1)
  ------------------
  |  |  966|     72|#define isString		Rf_isString
  ------------------
  |  Branch (2755:8): [True: 0, False: 72]
  |  Branch (2755:28): [True: 0, False: 72]
  ------------------
 2756|      0|	error(_("invalid '%s' argument"), "open");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "open");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2757|     72|    enc = CADDR(args);
 2758|     72|    if(!isString(enc) || LENGTH(enc) != 1 ||
  ------------------
  |  |  966|     72|#define isString		Rf_isString
  ------------------
  |  Branch (2758:8): [True: 0, False: 72]
  |  Branch (2758:26): [True: 0, False: 72]
  ------------------
 2759|     72|       strlen(CHAR(STRING_ELT(enc, 0))) > 100) /* ASCII */
  ------------------
  |  |  203|     72|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (2759:8): [True: 0, False: 72]
  ------------------
 2760|      0|	error(_("invalid '%s' argument"), "encoding");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "encoding");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2761|     72|    if(type < 2) {
  ------------------
  |  Branch (2761:8): [True: 72, False: 0]
  ------------------
 2762|     72|	compress = asInteger(CADDDR(args));
  ------------------
  |  |  885|     72|#define asInteger		Rf_asInteger
  ------------------
 2763|     72|	if(compress == NA_LOGICAL || compress < 0 || compress > 9)
  ------------------
  |  |   55|    144|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (2763:5): [True: 0, False: 72]
  |  Branch (2763:31): [True: 0, False: 72]
  |  Branch (2763:47): [True: 0, False: 72]
  ------------------
 2764|      0|	    error(_("invalid '%s' argument"), "compress");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' argument"), "compress");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2765|     72|    }
 2766|     72|    if(type == 2) {
  ------------------
  |  Branch (2766:8): [True: 0, False: 72]
  ------------------
 2767|      0|	compress = asInteger(CADDDR(args));
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
 2768|      0|	if(compress == NA_LOGICAL || abs(compress) > 9)
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (2768:5): [True: 0, False: 0]
  |  Branch (2768:31): [True: 0, False: 0]
  ------------------
 2769|      0|	    error(_("invalid '%s' argument"), "compress");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' argument"), "compress");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2770|      0|    }
 2771|     72|    if(type == 3) {
  ------------------
  |  Branch (2771:8): [True: 0, False: 72]
  ------------------
 2772|      0|	compress = asInteger(CADDDR(args));
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
 2773|      0|	if(compress == NA_LOGICAL || abs(compress) > 19)
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (2773:5): [True: 0, False: 0]
  |  Branch (2773:31): [True: 0, False: 0]
  ------------------
 2774|      0|	    error(_("invalid '%s' argument"), "compress");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' argument"), "compress");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2775|      0|    }
 2776|     72|    open = CHAR(STRING_ELT(sopen, 0)); /* ASCII */
  ------------------
  |  |  203|     72|#define CHAR(x) R_CHAR(x)
  ------------------
 2777|     72|    if (type == 0 && (!open[0] || open[0] == 'r')) {
  ------------------
  |  Branch (2777:9): [True: 72, False: 0]
  |  Branch (2777:23): [True: 0, False: 72]
  |  Branch (2777:35): [True: 72, False: 0]
  ------------------
 2778|       |	/* check magic no */
 2779|     72|	comp_type ct;
 2780|     72|	ct = comp_type_from_file(R_ExpandFileName(file), FALSE, &subtype);
 2781|     72|	switch(ct) {
  ------------------
  |  Branch (2781:9): [True: 72, False: 0]
  ------------------
 2782|     72|	case COMP_GZ:
  ------------------
  |  Branch (2782:2): [True: 72, False: 0]
  ------------------
 2783|     72|	case COMP_UNKNOWN: type = 0; break;
  ------------------
  |  Branch (2783:2): [True: 0, False: 72]
  ------------------
 2784|      0|	case COMP_BZ: type = 1; break;
  ------------------
  |  Branch (2784:2): [True: 0, False: 72]
  ------------------
 2785|      0|	case COMP_XZ: type = 2; break;
  ------------------
  |  Branch (2785:2): [True: 0, False: 72]
  ------------------
 2786|      0|	case COMP_ZSTD: type = 3; break;
  ------------------
  |  Branch (2786:2): [True: 0, False: 72]
  ------------------
 2787|     72|	}
 2788|     72|    }
 2789|     72|    switch(type) {
  ------------------
  |  Branch (2789:12): [True: 72, False: 0]
  ------------------
 2790|     72|    case 0:
  ------------------
  |  Branch (2790:5): [True: 72, False: 0]
  ------------------
 2791|       |	/* gzfile connection handles also transparent (uncompressed) files */
 2792|     72|	con = newgzfile(file, strlen(open) ? open : "rb", compress);
  ------------------
  |  Branch (2792:24): [True: 72, False: 0]
  ------------------
 2793|     72|	break;
 2794|      0|    case 1:
  ------------------
  |  Branch (2794:5): [True: 0, False: 72]
  ------------------
 2795|      0|	con = newbzfile(file, strlen(open) ? open : "rb", compress);
  ------------------
  |  Branch (2795:24): [True: 0, False: 0]
  ------------------
 2796|      0|	break;
 2797|      0|    case 2:
  ------------------
  |  Branch (2797:5): [True: 0, False: 72]
  ------------------
 2798|      0|	con = newxzfile(file, strlen(open) ? open : "rb", subtype, compress);
  ------------------
  |  Branch (2798:24): [True: 0, False: 0]
  ------------------
 2799|      0|	break;
 2800|      0|    case 3:
  ------------------
  |  Branch (2800:5): [True: 0, False: 72]
  ------------------
 2801|      0|	con = newzstdfile(file, strlen(open) ? open : "rb", compress);
  ------------------
  |  Branch (2801:26): [True: 0, False: 0]
  ------------------
 2802|      0|	break;
 2803|     72|    }
 2804|     72|    ncon = NextConnection();
 2805|     72|    Connections[ncon] = con;
 2806|     72|    con->blocking = TRUE;
 2807|     72|    strncpy(con->encname, CHAR(STRING_ELT(enc, 0)), 100); /* ASCII */
  ------------------
  |  |  203|     72|#define CHAR(x) R_CHAR(x)
  ------------------
 2808|     72|    con->encname[100 - 1] = '\0';
 2809|       |
 2810|       |    /* see the comment in do_url */
 2811|     72|    if (con->encname[0] && !streql(con->encname, "native.enc"))
  ------------------
  |  | 1498|     54|#define streql(s, t)	(!strcmp((s), (t)))
  ------------------
  |  Branch (2811:9): [True: 54, False: 18]
  |  Branch (2811:28): [True: 0, False: 54]
  ------------------
 2812|      0|	con->canseek = 0;
 2813|     72|    con->ex_ptr = PROTECT(R_MakeExternalPtr(con->id, install("connection"), R_NilValue));
  ------------------
  |  |  357|     72|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2814|       |
 2815|       |    /* open it if desired */
 2816|     72|    if(strlen(open))
  ------------------
  |  Branch (2816:8): [True: 72, False: 0]
  ------------------
 2817|     72|	checked_open(ncon);
 2818|       |
 2819|     72|    PROTECT(ans = ScalarInteger(ncon));
  ------------------
  |  |  357|     72|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2820|     72|    PROTECT(class = allocVector(STRSXP, 2));
  ------------------
  |  |  357|     72|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2821|     72|    switch(type) {
  ------------------
  |  Branch (2821:12): [True: 72, False: 0]
  ------------------
 2822|     72|    case 0:
  ------------------
  |  Branch (2822:5): [True: 72, False: 0]
  ------------------
 2823|     72|	SET_STRING_ELT(class, 0, mkChar("gzfile"));
  ------------------
  |  |  998|     72|#define mkChar			Rf_mkChar
  ------------------
 2824|     72|	break;
 2825|      0|    case 1:
  ------------------
  |  Branch (2825:5): [True: 0, False: 72]
  ------------------
 2826|      0|	SET_STRING_ELT(class, 0, mkChar("bzfile"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 2827|      0|	break;
 2828|      0|    case 2:
  ------------------
  |  Branch (2828:5): [True: 0, False: 72]
  ------------------
 2829|      0|	SET_STRING_ELT(class, 0, mkChar("xzfile"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 2830|      0|	break;
 2831|      0|    case 3:
  ------------------
  |  Branch (2831:5): [True: 0, False: 72]
  ------------------
 2832|      0|	SET_STRING_ELT(class, 0, mkChar("zstdfile"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 2833|      0|	break;
 2834|     72|    }
 2835|     72|    SET_STRING_ELT(class, 1, mkChar("connection"));
  ------------------
  |  |  998|     72|#define mkChar			Rf_mkChar
  ------------------
 2836|     72|    classgets(ans, class);
  ------------------
  |  |  894|     72|#define classgets		Rf_classgets
  ------------------
 2837|     72|    setAttrib(ans, R_ConnIdSymbol, con->ex_ptr);
  ------------------
  |  | 1027|     72|#define setAttrib		Rf_setAttrib
  ------------------
 2838|     72|    R_RegisterCFinalizerEx(con->ex_ptr, conFinalizer, FALSE);
 2839|     72|    UNPROTECT(3);
  ------------------
  |  |  358|     72|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2840|       |
 2841|     72|    return ans;
 2842|     72|}
do_isopen:
 4141|      2|{
 4142|      2|    Rconnection con;
 4143|      2|    int rw, res;
 4144|       |
 4145|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 4146|      2|    con = getConnection(asInteger(CAR(args)));
  ------------------
  |  |  885|      2|#define asInteger		Rf_asInteger
  ------------------
 4147|      2|    rw = asInteger(CADR(args));
  ------------------
  |  |  885|      2|#define asInteger		Rf_asInteger
  ------------------
 4148|      2|    res = con->isopen != FALSE;
 4149|      2|    switch(rw) {
 4150|      2|    case 0: break;
  ------------------
  |  Branch (4150:5): [True: 2, False: 0]
  ------------------
 4151|      0|    case 1: res = res & con->canread; break;
  ------------------
  |  Branch (4151:5): [True: 0, False: 2]
  ------------------
 4152|      0|    case 2: res = res & con->canwrite; break;
  ------------------
  |  Branch (4152:5): [True: 0, False: 2]
  ------------------
 4153|      0|    default: error(_("unknown 'rw' value"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  default: error(_("unknown 'rw' value"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (4153:5): [True: 0, False: 2]
  ------------------
 4154|      2|    }
 4155|      2|    return ScalarLogical(res);
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
 4156|      2|}
do_close:
 4253|     88|{
 4254|     88|    int i, j;
 4255|       |
 4256|     88|    checkArity(op, args);
  ------------------
  |  | 1788|     88|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 4257|     88|    if(!inherits(CAR(args), "connection"))
  ------------------
  |  |  933|     88|#define inherits		Rf_inherits
  ------------------
  |  Branch (4257:8): [True: 0, False: 88]
  ------------------
 4258|      0|	error(_("'con' is not a connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'con' is not a connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4259|     88|    i = asInteger(CAR(args));
  ------------------
  |  |  885|     88|#define asInteger		Rf_asInteger
  ------------------
 4260|     88|    if(i < 3) error(_("cannot close standard connections"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if(i < 3) error(_("cannot close standard connections"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (4260:8): [True: 0, False: 88]
  ------------------
 4261|     88|    for(j = 0; j < R_SinkNumber; j++)
  ------------------
  |  Branch (4261:16): [True: 0, False: 88]
  ------------------
 4262|      0|	if(i == SinkCons[j])
  ------------------
  |  Branch (4262:5): [True: 0, False: 0]
  ------------------
 4263|      0|	    error(_("cannot close 'output' sink connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("cannot close 'output' sink connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4264|     88|    if(i == R_ErrorCon)
  ------------------
  |  Branch (4264:8): [True: 0, False: 88]
  ------------------
 4265|      0|	error(_("cannot close 'message' sink connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot close 'message' sink connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4266|     88|    Rconnection con = getConnection(i);
 4267|     88|    int status = con_close1(con);
 4268|     88|    free(Connections[i]);
 4269|     88|    Connections[i] = NULL;
 4270|     88|    return (status != NA_INTEGER) ? ScalarInteger(status) : R_NilValue;
  ------------------
  |  |   56|     88|#define NA_INTEGER	R_NaInt
  ------------------
                  return (status != NA_INTEGER) ? ScalarInteger(status) : R_NilValue;
  ------------------
  |  | 1022|     16|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  |  Branch (4270:12): [True: 16, False: 72]
  ------------------
 4271|     88|}
Rconn_fgetc:
 4332|  17.0k|{
 4333|  17.0k|    char *curLine;
 4334|  17.0k|    int c;
 4335|       |
 4336|  17.0k|    if (con->save2 != -1000) {
  ------------------
  |  Branch (4336:9): [True: 0, False: 17.0k]
  ------------------
 4337|      0|	c = con->save2;
 4338|      0|	con->save2 = -1000;
 4339|      0|	return c;
 4340|      0|    }
 4341|  17.0k|    if(con->nPushBack <= 0) {
  ------------------
  |  Branch (4341:8): [True: 15.8k, False: 1.25k]
  ------------------
 4342|       |	/* map CR or CRLF to LF */
 4343|  15.8k|	if (con->save != -1000) {
  ------------------
  |  Branch (4343:6): [True: 0, False: 15.8k]
  ------------------
 4344|      0|	    c = con->save;
 4345|      0|	    con->save = -1000;
 4346|      0|	    return c;
 4347|      0|	}
 4348|  15.8k|	c = con->fgetc(con);
 4349|  15.8k|	if (c == '\r') {
  ------------------
  |  Branch (4349:6): [True: 0, False: 15.8k]
  ------------------
 4350|      0|	    c = con->fgetc(con);
 4351|      0|	    if (c != '\n') {
  ------------------
  |  Branch (4351:10): [True: 0, False: 0]
  ------------------
 4352|      0|		con->save = (c != '\r') ? c : '\n';
  ------------------
  |  Branch (4352:15): [True: 0, False: 0]
  ------------------
 4353|      0|		return('\n');
 4354|      0|	    }
 4355|      0|	}
 4356|  15.8k|	return c;
 4357|  15.8k|    }
 4358|  1.25k|    curLine = con->PushBack[con->nPushBack-1];
 4359|  1.25k|    c = (unsigned char) curLine[con->posPushBack++];
 4360|  1.25k|    if(con->posPushBack >= strlen(curLine)) {
  ------------------
  |  Branch (4360:8): [True: 20, False: 1.23k]
  ------------------
 4361|       |	/* last character on a line, so pop the line */
 4362|     20|	free(curLine);
 4363|     20|	con->nPushBack--;
 4364|     20|	con->posPushBack = 0;
 4365|     20|	if(con->nPushBack == 0) free(con->PushBack);
  ------------------
  |  Branch (4365:5): [True: 2, False: 18]
  ------------------
 4366|     20|    }
 4367|  1.25k|    return c;
 4368|  17.0k|}
do_readLines:
 4448|      2|{
 4449|      2|    SEXP ans = R_NilValue, ans2;
 4450|      2|    int ok, warn, skipNul, c;
 4451|      2|    size_t nbuf, buf_size = BUF_SIZE;
  ------------------
  |  | 4446|      2|#define BUF_SIZE 1000
  ------------------
 4452|      2|    int oenc = CE_NATIVE;
 4453|      2|    Rconnection con = NULL;
 4454|      2|    Rboolean wasopen;
 4455|      2|    char *buf = NULL;
 4456|      2|    const char *encoding;
 4457|      2|    RCNTXT cntxt;
 4458|      2|    R_xlen_t i, n, nn, nnn, nread;
 4459|       |
 4460|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 4461|      2|    if(!inherits(CAR(args), "connection"))
  ------------------
  |  |  933|      2|#define inherits		Rf_inherits
  ------------------
  |  Branch (4461:8): [True: 0, False: 2]
  ------------------
 4462|      0|	error(_("'con' is not a connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'con' is not a connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4463|      2|    con = getConnection(asInteger(CAR(args))); args = CDR(args);
  ------------------
  |  |  885|      2|#define asInteger		Rf_asInteger
  ------------------
 4464|      2|    n = asVecSize(CAR(args)); args = CDR(args);
  ------------------
  |  | 1862|      2|# define asVecSize		Rf_asVecSize
  ------------------
 4465|      2|    if(n == -999)
  ------------------
  |  Branch (4465:8): [True: 0, False: 2]
  ------------------
 4466|      0|	error(_("invalid '%s' argument"), "n");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "n");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4467|      2|    ok = asLogical(CAR(args));  args = CDR(args);
  ------------------
  |  |  886|      2|#define asLogical		Rf_asLogical
  ------------------
 4468|      2|    if(ok == NA_LOGICAL)
  ------------------
  |  |   55|      2|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (4468:8): [True: 0, False: 2]
  ------------------
 4469|      0|	error(_("invalid '%s' argument"), "ok");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "ok");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4470|      2|    warn = asLogical(CAR(args));  args = CDR(args);
  ------------------
  |  |  886|      2|#define asLogical		Rf_asLogical
  ------------------
 4471|      2|    if(warn == NA_LOGICAL)
  ------------------
  |  |   55|      2|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (4471:8): [True: 0, False: 2]
  ------------------
 4472|      0|	error(_("invalid '%s' argument"), "warn");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "warn");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4473|      2|    if(!isString(CAR(args)) || LENGTH(CAR(args)) != 1)
  ------------------
  |  |  966|      2|#define isString		Rf_isString
  ------------------
  |  Branch (4473:8): [True: 0, False: 2]
  |  Branch (4473:32): [True: 0, False: 2]
  ------------------
 4474|      0|	error(_("invalid '%s' value"), "encoding");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' value"), "encoding");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4475|      2|    encoding = CHAR(STRING_ELT(CAR(args), 0));  args = CDR(args); /* ASCII */
  ------------------
  |  |  203|      2|#define CHAR(x) R_CHAR(x)
  ------------------
 4476|      2|    skipNul = asLogical(CAR(args));
  ------------------
  |  |  886|      2|#define asLogical		Rf_asLogical
  ------------------
 4477|      2|    if(skipNul == NA_LOGICAL)
  ------------------
  |  |   55|      2|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (4477:8): [True: 0, False: 2]
  ------------------
 4478|      0|	error(_("invalid '%s' argument"), "skipNul");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "skipNul");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4479|       |
 4480|       |    /* Clean up the current buffer and any connection opened here on error. */
 4481|      2|    readLines_data data = {&buf, NULL};
 4482|      2|    begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
  ------------------
  |  | 1864|      2|# define begincontext		Rf_begincontext
  ------------------
 4483|      2|		 R_NilValue, R_NilValue);
 4484|      2|    cntxt.cend = &readLines_cleanup;
 4485|      2|    cntxt.cenddata = &data;
 4486|       |
 4487|      2|    wasopen = con->isopen;
 4488|      2|    if(!wasopen) {
  ------------------
  |  Branch (4488:8): [True: 0, False: 2]
  ------------------
 4489|      0|	char mode[5];
 4490|      0|	con->UTF8out = TRUE;  /* a request */
 4491|      0|	strcpy(mode, con->mode);
 4492|      0|	strcpy(con->mode, "rt");
 4493|      0|	if(!con->open(con)) error(_("cannot open the connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if(!con->open(con)) error(_("cannot open the connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (4493:5): [True: 0, False: 0]
  ------------------
 4494|      0|	strcpy(con->mode, mode);
 4495|      0|	data.con = con;
 4496|      0|	if(!con->canread) error(_("cannot read from this connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if(!con->canread) error(_("cannot read from this connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (4496:5): [True: 0, False: 0]
  ------------------
 4497|      2|    } else {
 4498|      2|	if(!con->canread) error(_("cannot read from this connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if(!con->canread) error(_("cannot read from this connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (4498:5): [True: 0, False: 2]
  ------------------
 4499|       |	/* for a non-blocking connection, more input may
 4500|       |	   have become available, so re-position */
 4501|      2|	if(con->canseek && !con->blocking)
  ------------------
  |  Branch (4501:5): [True: 2, False: 0]
  |  Branch (4501:21): [True: 0, False: 2]
  ------------------
 4502|      0|	    Rconn_seek(con, Rconn_seek(con, -1, 1, 1), 1, 1);
 4503|      2|    }
 4504|      2|    con->incomplete = FALSE;
 4505|      2|    if(con->UTF8out || streql(encoding, "UTF-8")) oenc = CE_UTF8;
  ------------------
  |  | 1498|      2|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  |  Branch (4505:8): [True: 0, False: 2]
  ------------------
 4506|      2|    else if(streql(encoding, "latin1")) oenc = CE_LATIN1;
  ------------------
  |  | 1498|      2|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 4507|      2|    else if(streql(encoding, "bytes")) oenc = CE_BYTES;
  ------------------
  |  | 1498|      2|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 4508|       |
 4509|      2|    buf = (char *) malloc(buf_size);
 4510|      2|    if(!buf)
  ------------------
  |  Branch (4510:8): [True: 0, False: 2]
  ------------------
 4511|      0|	error(_("cannot allocate buffer in readLines"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot allocate buffer in readLines"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4512|      2|    nn = (n < 0) ? 1000 : n; /* initially allocate space for 1000 lines */
  ------------------
  |  Branch (4512:10): [True: 2, False: 0]
  ------------------
 4513|      2|    nnn = (n < 0) ? R_XLEN_T_MAX : n;
  ------------------
  |  |   76|      2|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (4513:11): [True: 2, False: 0]
  ------------------
 4514|      2|    PROTECT(ans = allocVector(STRSXP, nn));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4515|     26|    for(nread = 0; nread < nnn; nread++) {
  ------------------
  |  Branch (4515:20): [True: 26, False: 0]
  ------------------
 4516|     26|	if(nread >= nn) {
  ------------------
  |  Branch (4516:5): [True: 0, False: 26]
  ------------------
 4517|      0|	    double dnn = 2. * (double) nn;
 4518|      0|	    if (dnn > R_XLEN_T_MAX) error("too many items");
  ------------------
  |  |   76|      0|# define R_XLEN_T_MAX 4503599627370496
  ------------------
              	    if (dnn > R_XLEN_T_MAX) error("too many items");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (4518:10): [True: 0, False: 0]
  ------------------
 4519|      0|	    ans2 = allocVector(STRSXP, 2*nn);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	    ans2 = allocVector(STRSXP, 2*nn);
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
 4520|      0|	    for(i = 0; i < nn; i++)
  ------------------
  |  Branch (4520:17): [True: 0, False: 0]
  ------------------
 4521|      0|		SET_STRING_ELT(ans2, i, STRING_ELT(ans, i));
 4522|      0|	    nn *= 2;
 4523|      0|	    UNPROTECT(1); /* old ans */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4524|      0|	    PROTECT(ans = ans2);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4525|      0|	}
 4526|     26|	nbuf = 0;
 4527|    766|	while((c = Rconn_fgetc(con)) != R_EOF) {
  ------------------
  |  | 1531|    766|#define R_EOF	-1
  ------------------
  |  Branch (4527:8): [True: 764, False: 2]
  ------------------
 4528|    764|	    if(nbuf == buf_size-1) {  /* need space for the terminator */
  ------------------
  |  Branch (4528:9): [True: 0, False: 764]
  ------------------
 4529|      0|		buf_size *= 2;
 4530|      0|		char *tmp = (char *) realloc(buf, buf_size);
 4531|      0|		if(!tmp)
  ------------------
  |  Branch (4531:6): [True: 0, False: 0]
  ------------------
 4532|      0|		    error(_("cannot allocate buffer in readLines"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("cannot allocate buffer in readLines"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4533|      0|		buf = tmp;
 4534|      0|	    }
 4535|    764|	    if(skipNul && c == '\0') continue;
  ------------------
  |  Branch (4535:9): [True: 0, False: 764]
  |  Branch (4535:20): [True: 0, False: 0]
  ------------------
 4536|    764|	    if(c != '\n')
  ------------------
  |  Branch (4536:9): [True: 740, False: 24]
  ------------------
 4537|       |		/* compiler-defined conversion behavior */
 4538|    740|		buf[nbuf++] = (char) c;
 4539|     24|	    else
 4540|     24|		break;
 4541|    764|	}
 4542|     26|	buf[nbuf] = '\0';
 4543|       |	/* Remove UTF-8 BOM */
 4544|     26|	const char *qbuf = buf;
 4545|       |	// avoid valgrind warning if < 3 bytes
 4546|     26|	if (nread == 0 && utf8locale && strlen(buf) >= 3 &&
  ------------------
  |  Branch (4546:6): [True: 2, False: 24]
  |  Branch (4546:20): [True: 0, False: 2]
  |  Branch (4546:34): [True: 0, False: 0]
  ------------------
 4547|      0|	    !memcmp(buf, "\xef\xbb\xbf", 3)) qbuf = buf + 3;
  ------------------
  |  Branch (4547:6): [True: 0, False: 0]
  ------------------
 4548|     26|	SET_STRING_ELT(ans, nread, mkCharCE(qbuf, oenc));
  ------------------
  |  |  999|     26|#define mkCharCE		Rf_mkCharCE
  ------------------
 4549|     26|	if (warn && strlen(buf) < nbuf)
  ------------------
  |  Branch (4549:6): [True: 26, False: 0]
  |  Branch (4549:14): [True: 0, False: 26]
  ------------------
 4550|      0|	    warning(_("line %lld appears to contain an embedded nul"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("line %lld appears to contain an embedded nul"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4551|      0|	            (long long)nread + 1);
 4552|     26|	if(c == R_EOF) goto no_more_lines;
  ------------------
  |  | 1531|     26|#define R_EOF	-1
  ------------------
  |  Branch (4552:5): [True: 2, False: 24]
  ------------------
 4553|     26|    }
 4554|      0|    if(!wasopen) {
  ------------------
  |  Branch (4554:8): [True: 0, False: 0]
  ------------------
 4555|      0|	data.con = NULL; /* do not close again if closing raises an error */
 4556|      0|	con->close(con);
 4557|      0|    }
 4558|      0|    endcontext(&cntxt);
  ------------------
  |  | 1895|      0|# define endcontext		Rf_endcontext
  ------------------
 4559|      0|    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4560|      0|    free(buf);
 4561|      0|    return ans;
 4562|      2|no_more_lines:
 4563|      2|    if(!wasopen) {
  ------------------
  |  Branch (4563:8): [True: 0, False: 2]
  ------------------
 4564|      0|	data.con = NULL;
 4565|      0|	con->close(con);
 4566|      0|    }
 4567|      2|    if(nbuf > 0) { /* incomplete last line */
  ------------------
  |  Branch (4567:8): [True: 0, False: 2]
  ------------------
 4568|      0|	if(con->text && !con->blocking &&
  ------------------
  |  Branch (4568:5): [True: 0, False: 0]
  |  Branch (4568:18): [True: 0, False: 0]
  ------------------
 4569|      0|	   (strcmp(con->class, "gzfile") != 0)) {
  ------------------
  |  Branch (4569:5): [True: 0, False: 0]
  ------------------
 4570|       |	    /* push back the rest */
 4571|      0|	    con_pushback(con, 0, buf);
  ------------------
  |  |   71|      0|#define con_pushback	Rf_con_pushback
  ------------------
 4572|      0|	    con->incomplete = TRUE;
 4573|      0|	} else {
 4574|      0|	    nread++;
 4575|      0|	    if(warn)
  ------------------
  |  Branch (4575:9): [True: 0, False: 0]
  ------------------
 4576|      0|		warning(_("incomplete final line found on '%s'"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		warning(_("incomplete final line found on '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4577|      0|			con->description);
 4578|      0|	}
 4579|      0|    }
 4580|      2|    endcontext(&cntxt);
  ------------------
  |  | 1895|      2|# define endcontext		Rf_endcontext
  ------------------
 4581|      2|    free(buf);
 4582|      2|    if(nread < nnn && !ok)
  ------------------
  |  Branch (4582:8): [True: 2, False: 0]
  |  Branch (4582:23): [True: 0, False: 2]
  ------------------
 4583|      0|	error(_("too few lines read in readLines"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("too few lines read in readLines"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4584|      2|    PROTECT(ans2 = allocVector(STRSXP, nread));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4585|     26|    for(i = 0; i < nread; i++)
  ------------------
  |  Branch (4585:16): [True: 24, False: 2]
  ------------------
 4586|     24|	SET_STRING_ELT(ans2, i, STRING_ELT(ans, i));
 4587|      2|    UNPROTECT(2);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4588|      2|    return ans2;
 4589|      2|}
do_pushback:
 5645|      2|{
 5646|      2|    int i, n, nexists, newLine, type;
 5647|      2|    Rconnection con = NULL;
 5648|      2|    SEXP stext;
 5649|      2|    const char *p;
 5650|      2|    char **q;
 5651|       |
 5652|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 5653|       |
 5654|      2|    stext = CAR(args);
 5655|      2|    if(!isString(stext))
  ------------------
  |  |  966|      2|#define isString		Rf_isString
  ------------------
  |  Branch (5655:8): [True: 0, False: 2]
  ------------------
 5656|      0|	error(_("invalid '%s' argument"), "data");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "data");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5657|      2|    con = getConnection(asInteger(CADR(args)));
  ------------------
  |  |  885|      2|#define asInteger		Rf_asInteger
  ------------------
 5658|      2|    newLine = asLogical(CADDR(args));
  ------------------
  |  |  886|      2|#define asLogical		Rf_asLogical
  ------------------
 5659|      2|    if(newLine == NA_LOGICAL)
  ------------------
  |  |   55|      2|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (5659:8): [True: 0, False: 2]
  ------------------
 5660|      0|	error(_("invalid '%s' argument"), "newLine");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "newLine");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5661|      2|    type = asInteger(CADDDR(args));
  ------------------
  |  |  885|      2|#define asInteger		Rf_asInteger
  ------------------
 5662|      2|    if(!con->canread && !con->isopen)
  ------------------
  |  Branch (5662:8): [True: 0, False: 2]
  |  Branch (5662:25): [True: 0, False: 0]
  ------------------
 5663|      0|	error(_("can only push back on open readable connections"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("can only push back on open readable connections"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5664|      2|    if(!con->text)
  ------------------
  |  Branch (5664:8): [True: 0, False: 2]
  ------------------
 5665|      0|	error(_("can only push back on text-mode connections"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("can only push back on text-mode connections"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5666|      2|    nexists = con->nPushBack;
 5667|      2|    if((n = LENGTH(stext)) > 0) {
  ------------------
  |  Branch (5667:8): [True: 2, False: 0]
  ------------------
 5668|      2|	if(nexists > 0)
  ------------------
  |  Branch (5668:5): [True: 0, False: 2]
  ------------------
 5669|      0|	    q = (char **) realloc(con->PushBack, (n+nexists)*sizeof(char *));
 5670|      2|	else
 5671|      2|	    q = (char **) malloc(n*sizeof(char *));
 5672|      2|	if(!q) error(_("could not allocate space for pushback"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if(!q) error(_("could not allocate space for pushback"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (5672:5): [True: 0, False: 2]
  ------------------
 5673|      2|	con->PushBack = q;
 5674|      2|	q += nexists;
 5675|     22|	for(i = 0; i < n; i++) {
  ------------------
  |  Branch (5675:13): [True: 20, False: 2]
  ------------------
 5676|     20|	    p = type == 1 ? translateChar(STRING_ELT(stext, n - i - 1))
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  |  Branch (5676:10): [True: 0, False: 20]
  ------------------
 5677|     20|			  : ((type == 3) ? translateCharUTF8(STRING_ELT(stext, n - i - 1))
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  |  Branch (5677:9): [True: 0, False: 20]
  ------------------
 5678|     20|					 : CHAR(STRING_ELT(stext, n - i - 1)));
  ------------------
  |  |  203|     20|#define CHAR(x) R_CHAR(x)
  ------------------
 5679|     20|	    *q = (char *) malloc(strlen(p) + 1 + newLine);
 5680|     20|	    if(!(*q)) error(_("could not allocate space for pushback"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    if(!(*q)) error(_("could not allocate space for pushback"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (5680:9): [True: 0, False: 20]
  ------------------
 5681|     20|	    strcpy(*q, p);
 5682|     20|	    if(newLine) strcat(*q, "\n");
  ------------------
  |  Branch (5682:9): [True: 20, False: 0]
  ------------------
 5683|     20|	    q++;
 5684|     20|	}
 5685|      2|	con->posPushBack = 0;
 5686|      2|	con->nPushBack += n;
 5687|      2|    }
 5688|      2|    return R_NilValue;
 5689|      2|}
R_SetNconn:
 5842|      2|{
 5843|      2|    if (nconn > 128) NCONNECTIONS = nconn;
  ------------------
  |  Branch (5843:9): [True: 0, False: 2]
  ------------------
 5844|      2|}
Rf_InitConnections:
 5848|      2|{
 5849|      2|    Connections = (Rconnection *) malloc(NCONNECTIONS * sizeof(Rconnection));
 5850|      2|    if (!Connections)
  ------------------
  |  Branch (5850:9): [True: 0, False: 2]
  ------------------
 5851|      0|	R_Suicide("could not allocate space for the connections table");
 5852|      2|    Connections[0] = newterminal("stdin", "r");
 5853|      2|    Connections[0]->fgetc = stdin_fgetc;
 5854|      2|    Connections[1] = newterminal("stdout", "w");
 5855|      2|    Connections[1]->vfprintf = stdout_vfprintf;
 5856|      2|    Connections[1]->fflush = stdout_fflush;
 5857|      2|    Connections[2] = newterminal("stderr", "w");
 5858|      2|    Connections[2]->vfprintf = stderr_vfprintf;
 5859|      2|    Connections[2]->fflush = stderr_fflush;
 5860|    252|    for(int i = 3; i < NCONNECTIONS; i++) Connections[i] = NULL;
  ------------------
  |  Branch (5860:20): [True: 250, False: 2]
  ------------------
 5861|      2|    R_OutputCon = 1;
 5862|      2|    R_SinkNumber = 0;
 5863|      2|    SinkCons[0] = 1; R_ErrorCon = 2;
 5864|      2|}
do_url:
 5956|     16|{
 5957|     16|    SEXP scmd, sopen, ans, class, enc, headers = R_NilValue;
 5958|       |#ifdef Win32
 5959|       |    SEXP headers_flat = R_NilValue;
 5960|       |#endif
 5961|     16|    char *class2 = "url";
 5962|     16|    const char *url, *open;
 5963|     16|    int ncon, block, defmeth,
 5964|     16|	meth = 0, // 0: "internal" | "wininet", 1: "libcurl"
 5965|     16|	winmeth = 0;  // 0: "internal", 1: "wininet" (Windows only)
 5966|     16|    cetype_t ienc = CE_NATIVE;
 5967|     16|    Rconnection con = NULL;
 5968|     16|    Rboolean raw = FALSE;
 5969|       |
 5970|     16|    checkArity(op, args);
  ------------------
  |  | 1788|     16|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 5971|       |    // --------- description
 5972|     16|    scmd = CAR(args);
 5973|     16|    if(!isString(scmd) || LENGTH(scmd) != 1 ||
  ------------------
  |  |  966|     16|#define isString		Rf_isString
  ------------------
  |  Branch (5973:8): [True: 0, False: 16]
  |  Branch (5973:27): [True: 0, False: 16]
  ------------------
 5974|     16|       STRING_ELT(scmd, 0) == NA_STRING)
  ------------------
  |  |  433|     16|#define NA_STRING	R_NaString
  ------------------
  |  Branch (5974:8): [True: 0, False: 16]
  ------------------
 5975|      0|	error(_("invalid '%s' argument"), "description");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "description");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5976|     16|    if(LENGTH(scmd) > 1)
  ------------------
  |  Branch (5976:8): [True: 0, False: 16]
  ------------------
 5977|      0|	warning(_("only first element of 'description' argument used"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("only first element of 'description' argument used"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5978|       |#ifdef Win32
 5979|       |    winmeth = 1;
 5980|       |    if(PRIMVAL(op) == 1 && !IS_ASCII(STRING_ELT(scmd, 0)) ) { // file(<non-ASCII>, *)
 5981|       |	ienc = CE_UTF8;
 5982|       |	url = trCharUTF8(STRING_ELT(scmd, 0));
 5983|       |    } else {
 5984|       |	ienc = getCharCE(STRING_ELT(scmd, 0));
 5985|       |	if(ienc == CE_UTF8)
 5986|       |	    url = CHAR(STRING_ELT(scmd, 0));
 5987|       |	else
 5988|       |	    url = translateCharFP(STRING_ELT(scmd, 0));
 5989|       |    }
 5990|       |#else
 5991|     16|    winmeth = 0;
 5992|     16|    url = translateCharFP(STRING_ELT(scmd, 0));
  ------------------
  |  | 1998|     16|# define translateCharFP	Rf_translateCharFP
  ------------------
 5993|     16|#endif
 5994|       |
 5995|       |    // curl-based url() does not need to know the type. so
 5996|       |    // only set for use by the wininet method.
 5997|       |#ifdef Win32
 5998|       |    UrlScheme type = HTTPsh;	/* -Wall */
 5999|       |#endif
 6000|     16|    Rboolean inet = TRUE;
 6001|     16|    if (strncmp(url, "http://", 7) == 0) {
  ------------------
  |  Branch (6001:9): [True: 0, False: 16]
  ------------------
 6002|       |#ifdef Win32
 6003|       |	type = HTTPsh;
 6004|       |#endif
 6005|     16|    } else if (strncmp(url, "ftp://", 6) == 0) {
  ------------------
  |  Branch (6005:16): [True: 0, False: 16]
  ------------------
 6006|       |#ifdef Win32
 6007|       |	type = FTPsh;
 6008|       |#endif
 6009|     16|    } else if (strncmp(url, "https://", 8) == 0) {
  ------------------
  |  Branch (6009:16): [True: 0, False: 16]
  ------------------
 6010|       |#ifdef Win32
 6011|       |	type = HTTPSsh;
 6012|       | #endif
 6013|       |    // ftps:// is available via most libcurl, only
 6014|     16|    } else if (strncmp(url, "ftps://", 7) == 0) {
  ------------------
  |  Branch (6014:16): [True: 0, False: 16]
  ------------------
 6015|       |#ifdef Win32
 6016|       |	type = FTPSsh;
 6017|       |#endif
 6018|      0|    } else
 6019|     16|	inet = FALSE; // file:// URL or a file path
 6020|       |
 6021|       |    // --------- open
 6022|     16|    sopen = CADR(args);
 6023|     16|    if(!isString(sopen) || LENGTH(sopen) != 1)
  ------------------
  |  |  966|     16|#define isString		Rf_isString
  ------------------
  |  Branch (6023:8): [True: 0, False: 16]
  |  Branch (6023:28): [True: 0, False: 16]
  ------------------
 6024|      0|	error(_("invalid '%s' argument"), "open");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "open");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6025|     16|    open = CHAR(STRING_ELT(sopen, 0)); /* ASCII */
  ------------------
  |  |  203|     16|#define CHAR(x) R_CHAR(x)
  ------------------
 6026|       |    // --------- blocking
 6027|     16|    block = asLogical(CADDR(args));
  ------------------
  |  |  886|     16|#define asLogical		Rf_asLogical
  ------------------
 6028|     16|    if(block == NA_LOGICAL)
  ------------------
  |  |   55|     16|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (6028:8): [True: 0, False: 16]
  ------------------
 6029|      0|	error(_("invalid '%s' argument"), "blocking");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "blocking");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6030|       |    // --------- encoding
 6031|     16|    enc = CADDDR(args);
 6032|     16|    if(!isString(enc) || LENGTH(enc) != 1 ||
  ------------------
  |  |  966|     16|#define isString		Rf_isString
  ------------------
  |  Branch (6032:8): [True: 0, False: 16]
  |  Branch (6032:26): [True: 0, False: 16]
  ------------------
 6033|     16|       strlen(CHAR(STRING_ELT(enc, 0))) > 100) /* ASCII */
  ------------------
  |  |  203|     16|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (6033:8): [True: 0, False: 16]
  ------------------
 6034|      0|	error(_("invalid '%s' argument"), "encoding");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "encoding");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6035|       |
 6036|       |    // --------- method
 6037|     16|    const char *cmeth = CHAR(asChar(CAD4R(args)));
  ------------------
  |  |  203|     16|#define CHAR(x) R_CHAR(x)
  ------------------
 6038|     16|    meth = streql(cmeth, "libcurl"); // 1 if "libcurl", else 0
  ------------------
  |  | 1498|     16|#define streql(s, t)	(!strcmp((s), (t)))
  ------------------
 6039|     16|    defmeth = streql(cmeth, "default");
  ------------------
  |  | 1498|     16|#define streql(s, t)	(!strcmp((s), (t)))
  ------------------
 6040|       |//#ifndef Win32
 6041|     16|    if(defmeth) meth = 1; // default to libcurl
  ------------------
  |  Branch (6041:8): [True: 16, False: 0]
  ------------------
 6042|       |//#endif
 6043|     16|    if (streql(cmeth, "wininet")) {
  ------------------
  |  | 1498|     16|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 16]
  |  |  ------------------
  ------------------
 6044|       |#ifdef Win32
 6045|       |	winmeth = 1;
 6046|       |#else
 6047|      0|	error(_("method = \"wininet\" is only supported on Windows"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("method = \"wininet\" is only supported on Windows"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6048|      0|#endif
 6049|      0|    }
 6050|       |#ifdef Win32
 6051|       |    else if (streql(cmeth, "internal")) winmeth = 0;
 6052|       |#endif
 6053|       |
 6054|       |    // --------- raw, for file() only
 6055|     16|    if(PRIMVAL(op) == 1) {
  ------------------
  |  | 1347|     16|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (6055:8): [True: 16, False: 0]
  ------------------
 6056|     16|	raw = asRbool(CAD5R(args), call);
  ------------------
  |  | 1861|     16|# define asRbool		Rf_asRbool
  ------------------
 6057|     16|	if(raw == NA_LOGICAL)
  ------------------
  |  |   55|     16|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (6057:5): [True: 0, False: 16]
  ------------------
 6058|      0|	    error(_("invalid '%s' argument"), "raw");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' argument"), "raw");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6059|     16|    }
 6060|       |
 6061|       |    // --------- headers, for url() only
 6062|     16|    if(PRIMVAL(op) == 0) {
  ------------------
  |  | 1347|     16|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (6062:8): [True: 0, False: 16]
  ------------------
 6063|      0| 	SEXP lheaders = CAD5R(args);
 6064|      0|	if (!isNull(lheaders)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (6064:6): [True: 0, False: 0]
  ------------------
 6065|      0|	    headers = VECTOR_ELT(lheaders, 0);
 6066|       |#ifdef Win32
 6067|       |	    headers_flat = VECTOR_ELT(lheaders, 1);
 6068|       |#endif
 6069|      0|	}
 6070|      0|    }
 6071|       |
 6072|     16|    if(!meth) {
  ------------------
  |  Branch (6072:8): [True: 0, False: 16]
  ------------------
 6073|      0|	if (strncmp(url, "ftps://", 7) == 0) {
  ------------------
  |  Branch (6073:6): [True: 0, False: 0]
  ------------------
 6074|      0|#ifdef HAVE_LIBCURL
 6075|      0|	    if (defmeth) meth = 1; else
  ------------------
  |  Branch (6075:10): [True: 0, False: 0]
  ------------------
 6076|      0|#endif
 6077|      0|		error("ftps:// URLs are not supported by this method");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 6078|      0|	}
 6079|       |#ifdef Win32
 6080|       |	if (!winmeth && strncmp(url, "https://", 8) == 0) {
 6081|       |# ifdef HAVE_LIBCURL
 6082|       |	    if (defmeth) meth = 1; else
 6083|       |# endif
 6084|       |		error("https:// URLs are not supported by this method");
 6085|       |	}
 6086|       |#else // Unix
 6087|      0|	if (strncmp(url, "https://", 8) == 0) {
  ------------------
  |  Branch (6087:6): [True: 0, False: 0]
  ------------------
 6088|       |	    // We check the libcurl build does support https as from R 3.3.0
 6089|      0|	    if (defmeth) meth = 1; else
  ------------------
  |  Branch (6089:10): [True: 0, False: 0]
  ------------------
 6090|      0|		error("https:// URLs are not supported by the \"internal\" method");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 6091|      0|	}
 6092|      0|#endif
 6093|      0|    }
 6094|       |
 6095|     16|    ncon = NextConnection();
 6096|     16|    if(strncmp(url, "file://", 7) == 0) {
  ------------------
  |  Branch (6096:8): [True: 0, False: 16]
  ------------------
 6097|      0|	int nh = 7;
 6098|       |#ifdef Win32
 6099|       |	/* on Windows we have file:///d:/path/to
 6100|       |	   whereas on Unix it is file:///path/to */
 6101|       |	if (strlen(url) > 9 && url[7] == '/' && url[9] == ':') nh = 8;
 6102|       |#endif
 6103|      0|	con = newfile(url + nh, ienc, strlen(open) ? open : "r", raw);
  ------------------
  |  Branch (6103:32): [True: 0, False: 0]
  ------------------
 6104|      0|	class2 = "file";
 6105|     16|    } else if (inet) {
  ------------------
  |  Branch (6105:16): [True: 0, False: 16]
  ------------------
 6106|      0|	if(meth) {
  ------------------
  |  Branch (6106:5): [True: 0, False: 0]
  ------------------
 6107|      0|# ifdef HAVE_LIBCURL
 6108|      0|	    con = R_newCurlUrl(url, strlen(open) ? open : "r", headers, 0);
  ------------------
  |  Branch (6108:30): [True: 0, False: 0]
  ------------------
 6109|       |# else
 6110|       |	    error("url(method = \"libcurl\") is not supported on this platform");
 6111|       |# endif
 6112|      0|	} else {
 6113|      0|	    if(!winmeth)
  ------------------
  |  Branch (6113:9): [True: 0, False: 0]
  ------------------
 6114|      0|		error(_("the 'internal' method of url() is defunct for http:// and ftp:// URLs"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("the 'internal' method of url() is defunct for http:// and ftp:// URLs"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6115|       |#ifdef Win32
 6116|       |	    // so for "wininet' only
 6117|       |	    con = R_newurl(url, strlen(open) ? open : "r", headers_flat, winmeth);
 6118|       |	    ((Rurlconn)con->private)->type = type;
 6119|       |#endif
 6120|      0|	}
 6121|     16|    } else {
 6122|     16|	if(PRIMVAL(op) == 1) { /* call to file() */
  ------------------
  |  | 1347|     16|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (6122:5): [True: 16, False: 0]
  ------------------
 6123|     16|	    if(strlen(url) == 0) {
  ------------------
  |  Branch (6123:9): [True: 0, False: 16]
  ------------------
 6124|      0|		if(!strlen(open)) open ="w+";
  ------------------
  |  Branch (6124:6): [True: 0, False: 0]
  ------------------
 6125|      0|		if(strcmp(open, "w+") != 0 && strcmp(open, "w+b") != 0) {
  ------------------
  |  Branch (6125:6): [True: 0, False: 0]
  |  Branch (6125:33): [True: 0, False: 0]
  ------------------
 6126|      0|		    open ="w+";
 6127|      0|		    warning(_("file(\"\") only supports open = \"w+\" and open = \"w+b\": using the former"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		    warning(_("file(\"\") only supports open = \"w+\" and open = \"w+b\": using the former"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6128|      0|		}
 6129|      0|	    }
 6130|     16|	    if(strcmp(url, "clipboard") == 0 ||
  ------------------
  |  Branch (6130:9): [True: 0, False: 16]
  ------------------
 6131|       |#ifdef Win32
 6132|       |	       strncmp(url, "clipboard-", 10) == 0
 6133|       |#else
 6134|     16|	       strcmp(url, "X11_primary") == 0
  ------------------
  |  Branch (6134:9): [True: 0, False: 16]
  ------------------
 6135|     16|	       || strcmp(url, "X11_secondary") == 0
  ------------------
  |  Branch (6135:12): [True: 0, False: 16]
  ------------------
 6136|     16|	       || strcmp(url, "X11_clipboard") == 0
  ------------------
  |  Branch (6136:12): [True: 0, False: 16]
  ------------------
 6137|     16|#endif
 6138|     16|		)
 6139|      0|		con = newclp(url, strlen(open) ? open : "r");
  ------------------
  |  Branch (6139:21): [True: 0, False: 0]
  ------------------
 6140|     16|	    else {
 6141|     16|		const char *efn = R_ExpandFileName(url);
 6142|     16|#ifndef Win32
 6143|     16|		if (!raw) {
  ------------------
  |  Branch (6143:7): [True: 16, False: 0]
  ------------------
 6144|     16|		    struct stat sb;
 6145|     16|		    int res = stat(efn, &sb);
 6146|     16|		    if (!res && (sb.st_mode & S_IFIFO)) {
  ------------------
  |  Branch (6146:11): [True: 16, False: 0]
  |  Branch (6146:19): [True: 0, False: 16]
  ------------------
 6147|      0|			raw = TRUE;
 6148|      0|			warning(_("using 'raw = TRUE' because '%s' is a fifo or pipe"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			warning(_("using 'raw = TRUE' because '%s' is a fifo or pipe"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6149|      0|				url);
 6150|     16|		    } else if (!res && !(sb.st_mode & S_IFREG) &&
  ------------------
  |  Branch (6150:18): [True: 16, False: 0]
  |  Branch (6150:26): [True: 0, False: 16]
  ------------------
 6151|      0|			       strcmp(efn, "/dev/null"))
  ------------------
  |  Branch (6151:11): [True: 0, False: 0]
  ------------------
 6152|       |			/* not setting 'raw' to FALSE because character devices may be
 6153|       |			   seekable; unfortunately there is no reliable way to detect
 6154|       |			   that without changing the device state */
 6155|      0|			warning(_("'raw = FALSE' but '%s' is not a regular file"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			warning(_("'raw = FALSE' but '%s' is not a regular file"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6156|      0|			        url);
 6157|     16|		}
 6158|     16|#endif
 6159|     16|		if (!raw &&
  ------------------
  |  Branch (6159:7): [True: 16, False: 0]
  ------------------
 6160|     16|		    (!strlen(open) || streql(open, "r") || streql(open, "rt"))) {
  ------------------
  |  | 1498|     32|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 14, False: 2]
  |  |  ------------------
  ------------------
              		    (!strlen(open) || streql(open, "r") || streql(open, "rt"))) {
  ------------------
  |  | 1498|      2|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (6160:8): [True: 0, False: 16]
  ------------------
 6161|       |		    /* check if this is a compressed file */
 6162|     16|		    int subtype = 0, compress = 0;
 6163|     16|		    comp_type ct = comp_type_from_file(efn, FALSE, &subtype);
 6164|     16|		    switch(ct) {
  ------------------
  |  Branch (6164:14): [True: 16, False: 0]
  ------------------
 6165|     16|		    case COMP_UNKNOWN:
  ------------------
  |  Branch (6165:7): [True: 16, False: 0]
  ------------------
 6166|     16|			con = newfile(url, ienc, strlen(open) ? open : "r", raw);
  ------------------
  |  Branch (6166:29): [True: 16, False: 0]
  ------------------
 6167|     16|			break;
 6168|      0|		    case COMP_GZ:
  ------------------
  |  Branch (6168:7): [True: 0, False: 16]
  ------------------
 6169|      0|			con = newgzfile(url, strlen(open) ? open : "rt", compress);
  ------------------
  |  Branch (6169:25): [True: 0, False: 0]
  ------------------
 6170|      0|			break;
 6171|      0|		    case COMP_BZ:
  ------------------
  |  Branch (6171:7): [True: 0, False: 16]
  ------------------
 6172|      0|			con = newbzfile(url, strlen(open) ? open : "rt", compress);
  ------------------
  |  Branch (6172:25): [True: 0, False: 0]
  ------------------
 6173|      0|			break;
 6174|      0|		    case COMP_XZ:
  ------------------
  |  Branch (6174:7): [True: 0, False: 16]
  ------------------
 6175|      0|			con = newxzfile(url, strlen(open) ? open : "rt", subtype,
  ------------------
  |  Branch (6175:25): [True: 0, False: 0]
  ------------------
 6176|      0|			                compress);
 6177|      0|			break;
 6178|      0|		    case COMP_ZSTD:
  ------------------
  |  Branch (6178:7): [True: 0, False: 16]
  ------------------
 6179|      0|			con = newzstdfile(url, strlen(open) ? open : "rt", compress);
  ------------------
  |  Branch (6179:27): [True: 0, False: 0]
  ------------------
 6180|      0|			break;
 6181|     16|		    }
 6182|     16|		} else
 6183|      0|		    con = newfile(url, ienc, strlen(open) ? open : "r", raw);
  ------------------
  |  Branch (6183:32): [True: 0, False: 0]
  ------------------
 6184|     16|	    }
 6185|     16|	    class2 = "file";
 6186|     16|	} else { // url()
 6187|      0|	    error(_("URL scheme unsupported by this method"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("URL scheme unsupported by this method"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6188|      0|	}
 6189|     16|    }
 6190|       |
 6191|     16|    Connections[ncon] = con;
 6192|     16|    con->blocking = (Rboolean) block;
 6193|     16|    strncpy(con->encname, CHAR(STRING_ELT(enc, 0)), 100); /* ASCII */
  ------------------
  |  |  203|     16|#define CHAR(x) R_CHAR(x)
  ------------------
 6194|     16|    con->encname[100 - 1] = '\0';
 6195|       |
 6196|       |    /* only text-mode connections are affected, but we can't tell that
 6197|       |       until the connection is opened, and why set an encoding on a
 6198|       |       connection intended to be used in binary mode? */
 6199|     16|    if (con->encname[0] && !streql(con->encname, "native.enc"))
  ------------------
  |  | 1498|     16|#define streql(s, t)	(!strcmp((s), (t)))
  ------------------
  |  Branch (6199:9): [True: 16, False: 0]
  |  Branch (6199:28): [True: 0, False: 16]
  ------------------
 6200|      0|	con->canseek = 0;
 6201|       |    /* This is referenced in do_getconnection, so set up before
 6202|       |       any warning */
 6203|     16|    con->ex_ptr = PROTECT(R_MakeExternalPtr(con->id, install("connection"),
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
 6204|     16|					    R_NilValue));
 6205|       |
 6206|       |    /* open it if desired */
 6207|     16|    if(strlen(open))
  ------------------
  |  Branch (6207:8): [True: 16, False: 0]
  ------------------
 6208|     16|	checked_open(ncon);
 6209|       |
 6210|     16|    PROTECT(ans = ScalarInteger(ncon));
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
 6211|     16|    PROTECT(class = allocVector(STRSXP, 2));
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
 6212|     16|    SET_STRING_ELT(class, 0, mkChar(class2));
  ------------------
  |  |  998|     16|#define mkChar			Rf_mkChar
  ------------------
 6213|     16|    SET_STRING_ELT(class, 1, mkChar("connection"));
  ------------------
  |  |  998|     16|#define mkChar			Rf_mkChar
  ------------------
 6214|     16|    classgets(ans, class);
  ------------------
  |  |  894|     16|#define classgets		Rf_classgets
  ------------------
 6215|     16|    setAttrib(ans, R_ConnIdSymbol, con->ex_ptr);
  ------------------
  |  | 1027|     16|#define setAttrib		Rf_setAttrib
  ------------------
 6216|     16|    R_RegisterCFinalizerEx(con->ex_ptr, conFinalizer, FALSE);
 6217|     16|    UNPROTECT(3);
  ------------------
  |  |  358|     16|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 6218|       |
 6219|     16|    return ans;
 6220|     16|}
R_decompress1:
 6733|  1.51k|{
 6734|  1.51k|    if(TYPEOF(in) != RAWSXP)
  ------------------
  |  |  136|  1.51k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (6734:8): [True: 0, False: 1.51k]
  ------------------
 6735|      0|	error("R_decompress1 requires a raw vector");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 6736|       |
 6737|  1.51k|    const void *vmax = vmaxget();
 6738|       |
 6739|  1.51k|    static struct libdeflate_decompressor *d = NULL;
 6740|  1.51k|    if(d == NULL) {
  ------------------
  |  Branch (6740:8): [True: 2, False: 1.51k]
  ------------------
 6741|      2|	d = libdeflate_alloc_decompressor();
 6742|      2|	if(d == NULL)
  ------------------
  |  Branch (6742:5): [True: 0, False: 2]
  ------------------
 6743|      0|	    error("allocation error in R_decompress1 with libdeflate");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 6744|      2|    }
 6745|       |
 6746|  1.51k|    unsigned char *p = RAW(in);
 6747|  1.51k|    size_t inlen = LENGTH(in);
 6748|  1.51k|    size_t outlen = uiSwap(*((unsigned int *) p));
 6749|  1.51k|    Bytef *buf = (Bytef *) R_alloc(outlen, sizeof(Bytef));
 6750|  1.51k|    size_t actual_out;
 6751|  1.51k|    enum libdeflate_result res =
 6752|  1.51k|	libdeflate_zlib_decompress(d, p + 4, inlen - 4, buf,
 6753|  1.51k|				   outlen, &actual_out);
 6754|       |
 6755|  1.51k|    if(res != LIBDEFLATE_SUCCESS) {
  ------------------
  |  Branch (6755:8): [True: 0, False: 1.51k]
  ------------------
 6756|      0|	warning("internal error %d in R_decompress1 with libdeflate", res);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
 6757|      0|	*err = TRUE;
 6758|      0|	return R_NilValue;
 6759|      0|    }
 6760|  1.51k|    SEXP ans = allocVector(RAWSXP, actual_out);
  ------------------
  |  |  875|  1.51k|#define allocVector		Rf_allocVector
  ------------------
                  SEXP ans = allocVector(RAWSXP, actual_out);
  ------------------
  |  |  136|  1.51k|#define RAWSXP      24    /* raw bytes */
  ------------------
 6761|  1.51k|    if (actual_out)
  ------------------
  |  Branch (6761:9): [True: 1.51k, False: 0]
  ------------------
 6762|  1.51k|	memcpy(RAW(ans), buf, actual_out);
 6763|  1.51k|    vmaxset(vmax);
 6764|  1.51k|    return ans;
 6765|  1.51k|}
connections.c:buff_fgetc:
  352|  15.8k|{
  353|  15.8k|    size_t unread_len;
  354|       |
  355|  15.8k|    unread_len = con->buff_stored_len - con->buff_pos;
  356|  15.8k|    if (unread_len == 0) {
  ------------------
  |  Branch (356:9): [True: 32, False: 15.8k]
  ------------------
  357|     32|	size_t filled_len = buff_fill(con);
  358|     32|	if (filled_len == 0)
  ------------------
  |  Branch (358:6): [True: 16, False: 16]
  ------------------
  359|     16|	    return R_EOF;
  ------------------
  |  | 1531|     16|#define R_EOF	-1
  ------------------
  360|     32|    }
  361|       |
  362|  15.8k|    return con->buff[con->buff_pos++];
  363|  15.8k|}
connections.c:buff_fill:
  337|     32|static size_t buff_fill(Rconnection con) {
  338|     32|    size_t free_len, read_len;
  339|       |
  340|     32|    buff_reset(con);
  341|       |
  342|     32|    free_len = con->buff_len - con->buff_stored_len;
  343|     32|    read_len = con->read(con->buff, sizeof(unsigned char), free_len, con);
  344|     32|    if ((int)read_len < 0)
  ------------------
  |  Branch (344:9): [True: 0, False: 32]
  ------------------
  345|      0|	error("error reading from the connection");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  346|     32|    con->buff_stored_len += read_len;
  347|       |
  348|     32|    return read_len;
  349|     32|}
connections.c:buff_reset:
  327|     32|static void buff_reset(Rconnection con) {
  328|     32|    size_t unread_len = con->buff_stored_len - con->buff_pos;
  329|       |
  330|     32|    if (unread_len > 0)
  ------------------
  |  Branch (330:9): [True: 0, False: 32]
  ------------------
  331|      0|	memmove(con->buff, con->buff + con->buff_pos, unread_len);
  332|       |
  333|     32|    con->buff_pos = 0;
  334|     32|    con->buff_stored_len = unread_len;
  335|     32|}
connections.c:null_destroy:
  454|     88|{
  455|     88|    if(con->private) free(con->private);
  ------------------
  |  Branch (455:8): [True: 88, False: 0]
  ------------------
  456|     88|}
connections.c:NextConnection:
  182|     88|{
  183|     88|    int i;
  184|     88|    for(i = 3; i < NCONNECTIONS; i++)
  ------------------
  |  Branch (184:16): [True: 88, False: 0]
  ------------------
  185|     88|	if(!Connections[i]) break;
  ------------------
  |  Branch (185:5): [True: 88, False: 0]
  ------------------
  186|     88|    if(i >= NCONNECTIONS) {
  ------------------
  |  Branch (186:8): [True: 0, False: 88]
  ------------------
  187|      0|	R_gc(); /* Try to reclaim unused ones */
  188|      0|	for(i = 3; i < NCONNECTIONS; i++)
  ------------------
  |  Branch (188:13): [True: 0, False: 0]
  ------------------
  189|      0|	    if(!Connections[i]) break;
  ------------------
  |  Branch (189:9): [True: 0, False: 0]
  ------------------
  190|       |	/* To make this dynamic, realloc Connections and set the new
  191|       |	   members to NULL. */
  192|      0|	if(i >= NCONNECTIONS)
  ------------------
  |  Branch (192:5): [True: 0, False: 0]
  ------------------
  193|      0|	    error(_("all %d connections are in use"), NCONNECTIONS);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("all %d connections are in use"), NCONNECTIONS);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  194|      0|    }
  195|     88|    return i;
  196|     88|}
connections.c:checked_open:
 1555|     88|{
 1556|     88|    Rconnection con = Connections[ncon];
 1557|     88|    RCNTXT cntxt;
 1558|       |
 1559|       |    /* Set up a context which will destroy the connection on error,
 1560|       |       including warning turned into error (PR#18491) */
 1561|     88|    begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
  ------------------
  |  | 1864|     88|# define begincontext		Rf_begincontext
  ------------------
 1562|     88|		 R_NilValue, R_NilValue);
 1563|     88|    cntxt.cend = &cend_con_destroy;
 1564|     88|    cntxt.cenddata = &ncon;
 1565|     88|    Rboolean success = con->open(con);
 1566|     88|    endcontext(&cntxt);
  ------------------
  |  | 1895|     88|# define endcontext		Rf_endcontext
  ------------------
 1567|     88|    if(!success) {
  ------------------
  |  Branch (1567:8): [True: 0, False: 88]
  ------------------
 1568|      0|	con_destroy(ncon);
 1569|      0|	error(_("cannot open the connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot open the connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1570|      0|    }
 1571|     88|}
connections.c:conFinalizer:
  232|     63|{
  233|     63|    int i, ncon = 0;
  234|     63|    void *cptr = R_ExternalPtrAddr(ptr);
  235|       |
  236|     63|    if(!cptr) return;
  ------------------
  |  Branch (236:8): [True: 0, False: 63]
  ------------------
  237|       |
  238|  7.93k|    for(i = 3; i < NCONNECTIONS; i++)
  ------------------
  |  Branch (238:16): [True: 7.87k, False: 63]
  ------------------
  239|  7.87k|	if(Connections[i] && Connections[i]->id == cptr) {
  ------------------
  |  Branch (239:5): [True: 0, False: 7.87k]
  |  Branch (239:23): [True: 0, False: 0]
  ------------------
  240|      0|	    ncon = i;
  241|      0|	    break;
  242|      0|	}
  243|     63|    if(i >= NCONNECTIONS) return;
  ------------------
  |  Branch (243:8): [True: 63, False: 0]
  ------------------
  244|       |
  245|      0|    char buf[R_PATH_MAX + 50]; /* much longer than limit for warning */
  246|      0|    Rboolean warn = FALSE;
  247|      0|    {
  248|      0|	Rconnection this = getConnection(ncon);
  249|      0|	if(this->isopen && strcmp(this->class, "textConnection")) {
  ------------------
  |  Branch (249:5): [True: 0, False: 0]
  |  Branch (249:21): [True: 0, False: 0]
  ------------------
  250|      0|	    warn = TRUE;
  251|      0|	    snprintf(buf, sizeof(buf),
  252|      0|	             _("closing unused connection %d (%s)\n"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  253|      0|	             ncon, this->description);
  254|      0|	}
  255|      0|    }
  256|       |
  257|      0|    con_destroy(ncon);
  258|      0|    R_ClearExternalPtr(ptr); /* not really needed */
  259|       |
  260|      0|    if (warn)
  ------------------
  |  Branch (260:9): [True: 0, False: 0]
  ------------------
  261|      0|	warning("%s", buf); /* may be turned into error */
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  262|      0|}
connections.c:file_read:
 1093|     32|{
 1094|     32|    Rfileconn this = con->private;
 1095|     32|    FILE *fp = this->fp;
 1096|       |
 1097|     32|    if(this->last_was_write) {
  ------------------
  |  Branch (1097:8): [True: 0, False: 32]
  ------------------
 1098|      0|	this->wpos = f_tell(this->fp);
  ------------------
  |  |  750|      0|# define f_tell ftello
  ------------------
 1099|      0|	this->last_was_write = FALSE;
 1100|      0|	f_seek(this->fp, this->rpos, SEEK_SET);
  ------------------
  |  |  749|      0|# define f_seek fseeko
  ------------------
 1101|      0|    }
 1102|     32|    size_t res = fread(ptr, size, nitems, fp);
 1103|     32|    if (res != nitems && feof(fp))
  ------------------
  |  Branch (1103:9): [True: 32, False: 0]
  |  Branch (1103:26): [True: 32, False: 0]
  ------------------
 1104|       |	/* see comment in file_fgetc_internal */
 1105|     32|	clearerr(fp);
 1106|     32|    return res;
 1107|     32|}
connections.c:comp_type_from_file:
 2723|     88|{
 2724|     88|    FILE *fp = fopen(name, "rb");
 2725|     88|    char buf[10];
 2726|       |
 2727|     88|    if (fp) {
  ------------------
  |  Branch (2727:9): [True: 88, False: 0]
  ------------------
 2728|     88|	size_t res = fread(buf, 1, sizeof(buf), fp);
 2729|     88|	fclose(fp);
 2730|     88|	if(res > 0)
  ------------------
  |  Branch (2730:5): [True: 88, False: 0]
  ------------------
 2731|     88|	    return comp_type_from_memory(buf, res, with_zlib, subtype);
 2732|     88|    }
 2733|      0|    return COMP_UNKNOWN;
 2734|     88|}
connections.c:newgzfile:
 1932|     72|{
 1933|     72|    Rconnection new;
 1934|     72|    new = (Rconnection) malloc(sizeof(struct Rconn));
 1935|     72|    if(!new) error(_("allocation of gzfile connection failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if(!new) error(_("allocation of gzfile connection failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (1935:8): [True: 0, False: 72]
  ------------------
 1936|     72|    new->class = (char *) malloc(strlen("gzfile") + 1);
 1937|     72|    if(!new->class) {
  ------------------
  |  Branch (1937:8): [True: 0, False: 72]
  ------------------
 1938|      0|	free(new);
 1939|      0|	error(_("allocation of gzfile connection failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("allocation of gzfile connection failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1940|      0|	/* for Solaris 12.5 */ new = NULL;
 1941|      0|    }
 1942|     72|    strcpy(new->class, "gzfile");
 1943|     72|    new->description = (char *) malloc(strlen(description) + 1);
 1944|     72|    if(!new->description) {
  ------------------
  |  Branch (1944:8): [True: 0, False: 72]
  ------------------
 1945|      0|	free(new->class); free(new);
 1946|      0|	error(_("allocation of gzfile connection failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("allocation of gzfile connection failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1947|      0|	/* for Solaris 12.5 */ new = NULL;
 1948|      0|    }
 1949|     72|    init_con(new, description, CE_NATIVE, mode);
  ------------------
  |  |   70|     72|#define init_con	Rf_init_con
  ------------------
 1950|       |
 1951|     72|    new->canseek = TRUE;
 1952|     72|    new->open = &gzfile_open;
 1953|     72|    new->close = &gzfile_close;
 1954|     72|    new->vfprintf = &dummy_vfprintf;
 1955|     72|    new->fgetc_internal = &gzfile_fgetc_internal;
 1956|     72|    new->fgetc = &dummy_fgetc;
 1957|     72|    new->seek = &gzfile_seek;
 1958|     72|    new->fflush = &gzfile_fflush;
 1959|     72|    new->read = &gzfile_read;
 1960|     72|    new->write = &gzfile_write;
 1961|     72|    new->private = (void *) malloc(sizeof(struct gzfileconn));
 1962|     72|    if(!new->private) {
  ------------------
  |  Branch (1962:8): [True: 0, False: 72]
  ------------------
 1963|      0|	free(new->description); free(new->class); free(new);
 1964|      0|	error(_("allocation of gzfile connection failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("allocation of gzfile connection failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1965|       |	/* for Solaris 12.5 */ new = NULL;
 1966|      0|    }
 1967|     72|    ((Rgzfileconn)new->private)->compress = compress;
 1968|     72|    return new;
 1969|     72|}
connections.c:gzfile_open:
 1834|     72|{
 1835|     72|    gzFile fp;
 1836|     72|    char mode[6];
 1837|     72|    Rgzfileconn gzcon = con->private;
 1838|     72|    const char *name;
 1839|       |
 1840|     72|    strcpy(mode, con->mode);
 1841|       |    /* Must open as binary */
 1842|     72|    if(strchr(con->mode, 'w')) snprintf(mode, 6, "wb%1d", gzcon->compress);
  ------------------
  |  Branch (1842:8): [True: 0, False: 72]
  ------------------
 1843|     72|    else if (con->mode[0] == 'a') snprintf(mode, 6, "ab%1d", gzcon->compress);
  ------------------
  |  Branch (1843:14): [True: 0, False: 72]
  ------------------
 1844|     72|    else strcpy(mode, "rb");
 1845|     72|    errno = 0; /* precaution */
 1846|     72|    name = R_ExpandFileName(con->description);
 1847|       |    /* We cannot use isDir, because we cannot get the fd from gzFile
 1848|       |       (it would be possible with gzdopen, if supported) */
 1849|     72|    if (R_IsDirPath(name)) {
  ------------------
  |  Branch (1849:9): [True: 0, False: 72]
  ------------------
 1850|      0|	warning(_("cannot open file '%s': it is a directory"), name);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("cannot open file '%s': it is a directory"), name);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1851|      0|	return FALSE;
 1852|      0|    }
 1853|     72|    fp = R_gzopen(name, mode);
 1854|     72|    if(!fp) {
  ------------------
  |  Branch (1854:8): [True: 0, False: 72]
  ------------------
 1855|      0|	warning(_("cannot open compressed file '%s', probable reason '%s'"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("cannot open compressed file '%s', probable reason '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1856|      0|	        name, strerror(errno));
 1857|      0|	return FALSE;
 1858|      0|    }
 1859|     72|    ((Rgzfileconn)(con->private))->fp = fp;
 1860|     72|    con->isopen = TRUE;
 1861|     72|    con->canwrite = (con->mode[0] == 'w' || con->mode[0] == 'a');
  ------------------
  |  Branch (1861:22): [True: 0, False: 72]
  |  Branch (1861:45): [True: 0, False: 72]
  ------------------
 1862|     72|    con->canread = !con->canwrite;
 1863|     72|    con->text = strchr(con->mode, 'b') ? FALSE : TRUE;
  ------------------
  |  Branch (1863:17): [True: 72, False: 0]
  ------------------
 1864|     72|    set_buffer(con);
 1865|     72|    set_iconv(con);
  ------------------
  |  |   97|     72|#define set_iconv Rf_set_iconv
  ------------------
 1866|     72|    con->save = -1000;
 1867|     72|    return TRUE;
 1868|     72|}
connections.c:set_buffer:
  388|     88|static void set_buffer(Rconnection con) {
  389|     88|    if (con->canread && con->text) {
  ------------------
  |  Branch (389:9): [True: 88, False: 0]
  |  Branch (389:25): [True: 16, False: 72]
  ------------------
  390|     16|	buff_init(con);
  391|     16|    }
  392|     88|}
connections.c:buff_init:
  322|     16|{
  323|     16|    con->buff_pos = con->buff_stored_len = 0;
  324|     16|    buff_set_len(con, RBUFFCON_LEN_DEFAULT);
  ------------------
  |  |  288|     16|#define RBUFFCON_LEN_DEFAULT 4096
  ------------------
  325|     16|}
connections.c:buff_set_len:
  293|     16|static size_t buff_set_len(Rconnection con, size_t len) {
  294|     16|    size_t unread_len = 0;
  295|     16|    unsigned char *buff;
  296|       |
  297|     16|    if (con->buff_len == len)
  ------------------
  |  Branch (297:9): [True: 0, False: 16]
  ------------------
  298|      0|	return len;
  299|       |
  300|     16|    if (con->buff) {
  ------------------
  |  Branch (300:9): [True: 0, False: 16]
  ------------------
  301|      0|	unread_len = con->buff_stored_len - con->buff_pos;
  302|      0|	len = MAX(len, unread_len);
  ------------------
  |  |  290|      0|# define MAX(a, b) ((a) > (b) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (290:21): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  303|      0|    }
  304|       |
  305|     16|    buff = (unsigned char *)malloc(sizeof(unsigned char) * len);
  306|       |
  307|     16|    if (con->buff) {
  ------------------
  |  Branch (307:9): [True: 0, False: 16]
  ------------------
  308|      0|	if (unread_len)
  ------------------
  |  Branch (308:6): [True: 0, False: 0]
  ------------------
  309|      0|	    memcpy(buff, con->buff + con->buff_pos, unread_len);
  310|      0|	free(con->buff);
  311|      0|    }
  312|       |
  313|     16|    con->buff = buff;
  314|     16|    con->buff_len = len;
  315|     16|    con->buff_pos = 0;
  316|     16|    con->buff_stored_len = unread_len;
  317|       |
  318|     16|    return len;
  319|     16|}
connections.c:gzfile_close:
 1871|     72|{
 1872|     72|    R_gzclose(((Rgzfileconn)(con->private))->fp);
 1873|     72|    con->isopen = FALSE;
 1874|     72|}
connections.c:gzfile_read:
 1912|  88.0k|{
 1913|  88.0k|    gzFile fp = ((Rgzfileconn)(con->private))->fp;
 1914|       |    /* uses 'unsigned' for len */
 1915|  88.0k|    if ((double) size * (double) nitems > UINT_MAX)
  ------------------
  |  Branch (1915:9): [True: 0, False: 88.0k]
  ------------------
 1916|      0|	error(_("too large a block specified"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("too large a block specified"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1917|  88.0k|    return R_gzread(fp, ptr, (unsigned int)(size*nitems))/size;
 1918|  88.0k|}
connections.c:isDir:
  788|     16|{
  789|     16|#ifdef HAVE_SYS_STAT_H
  790|     16|    struct stat sb;
  791|     16|    int err = fstat(fileno(fd), &sb);
  792|     16|    return err ? FALSE : S_ISDIR(sb.st_mode);
  ------------------
  |  Branch (792:12): [True: 0, False: 16]
  ------------------
  793|       |#else
  794|       |    return FALSE;
  795|       |#endif
  796|     16|}
connections.c:con_close1:
 4196|     88|{
 4197|     88|    int status;
 4198|     88|    checkClose(con);
 4199|     88|    status = con->status;
 4200|     88|    if(con->isGzcon) {
  ------------------
  |  Branch (4200:8): [True: 0, False: 88]
  ------------------
 4201|      0|	Rgzconn priv = con->private;
 4202|      0|	con_close1(priv->con);
 4203|      0|	R_ReleaseObject(priv->con->ex_ptr);
 4204|      0|	free(priv->con);
 4205|      0|    }
 4206|       |    /* close inconv and outconv if open */
 4207|     88|    if(con->inconv) Riconv_close(con->inconv);
  ------------------
  |  Branch (4207:8): [True: 0, False: 88]
  ------------------
 4208|     88|    if(con->outconv) Riconv_close(con->outconv);
  ------------------
  |  Branch (4208:8): [True: 0, False: 88]
  ------------------
 4209|     88|    con->destroy(con);
 4210|     88|    free(con->class);
 4211|     88|    con->class = NULL;
 4212|     88|    free(con->description);
 4213|     88|    con->description = NULL;
 4214|       |    /* clear the pushBack */
 4215|     88|    if(con->nPushBack > 0) { // already cleared on closed connection,
  ------------------
  |  Branch (4215:8): [True: 0, False: 88]
  ------------------
 4216|       |	                     // so no double-free pace -fanalyzer
 4217|      0|	int j;
 4218|       |
 4219|      0|	for(j = 0; j < con->nPushBack; j++)
  ------------------
  |  Branch (4219:13): [True: 0, False: 0]
  ------------------
 4220|      0|	    free(con->PushBack[j]);
 4221|      0|	free(con->PushBack);
 4222|      0|    }
 4223|     88|    con->nPushBack = 0;
 4224|     88|    if (con->buff) {
  ------------------
  |  Branch (4224:9): [True: 16, False: 72]
  ------------------
 4225|     16|	free(con->buff);
 4226|       |	con->buff = NULL;
 4227|     16|    }
 4228|     88|    con->buff_len = con->buff_pos = con->buff_stored_len = 0;
 4229|     88|    con->open = &null_open;
 4230|     88|    con->close = &null_close;
 4231|     88|    con->destroy = &null_destroy;
 4232|     88|    con->vfprintf = &null_vfprintf;
 4233|     88|    con->fgetc = con->fgetc_internal = &null_fgetc;
 4234|     88|    con->seek = &null_seek;
 4235|     88|    con->truncate = &null_truncate;
 4236|     88|    con->fflush = &null_fflush;
 4237|     88|    con->read = &null_read;
 4238|     88|    con->write = &null_write;
 4239|     88|    return status;
 4240|     88|}
connections.c:checkClose:
 4181|     88|{
 4182|     88|    if (con->isopen) {
  ------------------
  |  Branch (4182:9): [True: 88, False: 0]
  ------------------
 4183|     88|        errno = 0;
 4184|     88|    	con->close(con);
 4185|     88|    	if (con->status != NA_INTEGER && con->status < 0) {
  ------------------
  |  |   56|    176|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (4185:10): [True: 16, False: 72]
  |  Branch (4185:39): [True: 0, False: 16]
  ------------------
 4186|      0|    	    int serrno = errno;
 4187|      0|            if (serrno)
  ------------------
  |  Branch (4187:17): [True: 0, False: 0]
  ------------------
 4188|      0|		warning(_("Problem closing connection:  %s"), strerror(serrno));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		warning(_("Problem closing connection:  %s"), strerror(serrno));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4189|      0|	    else
 4190|      0|		warning(_("Problem closing connection"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		warning(_("Problem closing connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4191|      0|   	 }
 4192|     88|    }
 4193|     88|}
connections.c:newterminal:
 3188|      6|{
 3189|      6|    Rconnection new;
 3190|      6|    new = (Rconnection) malloc(sizeof(struct Rconn));
 3191|      6|    if(!new) error(_("allocation of terminal connection failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if(!new) error(_("allocation of terminal connection failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (3191:8): [True: 0, False: 6]
  ------------------
 3192|      6|    new->class = (char *) malloc(strlen("terminal") + 1);
 3193|      6|    if(!new->class) {
  ------------------
  |  Branch (3193:8): [True: 0, False: 6]
  ------------------
 3194|      0|	free(new);
 3195|      0|	error(_("allocation of terminal connection failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("allocation of terminal connection failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3196|      0|	/* for Solaris 12.5 */ new = NULL;
 3197|      0|    }
 3198|      6|    strcpy(new->class, "terminal");
 3199|      6|    new->description = (char *) malloc(strlen(description) + 1);
 3200|      6|    if(!new->description) {
  ------------------
  |  Branch (3200:8): [True: 0, False: 6]
  ------------------
 3201|      0|	free(new->class); free(new);
 3202|      0|	error(_("allocation of terminal connection failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("allocation of terminal connection failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3203|      0|	/* for Solaris 12.5 */ new = NULL;
 3204|      0|    }
 3205|      6|    init_con(new, description, CE_NATIVE, mode);
  ------------------
  |  |   70|      6|#define init_con	Rf_init_con
  ------------------
 3206|      6|    new->isopen = TRUE;
 3207|      6|    new->canread = (strcmp(mode, "r") == 0);
 3208|      6|    new->canwrite = (strcmp(mode, "w") == 0);
 3209|      6|    new->destroy = &null_close;
 3210|       |    new->private = NULL;
 3211|      6|    return new;
 3212|      6|}
connections.c:newfile:
 1125|     16|{
 1126|     16|    Rconnection new;
 1127|     16|    new = (Rconnection) malloc(sizeof(struct Rconn));
 1128|     16|    if(!new) error(_("allocation of file connection failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if(!new) error(_("allocation of file connection failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (1128:8): [True: 0, False: 16]
  ------------------
 1129|     16|    new->class = (char *) malloc(strlen("file") + 1);
 1130|     16|    if(!new->class) {
  ------------------
  |  Branch (1130:8): [True: 0, False: 16]
  ------------------
 1131|      0|	free(new);
 1132|      0|	error(_("allocation of file connection failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("allocation of file connection failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1133|      0|	/* for Solaris 12.5 */ new = NULL;
 1134|      0|    }
 1135|     16|    strcpy(new->class, "file");
 1136|     16|    new->description = (char *) malloc(strlen(description) + 1);
 1137|     16|    if(!new->description) {
  ------------------
  |  Branch (1137:8): [True: 0, False: 16]
  ------------------
 1138|      0|	free(new->class); free(new);
 1139|      0|	error(_("allocation of file connection failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("allocation of file connection failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1140|      0|	/* for Solaris 12.5 */ new = NULL;
 1141|      0|    }
 1142|     16|    init_con(new, description, enc, mode);
  ------------------
  |  |   70|     16|#define init_con	Rf_init_con
  ------------------
 1143|     16|    new->open = &file_open;
 1144|     16|    new->close = &file_close;
 1145|     16|    new->vfprintf = &file_vfprintf;
 1146|     16|    new->fgetc_internal = &file_fgetc_internal;
 1147|     16|    new->fgetc = &dummy_fgetc;
 1148|     16|    new->seek = &file_seek;
 1149|     16|    new->truncate = &file_truncate;
 1150|     16|    new->fflush = &file_fflush;
 1151|     16|    new->read = &file_read;
 1152|     16|    new->write = &file_write;
 1153|     16|    new->canseek = (raw == 0);
 1154|     16|    new->private = (void *) malloc(sizeof(struct fileconn));
 1155|     16|    if(!new->private) {
  ------------------
  |  Branch (1155:8): [True: 0, False: 16]
  ------------------
 1156|      0|	free(new->description); free(new->class); free(new);
 1157|      0|	error(_("allocation of file connection failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("allocation of file connection failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1158|      0|	/* for Solaris 12.5 */ new = NULL;
 1159|      0|    }
 1160|     16|    ((Rfileconn)(new->private))->raw = raw;
 1161|       |#ifdef Win32
 1162|       |    ((Rfileconn)(new->private))->use_fgetwc = FALSE;
 1163|       |#endif
 1164|     16|    return new;
 1165|     16|}
connections.c:file_open:
  818|     16|{
  819|     16|    const char *name;
  820|     16|    FILE *fp = NULL;
  821|     16|    Rfileconn this = con->private;
  822|     16|    Rboolean temp = FALSE;
  823|     16|#ifdef HAVE_FCNTL
  824|     16|    int fd, flags;
  825|     16|#endif
  826|     16|    int mlen = (int) strlen(con->mode); // short
  827|       |
  828|     16|    if(strlen(con->description) == 0) {
  ------------------
  |  Branch (828:8): [True: 0, False: 16]
  ------------------
  829|      0|	temp = TRUE;
  830|      0|	name = R_tmpnam("Rf", R_TempDir);
  831|     16|    } else name = R_ExpandFileName(con->description);
  832|     16|    errno = 0; /* some systems require this */
  833|     16|    if(strcmp(name, "stdin")) {
  ------------------
  |  Branch (833:8): [True: 16, False: 0]
  ------------------
  834|       |#ifdef Win32
  835|       |	char mode[20]; /* 4 byte mode plus "t,ccs=UTF-16LE" plus one for luck. */
  836|       |	strncpy(mode, con->mode, 4);
  837|       |	mode[4] = '\0';
  838|       |	if (!strpbrk(mode, "bt"))
  839|       |	    strcat(mode, "t");
  840|       |	// See PR#16737, https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/fopen-wfopen?view=vs-2019
  841|       |	// ccs= is also supported by glibc but not macOS
  842|       |	if (strchr(mode, 't')
  843|       |	    && (!strcmp(con->encname, "UTF-16LE") || !strcmp(con->encname, "UCS-2LE"))) {
  844|       |	    strcat(mode, ",ccs=UTF-16LE");
  845|       |	    if (con->canread) {
  846|       |	    	this->use_fgetwc = TRUE;
  847|       |	    	this->have_wcbuffered = FALSE;
  848|       |	    }
  849|       |	}
  850|       |	if(con->enc == CE_UTF8) {
  851|       |	    int n = strlen(name);
  852|       |	    wchar_t wname[2 * (n+1)], wmode[20];
  853|       |	    mbstowcs(wmode, mode, 19);
  854|       |	    R_CheckStack();
  855|       |	    Rf_utf8towcs(wname, name, n+1);
  856|       |	    fp = _wfopen(wname, wmode);
  857|       |	    if(!fp) {
  858|       |		if (temp)
  859|       |		    free((char *)name);
  860|       |		warning(_("cannot open file '%ls': %s"), wname, strerror(errno));
  861|       |		return FALSE;
  862|       |	    }
  863|       |	    if (isDir(fp)) {
  864|       |		fclose(fp);
  865|       |		if (temp)
  866|       |		    free((char *)name);
  867|       |		warning(_("cannot open file '%ls': it is a directory"), wname);
  868|       |		return FALSE;
  869|       |	    }
  870|       |	} else {
  871|       |	    fp = R_fopen(name, mode);
  872|       |	}
  873|       |#else
  874|     16|	fp = R_fopen(name, con->mode);
  875|     16|#endif
  876|     16|    } else {  /* use file("stdin") to refer to the file and not the console */
  877|      0|#ifdef HAVE_FDOPEN
  878|      0|	int dstdin = dup(0);
  879|       |# ifdef Win32
  880|       |	if (strchr(con->mode, 'b'))
  881|       |	    /* fdopen won't set dstdin to binary mode */
  882|       |	    setmode(dstdin, _O_BINARY);
  883|       |# endif
  884|      0|        fp = fdopen(dstdin, con->mode);
  885|      0|	con->canseek = FALSE;
  886|       |#else
  887|       |	warning(_("cannot open file '%s': %s"), name,
  888|       |		"fdopen is not supported on this platform");
  889|       |#endif
  890|      0|    }
  891|     16|    if(!fp) {
  ------------------
  |  Branch (891:8): [True: 0, False: 16]
  ------------------
  892|      0|	warning(_("cannot open file '%s': %s"), name, strerror(errno));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("cannot open file '%s': %s"), name, strerror(errno));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  893|      0|	if (temp)
  ------------------
  |  Branch (893:6): [True: 0, False: 0]
  ------------------
  894|      0|	    free((char *)name);
  895|      0|	return FALSE;
  896|      0|    }
  897|     16|    if (isDir(fp)) {
  ------------------
  |  Branch (897:9): [True: 0, False: 16]
  ------------------
  898|      0|	fclose(fp);
  899|      0|	warning(_("cannot open file '%s': it is a directory"), name);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("cannot open file '%s': it is a directory"), name);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  900|      0|	if (temp)
  ------------------
  |  Branch (900:6): [True: 0, False: 0]
  ------------------
  901|      0|	    free((char *)name);
  902|      0|	return FALSE;
  903|      0|    }
  904|     16|    if(temp) {
  ------------------
  |  Branch (904:8): [True: 0, False: 16]
  ------------------
  905|       |	/* This will fail on Windows, so arrange to remove in
  906|       |	 * file_close.  An alternative strategy would be to manipulate
  907|       |	 * the underlying file handle to add FILE_SHARE_DELETE (so the
  908|       |	 * unlink is valid) or FILE_FLAG_DELETE_ON_CLOSE.  E.g. create
  909|       |	 * via CreateFile, get an fd by _open_osfhandle and a file
  910|       |	 * stream by fdopen.  See
  911|       |	 * e.g. http://www.codeproject.com/KB/files/handles.aspx
  912|       |	 *
  913|       |	 * unlink(name);
  914|       |	 */
  915|       |#ifdef Win32
  916|       |	this->name = (char *)name; /* malloc'd in R_tmpnam */
  917|       |#else
  918|      0|	unlink(name);
  919|      0|	free((char *) name); /* only free if allocated by R_tmpnam */
  920|      0|#endif
  921|      0|    }
  922|       |#ifdef Win32
  923|       |    this->anon_file = temp;
  924|       |#endif
  925|     16|    this->fp = fp;
  926|     16|    con->isopen = TRUE;
  927|     16|    con->canwrite = (con->mode[0] == 'w' || con->mode[0] == 'a');
  ------------------
  |  Branch (927:22): [True: 0, False: 16]
  |  Branch (927:45): [True: 0, False: 16]
  ------------------
  928|     16|    con->canread = !con->canwrite;
  929|     16|    if(mlen >= 2 && con->mode[1] == '+')
  ------------------
  |  Branch (929:8): [True: 2, False: 14]
  |  Branch (929:21): [True: 0, False: 2]
  ------------------
  930|      0|	con->canread = con->canwrite = TRUE;
  931|     16|    this->last_was_write = !con->canread;
  932|     16|    this->rpos = 0;
  933|     16|    if(con->canwrite) this->wpos = f_tell(fp);
  ------------------
  |  |  750|      0|# define f_tell ftello
  ------------------
  |  Branch (933:8): [True: 0, False: 16]
  ------------------
  934|     16|    if(mlen >= 2 && con->mode[mlen-1] == 'b') con->text = FALSE;
  ------------------
  |  Branch (934:8): [True: 2, False: 14]
  |  Branch (934:21): [True: 0, False: 2]
  ------------------
  935|     16|    else con->text = TRUE;
  936|     16|    con->save = -1000;
  937|     16|    if (shouldBuffer(fileno(fp)))
  ------------------
  |  Branch (937:9): [True: 16, False: 0]
  ------------------
  938|     16|	set_buffer(con);
  939|     16|    set_iconv(con);
  ------------------
  |  |   97|     16|#define set_iconv Rf_set_iconv
  ------------------
  940|       |
  941|     16|#ifdef HAVE_FCNTL
  942|     16|    if(!con->blocking) {
  ------------------
  |  Branch (942:8): [True: 0, False: 16]
  ------------------
  943|      0|	fd = fileno(fp);
  944|      0|	flags = fcntl(fd, F_GETFL);
  945|      0|	flags |= O_NONBLOCK;
  946|       |	fcntl(fd, F_SETFL, flags);
  947|      0|    }
  948|     16|#endif
  949|     16|    return TRUE;
  950|     16|}
connections.c:shouldBuffer:
  776|     16|static Rboolean shouldBuffer(int fd) {
  777|     16|#ifdef HAVE_SYS_STAT_H
  778|     16|    struct stat sb;
  779|     16|    int err = fstat(fd, &sb);
  780|     16|    return err ? FALSE : S_ISREG(sb.st_mode);
  ------------------
  |  Branch (780:12): [True: 0, False: 16]
  ------------------
  781|       |#else
  782|       |    return FALSE;
  783|       |#endif
  784|     16|}
connections.c:file_close:
  953|     16|{
  954|     16|    Rfileconn this = con->private;
  955|     16|    if(con->isopen) // && strcmp(con->description, "stdin"))
  ------------------
  |  Branch (955:8): [True: 16, False: 0]
  ------------------
  956|     16|	con->status = fclose(this->fp);
  957|     16|    con->isopen = FALSE;
  958|       |#ifdef Win32
  959|       |    if(this->anon_file && this->name) {
  960|       |	unlink(this->name);
  961|       |	free(this->name);
  962|       |	this->name = NULL;
  963|       |    }
  964|       |#endif
  965|     16|}
connections.c:uiSwap:
 6688|  1.51k|{
 6689|  1.51k|  return((x << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | (x >> 24));
 6690|  1.51k|}
connections.c:comp_type_from_memory:
 2686|     88|{
 2687|     88|    if(len >= 2 && buf[0] == '\x1f' && buf[1] == '\x8b')
  ------------------
  |  Branch (2687:8): [True: 88, False: 0]
  |  Branch (2687:20): [True: 72, False: 16]
  |  Branch (2687:40): [True: 72, False: 0]
  ------------------
 2688|     72|	return COMP_GZ;
 2689|     16|    else if(with_zlib && len>=2 && buf[0] == '\x78' && buf[1] == '\x9c')
  ------------------
  |  Branch (2689:13): [True: 0, False: 16]
  |  Branch (2689:26): [True: 0, False: 0]
  |  Branch (2689:36): [True: 0, False: 0]
  |  Branch (2689:56): [True: 0, False: 0]
  ------------------
 2690|       |	/* zlib commression starts with 2 bytes, which for default settings are
 2691|       |	   \x78\x9c.  We could use that */
 2692|      0|	return COMP_GZ;
 2693|     16|    else if(len >= 10 && !strncmp(buf, "BZh", 3)) { 
  ------------------
  |  Branch (2693:13): [True: 16, False: 0]
  |  Branch (2693:26): [True: 0, False: 16]
  ------------------
 2694|       |	/* check also the block size and the block/eos magic to reduce
 2695|       |	   the risk of picking up an uncompressed file (PR#18768) */
 2696|      0|	if (buf[3] >= '1' && buf[3] <= '9') {
  ------------------
  |  Branch (2696:6): [True: 0, False: 0]
  |  Branch (2696:23): [True: 0, False: 0]
  ------------------
 2697|       |	    // 0x314159265359 (BCD (pi))
 2698|       |	    // 0x177245385090 (BCD sqrt(pi))
 2699|      0|	    if (!memcmp(buf+4, "\x31\x41\x59\x26\x53\x59", 6) ||
  ------------------
  |  Branch (2699:10): [True: 0, False: 0]
  ------------------
 2700|      0|	        !memcmp(buf+4, "\x17\x72\x45\x38\x50\x90", 6))
  ------------------
  |  Branch (2700:10): [True: 0, False: 0]
  ------------------
 2701|       |
 2702|      0|		return COMP_BZ;
 2703|      0|	}
 2704|     16|    } else if(len >= 5 && buf[0] == '\xFD' && !strncmp(buf+1, "7zXZ", 4)) {
  ------------------
  |  Branch (2704:15): [True: 16, False: 0]
  |  Branch (2704:27): [True: 0, False: 16]
  |  Branch (2704:47): [True: 0, False: 0]
  ------------------
 2705|      0|	*subtype = 0;
 2706|      0|	return COMP_XZ;
 2707|     16|    } else if(len >= 5 && buf[0] == '\xFF' && !strncmp(buf+1, "LZMA", 4)) {
  ------------------
  |  Branch (2707:15): [True: 16, False: 0]
  |  Branch (2707:27): [True: 0, False: 16]
  |  Branch (2707:47): [True: 0, False: 0]
  ------------------
 2708|      0|	*subtype = 1;
 2709|      0|	return COMP_XZ;
 2710|     16|    } else if(len >= 5 && !memcmp(buf, "]\0\0\200\0", 5)) {
  ------------------
  |  Branch (2710:15): [True: 16, False: 0]
  |  Branch (2710:27): [True: 0, False: 16]
  ------------------
 2711|      0|	*subtype = 1;
 2712|      0|	return COMP_XZ;
 2713|     16|    } else if(len >= 4 && buf[0] == '\x89' && !strncmp(buf+1, "LZO", 3))
  ------------------
  |  Branch (2713:15): [True: 16, False: 0]
  |  Branch (2713:27): [True: 0, False: 16]
  |  Branch (2713:47): [True: 0, False: 0]
  ------------------
 2714|      0|	error(_("this is a %s-compressed file which this build of R does not support"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("this is a %s-compressed file which this build of R does not support"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2715|      0|	        "lzop");
 2716|     16|    else if(len >= 4 && !memcmp(buf, "\x28\xb5\x2f\xfd", 4))
  ------------------
  |  Branch (2716:13): [True: 16, False: 0]
  |  Branch (2716:25): [True: 0, False: 16]
  ------------------
 2717|      0|	return COMP_ZSTD;
 2718|     16|    return COMP_UNKNOWN; 
 2719|     88|}

R_run_onexits:
  121|   388k|{
  122|   388k|    RCNTXT *c;
  123|       |
  124|   780k|    for (c = R_GlobalContext; c != cptr; c = c->nextcontext) {
  ------------------
  |  Branch (124:31): [True: 392k, False: 388k]
  ------------------
  125|       |	// a user embedding R incorrectly triggered this (PR#15420)
  126|   392k|	if (c == NULL)
  ------------------
  |  Branch (126:6): [True: 0, False: 392k]
  ------------------
  127|      0|	    error("bad target context--should NEVER happen if R was called correctly");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  128|   392k|	if (c->cend != NULL) {
  ------------------
  |  Branch (128:6): [True: 3.81k, False: 388k]
  ------------------
  129|  3.81k|	    void (*cend)(void *) = c->cend;
  130|  3.81k|	    c->cend = NULL; /* prevent recursion */
  131|  3.81k|	    R_HandlerStack = c->handlerstack;
  132|  3.81k|	    R_RestartStack = c->restartstack;
  133|  3.81k|	    cend(c->cenddata);
  134|  3.81k|	}
  135|   392k|	if (c->cloenv != R_NilValue && c->conexit != R_NilValue) {
  ------------------
  |  Branch (135:6): [True: 392k, False: 0]
  |  Branch (135:33): [True: 0, False: 392k]
  ------------------
  136|      0|	    SEXP s = c->conexit;
  137|      0|	    RCNTXT* savecontext = R_ExitContext;
  138|      0|	    R_ExitContext = c;
  139|      0|	    c->conexit = R_NilValue; /* prevent recursion */
  140|       |	    /* we are in intermediate jump, so returnValue is undefined */
  141|      0|	    c->returnValue = SEXP_TO_STACKVAL(NULL);
  ------------------
  |  | 2598|      0|#define SEXP_TO_STACKVAL(x) ((R_bcstack_t) { .tag = 0, .u.sxpval = (x) })
  ------------------
  142|      0|	    R_HandlerStack = c->handlerstack;
  143|      0|	    R_RestartStack = c->restartstack;
  144|      0|	    PROTECT(s);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  145|       |	    /* Since these are run before any jumps rather than after
  146|       |	       jumping to the context where the exit handler was set
  147|       |	       we need to make sure there is enough room on the
  148|       |	       evaluation stack in case the jump is from handling a
  149|       |	       stack overflow. To be safe it is good to also call
  150|       |	       R_CheckStack. LT */
  151|      0|	    R_Expressions = R_Expressions_keep + 500;
  152|      0|	    R_CheckStack();
  153|      0|	    for (; s != R_NilValue; s = CDR(s)) {
  ------------------
  |  Branch (153:13): [True: 0, False: 0]
  ------------------
  154|      0|		c->conexit = CDR(s);
  155|      0|		eval(CAR(s), c->cloenv);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
  156|      0|	    }
  157|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  158|      0|	    R_ExitContext = savecontext;
  159|      0|	}
  160|   392k|	if (R_ExitContext == c)
  ------------------
  |  Branch (160:6): [True: 36, False: 392k]
  ------------------
  161|     36|	    R_ExitContext = NULL; /* Not necessary?  Better safe than sorry. */
  162|   392k|    }
  163|   388k|}
R_jumpctxt:
  216|   388k|{
  217|   388k|    Rboolean savevis = R_Visible;
  218|   388k|    RCNTXT *cptr;
  219|       |
  220|       |    /* find the target for the first jump -- either an intermediate
  221|       |       context with an on.exit action to run or the final target if
  222|       |       there are no intermediate on.exit actions */
  223|   388k|    cptr = first_jump_target(targetcptr, mask);
  224|       |
  225|       |    /* run cend code for all contexts down to but not including
  226|       |       the first jump target */
  227|   388k|    R_run_onexits(cptr);
  228|   388k|    R_Visible = savevis;
  229|       |
  230|   388k|    R_ReturnedValue = val;
  231|   388k|    R_GlobalContext = cptr;
  232|   388k|    R_restore_globals(R_GlobalContext);
  233|       |
  234|       |    /* if we are in the process of handling a C stack overflow we need
  235|       |       to restore the C stack limit before the jump */
  236|   388k|    if (R_OldCStackLimit != 0) {
  ------------------
  |  Branch (236:9): [True: 0, False: 388k]
  ------------------
  237|      0|	R_CStackLimit = R_OldCStackLimit;
  238|      0|	R_OldCStackLimit = 0;
  239|      0|    }
  240|       |
  241|   388k|    if (mask == 0)
  ------------------
  |  Branch (241:9): [True: 1.90k, False: 386k]
  ------------------
  242|  1.90k|	mask = 1; // make sure the return value for SETJMP is not zero
  243|       |
  244|   388k|    LONGJMP(cptr->cjmpbuf, mask);
  ------------------
  |  | 1163|   388k|# define LONGJMP(x,i) siglongjmp(x,i)
  ------------------
  245|   388k|}
Rf_begincontext:
  254|  4.70M|{
  255|  4.70M|    cptr->cstacktop = R_PPStackTop;
  256|  4.70M|    cptr->gcenabled = R_GCEnabled;
  257|  4.70M|    cptr->relpc = R_BCRelPC(R_BCbody, R_BCpc);
  258|  4.70M|    cptr->bcpc = R_BCpc;
  259|  4.70M|    cptr->bcbody = R_BCbody;
  260|  4.70M|    cptr->bcframe = R_BCFrame;
  261|  4.70M|    cptr->bcintactive = R_BCIntActive;
  262|  4.70M|    cptr->evaldepth = R_EvalDepth;
  263|  4.70M|    cptr->callflag = flags;
  264|  4.70M|    cptr->call = syscall;
  265|  4.70M|    cptr->cloenv = env;
  266|  4.70M|    cptr->sysparent = sysp;
  267|  4.70M|    cptr->conexit = R_NilValue;
  268|  4.70M|    cptr->cend = NULL;
  269|  4.70M|    cptr->promargs = promargs;
  270|  4.70M|    cptr->callfun = callfun;
  271|  4.70M|    cptr->vmax = vmaxget();
  272|  4.70M|    cptr->intsusp = R_interrupts_suspended;
  273|  4.70M|    cptr->handlerstack = R_HandlerStack;
  274|  4.70M|    cptr->restartstack = R_RestartStack;
  275|  4.70M|    cptr->prstack = R_PendingPromises;
  276|  4.70M|    cptr->nodestack = R_BCNodeStackTop;
  277|  4.70M|    cptr->bcprottop = R_BCProtTop;
  278|  4.70M|    cptr->srcref = R_Srcref;
  279|  4.70M|    cptr->browserfinish = R_GlobalContext->browserfinish;
  280|  4.70M|    cptr->nextcontext = R_GlobalContext;
  281|  4.70M|    cptr->returnValue = SEXP_TO_STACKVAL(NULL);
  ------------------
  |  | 2598|  4.70M|#define SEXP_TO_STACKVAL(x) ((R_bcstack_t) { .tag = 0, .u.sxpval = (x) })
  ------------------
  282|  4.70M|    cptr->jumptarget = NULL;
  283|  4.70M|    cptr->jumpmask = 0;
  284|       |
  285|  4.70M|    R_GlobalContext = cptr;
  286|  4.70M|}
Rf_endcontext:
  292|  4.30M|{
  293|  4.30M|    void R_FixupExitingHandlerResult(SEXP); /* defined in error.c */
  294|  4.30M|    SEXP R_UnwindHandlerStack(SEXP); /* defined in error.c */
  295|  4.30M|    R_HandlerStack = R_UnwindHandlerStack(cptr->handlerstack);
  296|  4.30M|    R_RestartStack = cptr->restartstack;
  297|  4.30M|    RCNTXT *jumptarget = cptr->jumptarget;
  298|  4.30M|    if (cptr->cloenv != R_NilValue && cptr->conexit != R_NilValue ) {
  ------------------
  |  Branch (298:9): [True: 4.30M, False: 0]
  |  Branch (298:39): [True: 136, False: 4.30M]
  ------------------
  299|    136|	SEXP s = cptr->conexit;
  300|    136|	Rboolean savevis = R_Visible;
  301|    136|	RCNTXT* savecontext = R_ExitContext;
  302|    136|	SEXP saveretval = R_ReturnedValue;
  303|    136|	R_ExitContext = cptr;
  304|    136|	cptr->conexit = R_NilValue; /* prevent recursion */
  305|    136|	cptr->jumptarget = NULL; /* in case on.exit expr calls return() */
  306|    136|	PROTECT(saveretval);
  ------------------
  |  |  357|    136|#define PROTECT(s)	Rf_protect(s)
  ------------------
  307|    136|	PROTECT(s);
  ------------------
  |  |  357|    136|#define PROTECT(s)	Rf_protect(s)
  ------------------
  308|    136|	R_FixupExitingHandlerResult(saveretval);
  309|    136|	SEXP cptr_retval =
  310|    136|	    cptr->returnValue.tag == 0 ? cptr->returnValue.u.sxpval : NULL;
  ------------------
  |  Branch (310:6): [True: 136, False: 0]
  ------------------
  311|    136|	if (cptr_retval) // why is this needed???
  ------------------
  |  Branch (311:6): [True: 100, False: 36]
  ------------------
  312|    100|	    INCREMENT_LINKS(cptr_retval);
  ------------------
  |  |  540|    100|#define INCREMENT_LINKS(x) do {			\
  |  |  541|    100|	SEXP il__x__ = (x);			\
  |  |  542|    100|	INCREMENT_NAMED(il__x__);		\
  |  |  ------------------
  |  |  |  |  222|    100|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 100]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  543|    100|	INCREMENT_REFCNT(il__x__);		\
  |  |  544|    100|    } while (0)
  |  |  ------------------
  |  |  |  Branch (544:14): [Folded, False: 100]
  |  |  ------------------
  ------------------
  313|    272|	for (; s != R_NilValue; s = CDR(s)) {
  ------------------
  |  Branch (313:9): [True: 136, False: 136]
  ------------------
  314|    136|	    cptr->conexit = CDR(s);
  315|    136|	    eval(CAR(s), cptr->cloenv);
  ------------------
  |  |  913|    136|#define eval			Rf_eval
  ------------------
  316|    136|	}
  317|    136|	if (cptr_retval) // why is this needed???
  ------------------
  |  Branch (317:6): [True: 100, False: 36]
  ------------------
  318|    100|	    DECREMENT_LINKS(cptr_retval);
  ------------------
  |  |  545|    100|#define DECREMENT_LINKS(x) do {			\
  |  |  546|    100|	SEXP dl__x__ = (x);			\
  |  |  547|    100|	DECREMENT_NAMED(dl__x__);		\
  |  |  ------------------
  |  |  |  |  223|    100|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (223:43): [Folded, False: 100]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  548|    100|	DECREMENT_REFCNT(dl__x__);		\
  |  |  549|    100|    } while (0)
  |  |  ------------------
  |  |  |  Branch (549:14): [Folded, False: 100]
  |  |  ------------------
  ------------------
  319|    136|	R_ReturnedValue = saveretval;
  320|    136|	UNPROTECT(2);
  ------------------
  |  |  358|    136|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  321|    136|	R_ExitContext = savecontext;
  322|    136|	R_Visible = savevis;
  323|    136|    }
  324|  4.30M|    if (R_ExitContext == cptr)
  ------------------
  |  Branch (324:9): [True: 0, False: 4.30M]
  ------------------
  325|      0|	R_ExitContext = NULL;
  326|       |    /* continue jumping if this was reached as an intermediate jump */
  327|  4.30M|    if (jumptarget)
  ------------------
  |  Branch (327:9): [True: 0, False: 4.30M]
  ------------------
  328|       |	/* cptr->returnValue is undefined */
  329|      0|	R_jumpctxt(jumptarget, cptr->jumpmask, R_ReturnedValue);
  330|       |
  331|  4.30M|    R_GlobalContext = cptr->nextcontext;
  332|  4.30M|}
Rf_findcontext:
  338|   386k|{
  339|   386k|    RCNTXT *cptr;
  340|   386k|    cptr = R_GlobalContext;
  341|   386k|    if (mask & CTXT_LOOP) {		/* break/next */
  ------------------
  |  Branch (341:9): [True: 0, False: 386k]
  ------------------
  342|      0|	for (cptr = R_GlobalContext;
  343|      0|	     cptr != NULL && cptr->callflag != CTXT_TOPLEVEL;
  ------------------
  |  Branch (343:7): [True: 0, False: 0]
  |  Branch (343:23): [True: 0, False: 0]
  ------------------
  344|      0|	     cptr = cptr->nextcontext)
  345|      0|	    if (cptr->callflag & CTXT_LOOP && cptr->cloenv == env )
  ------------------
  |  Branch (345:10): [True: 0, False: 0]
  |  Branch (345:40): [True: 0, False: 0]
  ------------------
  346|      0|		R_jumpctxt(cptr, mask, val);
  347|      0|	error(_("no loop for break/next, jumping to top level"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("no loop for break/next, jumping to top level"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  348|      0|    }
  349|   386k|    else {				/* return; or browser */
  350|   386k|	for (cptr = R_GlobalContext;
  351|  1.15M|	     cptr != NULL && cptr->callflag != CTXT_TOPLEVEL;
  ------------------
  |  Branch (351:7): [True: 773k, False: 386k]
  |  Branch (351:23): [True: 773k, False: 0]
  ------------------
  352|   773k|	     cptr = cptr->nextcontext)
  353|   773k|	    if ((cptr->callflag & mask) && cptr->cloenv == env)
  ------------------
  |  Branch (353:10): [True: 773k, False: 0]
  |  Branch (353:37): [True: 386k, False: 387k]
  ------------------
  354|   386k|		R_jumpctxt(cptr, mask, val);
  355|   386k|	error(_("no function to return from, jumping to top level"));
  ------------------
  |  |   88|   386k|#define error Rf_error
  ------------------
              	error(_("no function to return from, jumping to top level"));
  ------------------
  |  | 2531|   386k|#   define _(String) gettext (String)
  ------------------
  356|   386k|    }
  357|   386k|}
R_sysframe:
  381|    404|{
  382|    404|    if (n == 0)
  ------------------
  |  Branch (382:9): [True: 0, False: 404]
  ------------------
  383|      0|	return(R_GlobalEnv);
  384|       |
  385|    404|    if (n == NA_INTEGER) error(_("NA argument is invalid"));
  ------------------
  |  |   56|    404|#define NA_INTEGER	R_NaInt
  ------------------
                  if (n == NA_INTEGER) error(_("NA argument is invalid"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (n == NA_INTEGER) error(_("NA argument is invalid"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (385:9): [True: 0, False: 404]
  ------------------
  386|       |
  387|    404|    if (n > 0)
  ------------------
  |  Branch (387:9): [True: 404, False: 0]
  ------------------
  388|    404|	n = framedepth(cptr) - n;
  ------------------
  |  | 1904|    404|# define framedepth		Rf_framedepth
  ------------------
  389|      0|    else
  390|      0|	n = -n;
  391|       |
  392|    404|    if(n < 0)
  ------------------
  |  Branch (392:8): [True: 0, False: 404]
  ------------------
  393|      0|	error(_("not that many frames on the stack"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not that many frames on the stack"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  394|       |
  395|  3.17k|    while (cptr->nextcontext != NULL) {
  ------------------
  |  Branch (395:12): [True: 3.17k, False: 0]
  ------------------
  396|  3.17k|	if (cptr->callflag & CTXT_FUNCTION ) {
  ------------------
  |  Branch (396:6): [True: 3.08k, False: 94]
  ------------------
  397|  3.08k|	    if (n == 0) {  /* we need to detach the enclosing env */
  ------------------
  |  Branch (397:10): [True: 404, False: 2.67k]
  ------------------
  398|    404|		return cptr->cloenv;
  399|    404|	    }
  400|  2.67k|	    else
  401|  2.67k|		n--;
  402|  3.08k|	}
  403|  2.77k|	cptr = cptr->nextcontext;
  404|  2.77k|    }
  405|      0|    if(n == 0 && cptr->nextcontext == NULL)
  ------------------
  |  Branch (405:8): [True: 0, False: 0]
  |  Branch (405:18): [True: 0, False: 0]
  ------------------
  406|      0|	return R_GlobalEnv;
  407|      0|    else
  408|      0|	error(_("not that many frames on the stack"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not that many frames on the stack"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  409|      0|    return R_NilValue;	   /* just for -Wall */
  410|      0|}
R_sysparent:
  420|     34|{
  421|     34|    int j;
  422|     34|    SEXP s;
  423|     34|    if(n <= 0)
  ------------------
  |  Branch (423:8): [True: 0, False: 34]
  ------------------
  424|      0|	errorcall(R_ToplevelContext->call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  425|      0|		  _("only positive values of 'n' are allowed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  426|     34|    while (cptr->nextcontext != NULL && n > 1) {
  ------------------
  |  Branch (426:12): [True: 34, False: 0]
  |  Branch (426:41): [True: 0, False: 34]
  ------------------
  427|      0|	if (cptr->callflag & CTXT_FUNCTION )
  ------------------
  |  Branch (427:6): [True: 0, False: 0]
  ------------------
  428|      0|	    n--;
  429|      0|	cptr = cptr->nextcontext;
  430|      0|    }
  431|       |    /* make sure we're looking at a return context */
  432|     34|    while (cptr->nextcontext != NULL && !(cptr->callflag & CTXT_FUNCTION) )
  ------------------
  |  Branch (432:12): [True: 34, False: 0]
  |  Branch (432:41): [True: 0, False: 34]
  ------------------
  433|      0|	cptr = cptr->nextcontext;
  434|     34|    s = cptr->sysparent;
  435|     34|    if(s == R_GlobalEnv)
  ------------------
  |  Branch (435:8): [True: 0, False: 34]
  ------------------
  436|      0|	return 0;
  437|     34|    j = 0;
  438|    744|    while (cptr != NULL ) {
  ------------------
  |  Branch (438:12): [True: 710, False: 34]
  ------------------
  439|    710|	if (cptr->callflag & CTXT_FUNCTION) {
  ------------------
  |  Branch (439:6): [True: 648, False: 62]
  ------------------
  440|    648|	    j++;
  441|    648|	    if( cptr->cloenv == s )
  ------------------
  |  Branch (441:10): [True: 34, False: 614]
  ------------------
  442|     34|		n=j;
  443|    648|	}
  444|    710|	cptr = cptr->nextcontext;
  445|    710|    }
  446|     34|    n = j - n + 1;
  447|     34|    if (n < 0)
  ------------------
  |  Branch (447:9): [True: 0, False: 34]
  ------------------
  448|      0|	n = 0;
  449|     34|    return n;
  450|     34|}
Rf_framedepth:
  453|    506|{
  454|    506|    int nframe = 0;
  455|  11.0k|    while (cptr->nextcontext != NULL) {
  ------------------
  |  Branch (455:12): [True: 10.5k, False: 506]
  ------------------
  456|  10.5k|	if (cptr->callflag & CTXT_FUNCTION )
  ------------------
  |  Branch (456:6): [True: 9.97k, False: 590]
  ------------------
  457|  9.97k|	    nframe++;
  458|  10.5k|	cptr = cptr->nextcontext;
  459|  10.5k|    }
  460|    506|    return nframe;
  461|    506|}
R_syscall:
  483|     18|{
  484|       |    /* negative n counts back from the current frame */
  485|       |    /* positive n counts up from the globalEnv */
  486|     18|    if (n > 0)
  ------------------
  |  Branch (486:9): [True: 0, False: 18]
  ------------------
  487|      0|	n = framedepth(cptr) - n;
  ------------------
  |  | 1904|      0|# define framedepth		Rf_framedepth
  ------------------
  488|     18|    else
  489|     18|	n = - n;
  490|     18|    if(n < 0)
  ------------------
  |  Branch (490:8): [True: 0, False: 18]
  ------------------
  491|      0|	error(_("not that many frames on the stack"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not that many frames on the stack"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  492|     18|    while (cptr->nextcontext != NULL) {
  ------------------
  |  Branch (492:12): [True: 18, False: 0]
  ------------------
  493|     18|	if (cptr->callflag & CTXT_FUNCTION ) {
  ------------------
  |  Branch (493:6): [True: 18, False: 0]
  ------------------
  494|     18|	    if (n == 0)
  ------------------
  |  Branch (494:10): [True: 18, False: 0]
  ------------------
  495|     18|		return getCallWithSrcref(cptr);
  496|      0|	    else
  497|      0|		n--;
  498|     18|	}
  499|      0|	cptr = cptr->nextcontext;
  500|      0|    }
  501|      0|    if (n == 0 && cptr->nextcontext == NULL)
  ------------------
  |  Branch (501:9): [True: 0, False: 0]
  |  Branch (501:19): [True: 0, False: 0]
  ------------------
  502|      0|	return getCallWithSrcref(cptr);
  503|      0|    error(_("not that many frames on the stack"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  error(_("not that many frames on the stack"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  504|      0|    return R_NilValue;	/* just for -Wall */
  505|      0|}
R_sysfunction:
  508|     40|{
  509|     40|    if (n > 0)
  ------------------
  |  Branch (509:9): [True: 34, False: 6]
  ------------------
  510|     34|	n = framedepth(cptr) - n;
  ------------------
  |  | 1904|     34|# define framedepth		Rf_framedepth
  ------------------
  511|      6|    else
  512|      6|	n = - n;
  513|     40|    if (n < 0)
  ------------------
  |  Branch (513:9): [True: 0, False: 40]
  ------------------
  514|      0|	error(_("not that many frames on the stack"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not that many frames on the stack"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  515|     74|    while (cptr->nextcontext != NULL) {
  ------------------
  |  Branch (515:12): [True: 74, False: 0]
  ------------------
  516|     74|	if (cptr->callflag & CTXT_FUNCTION ) {
  ------------------
  |  Branch (516:6): [True: 74, False: 0]
  ------------------
  517|     74|	    if (n == 0)
  ------------------
  |  Branch (517:10): [True: 40, False: 34]
  ------------------
  518|     40|		return duplicate(cptr->callfun);  /***** do we need to DUP? */
  ------------------
  |  |  909|     40|#define duplicate		Rf_duplicate
  ------------------
  519|     34|	    else
  520|     34|		n--;
  521|     74|	}
  522|     34|	cptr = cptr->nextcontext;
  523|     34|    }
  524|      0|    if (n == 0 && cptr->nextcontext == NULL)
  ------------------
  |  Branch (524:9): [True: 0, False: 0]
  |  Branch (524:19): [True: 0, False: 0]
  ------------------
  525|      0|	return duplicate(cptr->callfun);  /***** do we need to DUP? */
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
  526|      0|    error(_("not that many frames on the stack"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  error(_("not that many frames on the stack"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  527|      0|    return R_NilValue;	/* just for -Wall */
  528|      0|}
getLexicalContext:
  634|    530|{
  635|    530|    RCNTXT *cptr = R_GlobalContext;
  636|       |
  637|  1.22k|    while (cptr && cptr != R_ToplevelContext) {
  ------------------
  |  Branch (637:12): [True: 1.22k, False: 0]
  |  Branch (637:20): [True: 1.22k, False: 0]
  ------------------
  638|  1.22k|	if (cptr->callflag & CTXT_FUNCTION && cptr->cloenv == rho)
  ------------------
  |  Branch (638:6): [True: 1.22k, False: 0]
  |  Branch (638:40): [True: 530, False: 690]
  ------------------
  639|    530|	    break;
  640|    690|	cptr = cptr->nextcontext;
  641|    690|    }
  642|       |
  643|    530|    return cptr;
  644|    530|}
do_sys:
  658|    530|{
  659|    530|    int i, n  = -1, nframe;
  660|    530|    SEXP rval;
  661|       |
  662|    530|    checkArity(op, args);
  ------------------
  |  | 1788|    530|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  663|       |
  664|       |    /* first find the context that sys.xxx needs to be evaluated in */
  665|    530|    SEXP t = R_GlobalContext->sysparent;
  666|    530|    RCNTXT *cptr = getLexicalContext(t);
  667|       |
  668|    530|    if (length(args) == 1) n = asInteger(CAR(args));
  ------------------
  |  |  987|    530|#define length(x)		Rf_length(x)
  ------------------
                  if (length(args) == 1) n = asInteger(CAR(args));
  ------------------
  |  |  885|    496|#define asInteger		Rf_asInteger
  ------------------
  |  Branch (668:9): [True: 496, False: 34]
  ------------------
  669|       |
  670|    530|    switch (PRIMVAL(op)) {
  ------------------
  |  | 1347|    530|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  671|     34|    case 1: /* parent */
  ------------------
  |  Branch (671:5): [True: 34, False: 496]
  ------------------
  672|     34|	if(n == NA_INTEGER)
  ------------------
  |  |   56|     34|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (672:5): [True: 0, False: 34]
  ------------------
  673|      0|	    error(_("invalid '%s' argument"), "n");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' argument"), "n");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  674|     34|	i = nframe = framedepth(cptr);
  ------------------
  |  | 1904|     34|# define framedepth		Rf_framedepth
  ------------------
  675|       |	/* This is a pretty awful kludge, but the alternative would be
  676|       |	   a major redesign of everything... -pd */
  677|     68|	while (n-- > 0)
  ------------------
  |  Branch (677:9): [True: 34, False: 34]
  ------------------
  678|     34|	    i = R_sysparent(nframe - i + 1, cptr);
  679|     34|	return ScalarInteger(i);
  ------------------
  |  | 1022|     34|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  680|     18|    case 2: /* call */
  ------------------
  |  Branch (680:5): [True: 18, False: 512]
  ------------------
  681|     18|	if(n == NA_INTEGER)
  ------------------
  |  |   56|     18|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (681:5): [True: 0, False: 18]
  ------------------
  682|      0|	    error(_("invalid '%s' argument"), "which");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' argument"), "which");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  683|     18|	return R_syscall(n, cptr);
  684|    404|    case 3: /* frame */
  ------------------
  |  Branch (684:5): [True: 404, False: 126]
  ------------------
  685|    404|	if(n == NA_INTEGER)
  ------------------
  |  |   56|    404|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (685:5): [True: 0, False: 404]
  ------------------
  686|      0|	    error(_("invalid '%s' argument"), "which");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' argument"), "which");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  687|    404|	return R_sysframe(n, cptr);
  688|     34|    case 4: /* sys.nframe */
  ------------------
  |  Branch (688:5): [True: 34, False: 496]
  ------------------
  689|     34|	return ScalarInteger(framedepth(cptr));
  ------------------
  |  | 1022|     34|#define ScalarInteger		Rf_ScalarInteger
  ------------------
              	return ScalarInteger(framedepth(cptr));
  ------------------
  |  | 1904|     34|# define framedepth		Rf_framedepth
  ------------------
  690|      0|    case 5: /* sys.calls */
  ------------------
  |  Branch (690:5): [True: 0, False: 530]
  ------------------
  691|      0|	nframe = framedepth(cptr);
  ------------------
  |  | 1904|      0|# define framedepth		Rf_framedepth
  ------------------
  692|      0|	PROTECT(rval = allocList(nframe));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  693|      0|	t=rval;
  694|      0|	for(i = 1; i <= nframe; i++, t = CDR(t))
  ------------------
  |  Branch (694:13): [True: 0, False: 0]
  ------------------
  695|      0|	    SETCAR(t, R_syscall(i, cptr));
  696|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  697|      0|	return rval;
  698|      0|    case 6: /* sys.frames */
  ------------------
  |  Branch (698:5): [True: 0, False: 530]
  ------------------
  699|      0|	nframe = framedepth(cptr);
  ------------------
  |  | 1904|      0|# define framedepth		Rf_framedepth
  ------------------
  700|      0|	PROTECT(rval = allocList(nframe));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  701|      0|	t = rval;
  702|      0|	for(i = 1; i <= nframe; i++, t = CDR(t))
  ------------------
  |  Branch (702:13): [True: 0, False: 0]
  ------------------
  703|      0|	    SETCAR(t, R_sysframe(i, cptr));
  704|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  705|      0|	return rval;
  706|      0|    case 7: /* sys.on.exit */
  ------------------
  |  Branch (706:5): [True: 0, False: 530]
  ------------------
  707|      0|	{
  708|      0|	    SEXP conexit = cptr->conexit;
  709|      0|	    if (conexit == R_NilValue)
  ------------------
  |  Branch (709:10): [True: 0, False: 0]
  ------------------
  710|      0|		return R_NilValue;
  711|      0|	    else if (CDR(conexit) == R_NilValue)
  ------------------
  |  Branch (711:15): [True: 0, False: 0]
  ------------------
  712|      0|		return CAR(conexit);
  713|      0|	    else
  714|      0|		return LCONS(R_BraceSymbol, conexit);
  ------------------
  |  |  310|      0|#define LCONS(a, b)	Rf_lcons((a), (b))		/* language lists */
  ------------------
  715|      0|	}
  716|      0|    case 8: /* sys.parents */
  ------------------
  |  Branch (716:5): [True: 0, False: 530]
  ------------------
  717|      0|	nframe = framedepth(cptr);
  ------------------
  |  | 1904|      0|# define framedepth		Rf_framedepth
  ------------------
  718|      0|	rval = allocVector(INTSXP, nframe);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	rval = allocVector(INTSXP, nframe);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  719|      0|	for(i = 0; i < nframe; i++)
  ------------------
  |  Branch (719:13): [True: 0, False: 0]
  ------------------
  720|      0|	    INTEGER(rval)[i] = R_sysparent(nframe - i, cptr);
  721|      0|	return rval;
  722|     40|    case 9: /* sys.function */
  ------------------
  |  Branch (722:5): [True: 40, False: 490]
  ------------------
  723|     40|	if(n == NA_INTEGER)
  ------------------
  |  |   56|     40|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (723:5): [True: 0, False: 40]
  ------------------
  724|      0|	    error(_("invalid '%s' value"), "which");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' value"), "which");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  725|     40|	return(R_sysfunction(n, cptr));
  726|      0|    default:
  ------------------
  |  Branch (726:5): [True: 0, False: 530]
  ------------------
  727|      0|	error(_("internal error in 'do_sys'"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("internal error in 'do_sys'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  728|      0|	return R_NilValue;/* just for -Wall */
  729|    530|    }
  730|    530|}
do_parentframe:
  733|  4.91k|{
  734|  4.91k|    checkArity(op, args);
  ------------------
  |  | 1788|  4.91k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  735|       |
  736|  4.91k|    int n = asInteger(CAR(args));
  ------------------
  |  |  885|  4.91k|#define asInteger		Rf_asInteger
  ------------------
  737|  4.91k|    if(n == NA_INTEGER || n < 1 )
  ------------------
  |  |   56|  9.82k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (737:8): [True: 0, False: 4.91k]
  |  Branch (737:27): [True: 0, False: 4.91k]
  ------------------
  738|      0|	error(_("invalid '%s' value"), "n");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' value"), "n");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  739|       |
  740|  4.91k|    RCNTXT *cptr = R_findParentContext(R_GlobalContext, n);
  741|       |
  742|  4.91k|    if (cptr)
  ------------------
  |  Branch (742:9): [True: 4.91k, False: 0]
  ------------------
  743|  4.91k|	return cptr->sysparent;
  744|      0|    else
  745|      0|	return R_GlobalEnv;
  746|  4.91k|}
R_findExecContext:
  752|  4.96k|{
  753|  9.95k|    while (cptr->nextcontext != NULL) {
  ------------------
  |  Branch (753:12): [True: 9.95k, False: 0]
  ------------------
  754|  9.95k|	if ((cptr->callflag & CTXT_FUNCTION) != 0 && cptr->cloenv == envir)
  ------------------
  |  Branch (754:6): [True: 9.95k, False: 0]
  |  Branch (754:47): [True: 4.96k, False: 4.99k]
  ------------------
  755|  4.96k|	    return cptr;
  756|  4.99k|	cptr = cptr->nextcontext;
  757|  4.99k|    }
  758|      0|    return NULL;
  759|  4.96k|}
R_findParentContext:
  768|  4.91k|{
  769|  4.96k|    while ((cptr = R_findExecContext(cptr, cptr->sysparent)) != NULL) {
  ------------------
  |  Branch (769:12): [True: 4.96k, False: 0]
  ------------------
  770|  4.96k|	if (n == 1)
  ------------------
  |  Branch (770:6): [True: 4.91k, False: 51]
  ------------------
  771|  4.91k|	    return cptr;
  772|     51|	n--;
  773|     51|    }
  774|      0|    return NULL;
  775|  4.91k|}
R_ToplevelExec:
  784|  3.74k|{
  785|  3.74k|    RCNTXT thiscontext;
  786|  3.74k|    RCNTXT * volatile saveToplevelContext;
  787|  3.74k|    volatile SEXP topExp, oldHStack, oldRStack, oldRVal;
  788|  3.74k|    volatile Rboolean oldvis;
  789|  3.74k|    Rboolean result;
  790|       |
  791|       |
  792|  3.74k|    PROTECT(topExp = R_CurrentExpr);
  ------------------
  |  |  357|  3.74k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  793|  3.74k|    PROTECT(oldHStack = R_HandlerStack);
  ------------------
  |  |  357|  3.74k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  794|  3.74k|    PROTECT(oldRStack = R_RestartStack);
  ------------------
  |  |  357|  3.74k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  795|  3.74k|    PROTECT(oldRVal = R_ReturnedValue);
  ------------------
  |  |  357|  3.74k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  796|  3.74k|    oldvis = R_Visible;
  797|  3.74k|    R_HandlerStack = R_NilValue;
  798|  3.74k|    R_RestartStack = R_NilValue;
  799|  3.74k|    saveToplevelContext = R_ToplevelContext;
  800|       |
  801|  3.74k|    begincontext(&thiscontext, CTXT_TOPLEVEL, R_NilValue, R_GlobalEnv,
  ------------------
  |  | 1864|  3.74k|# define begincontext		Rf_begincontext
  ------------------
  802|  3.74k|		 R_BaseEnv, R_NilValue, R_NilValue);
  803|  3.74k|    if (SETJMP(thiscontext.cjmpbuf))
  ------------------
  |  | 1162|  3.74k|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (803:9): [True: 1.87k, False: 1.87k]
  ------------------
  804|  1.87k|	result = FALSE;
  805|  1.87k|    else {
  806|  1.87k|	R_GlobalContext = R_ToplevelContext = &thiscontext;
  807|  1.87k|	fun(data);
  808|  1.87k|	result = TRUE;
  809|  1.87k|    }
  810|  3.74k|    endcontext(&thiscontext);
  ------------------
  |  | 1895|  3.74k|# define endcontext		Rf_endcontext
  ------------------
  811|       |
  812|  3.74k|    R_ToplevelContext = saveToplevelContext;
  813|  3.74k|    R_CurrentExpr = topExp;
  814|  3.74k|    R_HandlerStack = oldHStack;
  815|  3.74k|    R_RestartStack = oldRStack;
  816|  3.74k|    R_ReturnedValue = oldRVal;
  817|  3.74k|    R_Visible = oldvis;
  818|  3.74k|    UNPROTECT(4);
  ------------------
  |  |  358|  3.74k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  819|       |
  820|  3.74k|    return result;
  821|  3.74k|}
R_tryEval:
  877|  1.87k|{
  878|  1.87k|    Rboolean ok;
  879|  1.87k|    ProtectedEvalData data;
  880|       |
  881|  1.87k|    data.expression = e;
  882|  1.87k|    data.val = NULL;
  883|  1.87k|    data.env = env;
  884|       |
  885|  1.87k|    ok = R_ToplevelExec(protectedEval, &data);
  886|  1.87k|    if (ErrorOccurred) {
  ------------------
  |  Branch (886:9): [True: 1.87k, False: 0]
  ------------------
  887|  1.87k|	*ErrorOccurred = (ok == FALSE);
  888|  1.87k|    }
  889|  1.87k|    if (ok == FALSE)
  ------------------
  |  Branch (889:9): [True: 1.87k, False: 2]
  ------------------
  890|  1.87k|	data.val = NULL;
  891|      2|    else
  892|      2|	R_ReleaseObject(data.val);
  893|       |
  894|  1.87k|    return(data.val);
  895|  1.87k|}
R_tryEvalSilent:
  904|  1.87k|{
  905|  1.87k|    SEXP val;
  906|  1.87k|    int oldshow = R_ShowErrorMessages;
  907|  1.87k|    R_ShowErrorMessages = FALSE;
  908|  1.87k|    val = R_tryEval(e, env, ErrorOccurred);
  909|  1.87k|    R_ShowErrorMessages = oldshow;
  910|  1.87k|    return val;
  911|  1.87k|}
R_MakeUnwindCont:
  941|     34|{
  942|     34|    return CONS(R_NilValue, allocVector(RAWSXP, sizeof(unwind_cont_t)));
  ------------------
  |  |  309|     34|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  943|     34|}
R_UnwindProtect:
  957|     68|{
  958|     68|    RCNTXT thiscontext;
  959|     68|    volatile SEXP result;
  960|     68|    Rboolean jump;
  961|       |
  962|       |    /* Allow simple usage with a NULL continuation token. This _could_
  963|       |       result in a failure in allocation or exceeding the PROTECT
  964|       |       stack limit before calling fun(), so fun() and cleanfun should
  965|       |       be written accordingly. */
  966|     68|    if (cont == NULL) {
  ------------------
  |  Branch (966:9): [True: 34, False: 34]
  ------------------
  967|     34|	PROTECT(cont = R_MakeUnwindCont());
  ------------------
  |  |  357|     34|#define PROTECT(s)	Rf_protect(s)
  ------------------
  968|     34|	result = R_UnwindProtect(fun, data, cleanfun, cleandata, cont);
  969|     34|	UNPROTECT(1);
  ------------------
  |  |  358|     34|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  970|     34|	return result;
  971|     34|    }
  972|       |
  973|     34|    begincontext(&thiscontext, CTXT_UNWIND, R_NilValue, R_GlobalEnv,
  ------------------
  |  | 1864|     34|# define begincontext		Rf_begincontext
  ------------------
  974|     34|		 R_BaseEnv, R_NilValue, R_NilValue);
  975|     34|    if (SETJMP(thiscontext.cjmpbuf)) {
  ------------------
  |  | 1162|     34|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (975:9): [True: 0, False: 34]
  ------------------
  976|      0|	jump = TRUE;
  977|      0|	SETCAR(cont, R_ReturnedValue);
  978|      0|	unwind_cont_t *u = RAWDATA(CDR(cont));
  ------------------
  |  |  945|      0|#define RAWDATA(x) ((void *) RAW0(x))
  ------------------
  979|      0|	u->jumpmask = thiscontext.jumpmask;
  980|      0|	u->jumptarget = thiscontext.jumptarget;
  981|      0|	thiscontext.jumptarget = NULL;
  982|      0|    }
  983|     34|    else {
  984|     34|	result = fun(data);
  985|     34|	SETCAR(cont, result);
  986|     34|	jump = FALSE;
  987|     34|    }
  988|     34|    endcontext(&thiscontext);
  ------------------
  |  | 1895|     34|# define endcontext		Rf_endcontext
  ------------------
  989|       |
  990|     34|    cleanfun(cleandata, jump);
  991|       |
  992|     34|    if (jump)
  ------------------
  |  Branch (992:9): [True: 0, False: 34]
  ------------------
  993|      0|	R_ContinueUnwind(cont);	
  994|       |
  995|     34|    return result;
  996|     68|}
context.c:first_jump_target:
  199|   388k|{
  200|   388k|    RCNTXT *c;
  201|       |
  202|   780k|    for (c = R_GlobalContext; c && c != cptr; c = c->nextcontext) {
  ------------------
  |  Branch (202:31): [True: 780k, False: 0]
  |  Branch (202:36): [True: 392k, False: 388k]
  ------------------
  203|   392k|	if ((c->cloenv != R_NilValue && c->conexit != R_NilValue) ||
  ------------------
  |  Branch (203:7): [True: 392k, False: 0]
  |  Branch (203:34): [True: 36, False: 392k]
  ------------------
  204|   392k|	    c->callflag == CTXT_UNWIND) {
  ------------------
  |  Branch (204:6): [True: 0, False: 392k]
  ------------------
  205|     36|	    c->jumptarget = cptr;
  206|     36|	    c->jumpmask = mask;
  207|     36|	    return c;
  208|     36|	}
  209|   392k|    }
  210|   388k|    return cptr;
  211|   388k|}
context.c:R_restore_globals:
  171|   388k|{
  172|   388k|    R_PPStackTop = cptr->cstacktop;
  173|   388k|    R_GCEnabled = cptr->gcenabled;
  174|   388k|    R_BCIntActive = cptr->bcintactive;
  175|   388k|    R_BCpc = cptr->bcpc;
  176|   388k|    R_BCbody = cptr->bcbody;
  177|   388k|    R_BCFrame = cptr->bcframe;
  178|   388k|    R_EvalDepth = cptr->evaldepth;
  179|   388k|    vmaxset(cptr->vmax);
  180|   388k|    R_interrupts_suspended = (Rboolean) cptr->intsusp;
  181|   388k|    R_HandlerStack = cptr->handlerstack;
  182|   388k|    R_RestartStack = cptr->restartstack;
  183|   776k|    while (R_PendingPromises != cptr->prstack) {
  ------------------
  |  Branch (183:12): [True: 388k, False: 388k]
  ------------------
  184|       |	/* The value 2 installed in PRSEEN 2 allows forcePromise in
  185|       |	   eval.c to signal a warning when asked to evaluate a promise
  186|       |	   whose evaluation has been interrupted by a jump. */
  187|   388k|	SET_PRSEEN(R_PendingPromises->promise, 2);
  188|   388k|	R_PendingPromises = R_PendingPromises->next;
  189|   388k|    }
  190|       |    /* Need to reset R_Expressions in case we are jumping after
  191|       |       handling a stack overflow. */
  192|   388k|    R_Expressions = R_Expressions_keep;
  193|   388k|    R_BCNodeStackTop = cptr->nodestack;
  194|   388k|    R_Srcref = cptr->srcref;
  195|   388k|    R_BCProtReset(cptr->bcprottop);
  196|   388k|}
context.c:getCallWithSrcref:
  464|     18|{
  465|     18|    SEXP result;
  466|       |
  467|     18|    PROTECT(result = shallow_duplicate(cptr->call));
  ------------------
  |  |  357|     18|#define PROTECT(s)	Rf_protect(s)
  ------------------
  468|     18|    if (cptr->srcref && !isNull(cptr->srcref)) {
  ------------------
  |  |  956|     18|#define isNull			Rf_isNull
  ------------------
  |  Branch (468:9): [True: 18, False: 0]
  |  Branch (468:25): [True: 18, False: 0]
  ------------------
  469|     18|	SEXP sref;
  470|     18|	if (cptr->srcref == R_InBCInterpreter)
  ------------------
  |  Branch (470:6): [True: 18, False: 0]
  ------------------
  471|       |	    /* FIXME: this is expensive, it might be worth changing sys.call */
  472|       |	    /* to return srcrefs only on request (add `with.source` option) */
  473|     18|	    sref = R_findBCInterpreterSrcref(cptr);
  474|      0|	else
  475|      0|	    sref = cptr->srcref;
  476|     18|	setAttrib(result, R_SrcrefSymbol, duplicate(sref));
  ------------------
  |  | 1027|     18|#define setAttrib		Rf_setAttrib
  ------------------
              	setAttrib(result, R_SrcrefSymbol, duplicate(sref));
  ------------------
  |  |  909|     18|#define duplicate		Rf_duplicate
  ------------------
  477|     18|    }
  478|     18|    UNPROTECT(1);
  ------------------
  |  |  358|     18|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  479|     18|    return result;
  480|     18|}
context.c:protectedEval:
  865|  1.87k|{
  866|  1.87k|    ProtectedEvalData *data = (ProtectedEvalData *)d;
  867|  1.87k|    SEXP env = R_GlobalEnv;
  868|  1.87k|    if(data->env) {
  ------------------
  |  Branch (868:8): [True: 1.87k, False: 0]
  ------------------
  869|  1.87k|	env = data->env;
  870|  1.87k|    }
  871|  1.87k|    data->val = eval(data->expression, env);
  ------------------
  |  |  913|  1.87k|#define eval			Rf_eval
  ------------------
  872|  1.87k|    R_PreserveObject(data->val);
  873|  1.87k|}

do_deparse:
  168|     64|{
  169|     64|    checkArity(op, args);
  ------------------
  |  | 1788|     64|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  170|       |
  171|     64|    SEXP expr = CAR(args); args = CDR(args);
  172|     64|    int cut0 = DEFAULT_Cutoff;
  ------------------
  |  |  119|     64|#define DEFAULT_Cutoff 60
  ------------------
  173|     64|    if(!isNull(CAR(args))) {
  ------------------
  |  |  956|     64|#define isNull			Rf_isNull
  ------------------
  |  Branch (173:8): [True: 64, False: 0]
  ------------------
  174|     64|	cut0 = asInteger(CAR(args));
  ------------------
  |  |  885|     64|#define asInteger		Rf_asInteger
  ------------------
  175|     64|	if(cut0 == NA_INTEGER|| cut0 < MIN_Cutoff || cut0 > MAX_Cutoff) {
  ------------------
  |  |   56|    128|#define NA_INTEGER	R_NaInt
  ------------------
              	if(cut0 == NA_INTEGER|| cut0 < MIN_Cutoff || cut0 > MAX_Cutoff) {
  ------------------
  |  |  118|    128|#define MIN_Cutoff 20
  ------------------
              	if(cut0 == NA_INTEGER|| cut0 < MIN_Cutoff || cut0 > MAX_Cutoff) {
  ------------------
  |  |  120|     64|#define MAX_Cutoff (BUFSIZE - 12)
  |  |  ------------------
  |  |  |  |  116|     64|#define BUFSIZE 512
  |  |  ------------------
  ------------------
  |  Branch (175:5): [True: 0, False: 64]
  |  Branch (175:26): [True: 0, False: 64]
  |  Branch (175:47): [True: 0, False: 64]
  ------------------
  176|      0|	    warning(_("invalid 'cutoff' value for 'deparse', using default"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("invalid 'cutoff' value for 'deparse', using default"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  177|      0|	    cut0 = DEFAULT_Cutoff;
  ------------------
  |  |  119|      0|#define DEFAULT_Cutoff 60
  ------------------
  178|      0|	}
  179|     64|    }
  180|     64|    args = CDR(args);
  181|     64|    bool backtick = isNull(CAR(args)) ? 0 : asRbool(CAR(args), call);
  ------------------
  |  |  956|     64|#define isNull			Rf_isNull
  ------------------
                  bool backtick = isNull(CAR(args)) ? 0 : asRbool(CAR(args), call);
  ------------------
  |  | 1861|     64|# define asRbool		Rf_asRbool
  ------------------
  |  Branch (181:21): [True: 0, False: 64]
  ------------------
  182|     64|    args = CDR(args);
  183|     64|    int opts = isNull(CAR(args)) ? SHOWATTRIBUTES : asInteger(CAR(args));
  ------------------
  |  |  956|     64|#define isNull			Rf_isNull
  ------------------
                  int opts = isNull(CAR(args)) ? SHOWATTRIBUTES : asInteger(CAR(args));
  ------------------
  |  | 2070|      0|#define SHOWATTRIBUTES 		4
  ------------------
                  int opts = isNull(CAR(args)) ? SHOWATTRIBUTES : asInteger(CAR(args));
  ------------------
  |  |  885|     64|#define asInteger		Rf_asInteger
  ------------------
  |  Branch (183:16): [True: 0, False: 64]
  ------------------
  184|     64|    args = CDR(args);
  185|     64|    int nlines = asInteger(CAR(args));
  ------------------
  |  |  885|     64|#define asInteger		Rf_asInteger
  ------------------
  186|     64|    if (nlines == NA_INTEGER) nlines = -1;
  ------------------
  |  |   56|     64|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (186:9): [True: 0, False: 64]
  ------------------
  187|     64|    return deparse1WithCutoff(expr, false, cut0, backtick, opts, nlines);
  188|     64|}
Rf_deparse1s:
  384|  1.90k|{
  385|  1.90k|   bool backtick=true;
  386|  1.90k|   return
  387|  1.90k|       deparse1WithCutoff(call, false, DEFAULT_Cutoff, backtick,
  ------------------
  |  |  119|  1.90k|#define DEFAULT_Cutoff 60
  ------------------
  388|  1.90k|			  DEFAULTDEPARSE, /* nlines = */ 1);
  ------------------
  |  | 2081|  1.90k|#define DEFAULTDEPARSE		1089 /* KEEPINTEGER | KEEPNA | NICE_NAMES, used for calls */
  ------------------
  389|  1.90k|}
deparse.c:deparse1WithCutoff:
  234|  1.97k|{
  235|       |/* Arg. abbrev:
  236|       |	If abbrev is TRUE, then the returned value
  237|       |	is a STRSXP of length 1 with at most 13 characters.
  238|       |	This is used for plot labelling etc.
  239|       |*/
  240|  1.97k|    SEXP svec;
  241|  1.97k|    int savedigits;
  242|  1.97k|    bool need_ellipses = false;
  243|  1.97k|    LocalParseData localData = {
  244|  1.97k|	.linenumber = 0,
  245|  1.97k|	.len = 0,
  246|  1.97k|	.incurly = 0,
  247|  1.97k|	.inlist = 0,
  248|  1.97k|	.startline = true,
  249|  1.97k|	.indent = 0,
  250|  1.97k|	.strvec = NULL,
  251|  1.97k|	.left = 0,
  252|  1.97k|	.buffer = { NULL, 0, BUFSIZE },
  ------------------
  |  |  116|  1.97k|#define BUFSIZE 512
  ------------------
  253|  1.97k|	.cutoff = DEFAULT_Cutoff,
  ------------------
  |  |  119|  1.97k|#define DEFAULT_Cutoff 60
  ------------------
  254|  1.97k|	.backtick = false,
  255|  1.97k|	.opts = 0,
  256|  1.97k|	.sourceable = true,
  257|       |#ifdef longstring_WARN
  258|       |	.longstring = false,
  259|       |#endif
  260|  1.97k|	.maxlines = INT_MAX,
  261|  1.97k|	.active = true,
  262|  1.97k|	.isS4 = 0,
  263|  1.97k|	.fnarg = false
  264|  1.97k|    };
  265|  1.97k|    localData.cutoff = cutoff;
  266|  1.97k|    localData.backtick = backtick;
  267|  1.97k|    localData.opts = opts;
  268|  1.97k|    localData.strvec = R_NilValue;
  269|       |
  270|       |    /* Set up a context to free the heap-allocated buffer when an error
  271|       |       signalled during deparsing unwinds past this frame */
  272|  1.97k|    RCNTXT cntxt;
  273|  1.97k|    begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
  ------------------
  |  | 1864|  1.97k|# define begincontext		Rf_begincontext
  ------------------
  274|  1.97k|		 R_NilValue, R_NilValue);
  275|  1.97k|    cntxt.cend = &deparse_cleanup;
  276|  1.97k|    cntxt.cenddata = &localData;
  277|       |
  278|  1.97k|    PrintDefaults(); /* from global options() */
  ------------------
  |  | 1970|  1.97k|# define PrintDefaults		Rf_PrintDefaults
  ------------------
  279|  1.97k|    savedigits = R_print.digits;
  280|  1.97k|    R_print.digits = DBL_DIG;/* MAX precision */
  281|  1.97k|    print2buff("", &localData); /* ensure allocation of buffer.data, PR#17876 */
  282|       |
  283|  1.97k|    svec = R_NilValue;
  284|  1.97k|    if (nlines > 0) {
  ------------------
  |  Branch (284:9): [True: 1.90k, False: 64]
  ------------------
  285|  1.90k|	localData.linenumber = localData.maxlines = nlines;
  286|  1.90k|    } else { // default: nlines = -1 (from R), or = 0 (from other C fn's)
  287|     64|	if(R_BrowseLines > 0)// not by default; e.g. from getOption("deparse.max.lines")
  ------------------
  |  Branch (287:5): [True: 0, False: 64]
  ------------------
  288|      0|	    localData.maxlines = R_BrowseLines + 1; // enough to determine linenumber
  289|     64|	deparse2(call, svec, &localData);
  290|     64|	localData.active = true;
  291|     64|	if(R_BrowseLines > 0 && localData.linenumber > R_BrowseLines) {
  ------------------
  |  Branch (291:5): [True: 0, False: 64]
  |  Branch (291:26): [True: 0, False: 0]
  ------------------
  292|      0|	    localData.linenumber = R_BrowseLines + 1;
  293|      0|	    need_ellipses = true;
  294|      0|	}
  295|     64|    }
  296|  1.97k|    PROTECT(svec = allocVector(STRSXP, localData.linenumber));
  ------------------
  |  |  357|  1.97k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  297|  1.97k|    deparse2(call, svec, &localData);
  298|  1.97k|    if (abbrev) {
  ------------------
  |  Branch (298:9): [True: 0, False: 1.97k]
  ------------------
  299|      0|	char data[14];
  300|      0|	strncpy(data, CHAR(STRING_ELT(svec, 0)), 10);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  301|      0|	data[10] = '\0';
  302|      0|	if (strlen(CHAR(STRING_ELT(svec, 0))) > 10) strcat(data, "...");
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (302:6): [True: 0, False: 0]
  ------------------
  303|      0|	svec = mkString(data);
  ------------------
  |  | 1003|      0|#define mkString		Rf_mkString
  ------------------
  304|  1.97k|    } else if(need_ellipses) {
  ------------------
  |  Branch (304:15): [True: 0, False: 1.97k]
  ------------------
  305|      0|	SET_STRING_ELT(svec, R_BrowseLines, mkChar("  ..."));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  306|      0|    }
  307|  1.97k|    if(nlines > 0 && localData.linenumber < nlines) {
  ------------------
  |  Branch (307:8): [True: 1.90k, False: 64]
  |  Branch (307:22): [True: 0, False: 1.90k]
  ------------------
  308|      0|	UNPROTECT(1); /* old svec value */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  309|      0|	PROTECT(svec);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  310|      0|	svec = lengthgets(svec, localData.linenumber);
  ------------------
  |  |  988|      0|#define lengthgets		Rf_lengthgets
  ------------------
  311|      0|    }
  312|  1.97k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.97k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  313|  1.97k|    PROTECT(svec); /* protect from warning() allocating, PR#14356 */
  ------------------
  |  |  357|  1.97k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  314|  1.97k|    R_print.digits = savedigits;
  315|       |    /*: Don't warn anymore, we do deal with most (-> 'S4SXP' below)
  316|       |    if ((opts & WARNINCOMPLETE) && localData.isS4)
  317|       |	warning(_("deparse of an S4 object may not always be source()able"));
  318|       |	else */
  319|  1.97k|    if ((opts & WARNINCOMPLETE) && !localData.sourceable)
  ------------------
  |  | 2072|  1.97k|#define WARNINCOMPLETE 		16
  ------------------
  |  Branch (319:9): [True: 0, False: 1.97k]
  |  Branch (319:36): [True: 0, False: 0]
  ------------------
  320|      0|	warning(_("deparse may be incomplete"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("deparse may be incomplete"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  321|       |#ifdef longstring_WARN
  322|       |    if ((opts & WARNINCOMPLETE) && localData.longstring)
  323|       |	warning(_("deparse may be not be source()able in R < 2.7.0"));
  324|       |#endif
  325|       |    /* somewhere lower down might have allocated ... */
  326|  1.97k|    endcontext(&cntxt);
  ------------------
  |  | 1895|  1.97k|# define endcontext		Rf_endcontext
  ------------------
  327|  1.97k|    R_FreeStringBuffer(&(localData.buffer));
  328|  1.97k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.97k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  329|  1.97k|    return svec;
  330|  1.97k|}
deparse.c:print2buff:
 1606|  35.3k|{
 1607|  35.3k|    size_t tlen, bufflen;
 1608|  35.3k|    static unsigned int appends = 0;
 1609|       |
 1610|  35.3k|    if ((++appends & 1023) == 0)
  ------------------
  |  Branch (1610:9): [True: 34, False: 35.2k]
  ------------------
 1611|     34|	R_UnwindProtect(deparse_poll, NULL,
 1612|     34|			deparse_poll_cleanup, &(d->buffer), NULL);
 1613|       |
 1614|  35.3k|    if (d->startline) {
  ------------------
  |  Branch (1614:9): [True: 2.82k, False: 32.5k]
  ------------------
 1615|  2.82k|	d->startline = false;
 1616|  2.82k|	printtab2buff(d->indent, d);	/*if at the start of a line tab over */
 1617|  2.82k|    }
 1618|  35.3k|    tlen = strlen(strng);
 1619|  35.3k|    R_AllocStringBuffer(0, &(d->buffer));
 1620|  35.3k|    bufflen = strlen(d->buffer.data);
 1621|  35.3k|    R_AllocStringBuffer(bufflen + tlen, &(d->buffer));
 1622|  35.3k|    strcat(d->buffer.data, strng);
 1623|  35.3k|    d->len += (int) tlen;
 1624|  35.3k|}
deparse.c:deparse_poll:
 1593|     34|{
 1594|     34|    (void) data;
 1595|     34|    R_CheckUserInterrupt();
 1596|     34|    return R_NilValue;
 1597|     34|}
deparse.c:deparse_poll_cleanup:
 1600|     34|{
 1601|     34|    if (jump)
  ------------------
  |  Branch (1601:9): [True: 0, False: 34]
  ------------------
 1602|      0|	R_FreeStringBuffer((R_StringBuffer *) data);
 1603|     34|}
deparse.c:printtab2buff:
 2017|  2.82k|{
 2018|  2.82k|    int i;
 2019|       |
 2020|  3.44k|    for (i = 1; i <= ntab; i++)
  ------------------
  |  Branch (2020:17): [True: 624, False: 2.82k]
  ------------------
 2021|    624|	if (i <= 4)
  ------------------
  |  Branch (2021:6): [True: 624, False: 0]
  ------------------
 2022|    624|	    print2buff("    ", d);
 2023|      0|	else
 2024|      0|	    print2buff("  ", d);
 2025|  2.82k|}
deparse.c:deparse2:
  568|  2.03k|{
  569|  2.03k|    d->strvec = svec;
  570|  2.03k|    d->linenumber = 0;
  571|  2.03k|    d->indent = 0;
  572|  2.03k|    deparse2buff(what, d);
  573|  2.03k|    writeline(d);
  574|  2.03k|}
deparse.c:deparse2buff:
  914|  16.0k|{
  915|  16.0k|    bool lookahead = false, lbreak = false, fnarg = d->fnarg;
  916|  16.0k|    attr_type attr = STRUC_ATTR;
  917|  16.0k|    SEXP t;
  918|  16.0k|    int d_opts_in = d->opts, i, n;
  919|       |
  920|  16.0k|    d->fnarg = false;
  921|       |
  922|       |    /* This flag should only be set when recursing through the LHS
  923|       |       of binary ops, so by default we reset to zero */
  924|  16.0k|    int prevLeft = d->left;
  925|  16.0k|    d->left = 0;
  926|       |
  927|  16.0k|    if (!d->active) return;
  ------------------
  |  Branch (927:9): [True: 24, False: 16.0k]
  ------------------
  928|       |
  929|  16.0k|    if (IS_S4_OBJECT(s)) {
  ------------------
  |  Branch (929:9): [True: 0, False: 16.0k]
  ------------------
  930|      0|	d->isS4 = true;
  ------------------
  |  |  964|      0|#define isS4			Rf_isS4
  ------------------
  931|       |	/* const void *vmax = vmaxget(); */
  932|      0|	SEXP class = getAttrib(s, R_ClassSymbol),
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  933|      0|	    cl_def = TYPEOF(class) == STRSXP ? STRING_ELT(class, 0) : R_NilValue;
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (933:15): [True: 0, False: 0]
  ------------------
  934|      0|	if(TYPEOF(cl_def) == CHARSXP) { // regular S4 objects
  ------------------
  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (934:5): [True: 0, False: 0]
  ------------------
  935|      0|	    print2buff("new(\"", d);
  936|      0|	    print2buff(translateChar(cl_def), d);
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  937|      0|	    print2buff("\", ", d);
  938|      0|	    SEXP slotNms; // ---- slotNms := methods::.slotNames(s)  ---------
  939|       |	    // computed alternatively, slotNms := names(getClassDef(class)@slots) :
  940|      0|	    static SEXP R_getClassDef = NULL, R_slots = NULL, R_asS3 = NULL;
  941|      0|	    if(R_getClassDef == NULL)
  ------------------
  |  Branch (941:9): [True: 0, False: 0]
  ------------------
  942|      0|		R_getClassDef = findFun(install("getClassDef"), R_MethodsNamespace);
  ------------------
  |  |  915|      0|#define findFun			Rf_findFun
  ------------------
              		R_getClassDef = findFun(install("getClassDef"), R_MethodsNamespace);
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
  943|      0|	    if(R_slots == NULL) R_slots = install("slots");
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
  |  Branch (943:9): [True: 0, False: 0]
  ------------------
  944|      0|	    if(R_asS3  == NULL) R_asS3  = install("asS3");
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
  |  Branch (944:9): [True: 0, False: 0]
  ------------------
  945|      0|	    SEXP e = PROTECT(lang2(R_getClassDef, class));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  946|      0|	    cl_def = PROTECT(eval(e, R_BaseEnv)); // correct env?
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  947|      0|	    slotNms = // names( cl_def@slots ) :
  948|      0|		getAttrib(R_do_slot(cl_def, R_slots), R_NamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  949|      0|	    UNPROTECT(2); // (e, cl_def)
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  950|      0|	    int n;
  951|      0|	    bool has_Data = false;// does it have ".Data" slot?
  952|      0|	    bool hasS4_t = TYPEOF(s) == OBJSXP;
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  953|      0|	    if(TYPEOF(slotNms) == STRSXP && (n = LENGTH(slotNms))) {
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (953:9): [True: 0, False: 0]
  |  Branch (953:38): [True: 0, False: 0]
  ------------------
  954|      0|		PROTECT(slotNms);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  955|      0|		SEXP slotlist = PROTECT(allocVector(VECSXP, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  956|       |		// := structure(lapply(slotNms, slot, object=s), names=slotNms)
  957|      0|		for(int i=0; i < n; i++) {
  ------------------
  |  Branch (957:16): [True: 0, False: 0]
  ------------------
  958|      0|		    SEXP slot_i = STRING_ELT(slotNms, i);
  959|      0|		    SET_VECTOR_ELT(slotlist, i, R_do_slot(s, installTrChar(slot_i)));
  ------------------
  |  |  937|      0|#define installTrChar		Rf_installTrChar
  ------------------
  960|      0|		    if(!hasS4_t && !has_Data)
  ------------------
  |  Branch (960:10): [True: 0, False: 0]
  |  Branch (960:22): [True: 0, False: 0]
  ------------------
  961|      0|			has_Data = (strcmp(CHAR(slot_i), ".Data") == 0);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  962|      0|		}
  963|      0|		setAttrib(slotlist, R_NamesSymbol, slotNms);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  964|      0|		vec2buff(slotlist, d, true);
  965|       |		/*-----------------*/
  966|      0|		UNPROTECT(2); // (slotNms, slotlist)
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  967|      0|	    }
  968|      0|	    if(!hasS4_t && !has_Data) {
  ------------------
  |  Branch (968:9): [True: 0, False: 0]
  |  Branch (968:21): [True: 0, False: 0]
  ------------------
  969|       |		// may have *non*-slot contents, (i.e., not in .Data)
  970|       |		// ==> additionally deparse asS3(s) :
  971|      0|		e = PROTECT(lang2(R_asS3, s)); // = asS3(s)
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  972|      0|		SEXP S3_s = PROTECT(eval(e, R_BaseEnv)); // correct env?
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  973|      0|		print2buff(", ", d);
  974|      0|		deparse2buff(S3_s, d);
  975|      0|		UNPROTECT(2); // (e, S3_s)
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  976|      0|	    }
  977|      0|	    print2buff(")", d);
  978|      0|	}
  979|      0|	else { // exception: class is not CHARSXP
  980|      0|	    if(isNull(cl_def) && isNull(ATTRIB(s))) // special
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
              	    if(isNull(cl_def) && isNull(ATTRIB(s))) // special
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (980:9): [True: 0, False: 0]
  |  Branch (980:27): [True: 0, False: 0]
  ------------------
  981|      0|		print2buff("getClass(\"S4\")@prototype", d);
  982|      0|	    else { // irregular S4 ((does this ever trigger ??))
  983|      0|		d->sourceable = false;
  984|      0|		print2buff("<S4 object of class ", d);
  985|      0|		deparse2buff(class, d);
  986|      0|		print2buff(">", d);
  987|      0|	    }
  988|      0|	}
  989|       |	/* vmaxset(vmax); */
  990|      0|	return;
  991|      0|    } // if( S4 )
  992|       |
  993|       |    // non-S4 cases:
  994|  16.0k|    switch (TYPEOF(s)) {
  995|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (995:5): [True: 0, False: 16.0k]
  ------------------
  996|      0|	print2buff("NULL", d);
  997|      0|	break;
  998|  4.33k|    case SYMSXP: {
  ------------------
  |  |  112|  4.33k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (998:5): [True: 4.33k, False: 11.7k]
  ------------------
  999|  4.33k|	bool
 1000|  4.33k|	    doquote = (d_opts_in & QUOTEEXPRESSIONS) && strlen(CHAR(PRINTNAME(s)));
  ------------------
  |  | 2069|  4.33k|#define QUOTEEXPRESSIONS 	2
  ------------------
              	    doquote = (d_opts_in & QUOTEEXPRESSIONS) && strlen(CHAR(PRINTNAME(s)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1000:16): [True: 0, False: 4.33k]
  |  Branch (1000:50): [True: 0, False: 0]
  ------------------
 1001|  4.33k|	if (doquote) {
  ------------------
  |  Branch (1001:6): [True: 0, False: 4.33k]
  ------------------
 1002|      0|	    attr = (d_opts_in & SHOW_ATTR_OR_NMS) ? attr1(s, d) : SIMPLE;
  ------------------
  |  |  911|      0|#define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2070|      0|#define SHOWATTRIBUTES 		4
  |  |  ------------------
  |  |               #define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2078|      0|#define NICE_NAMES             	1024
  |  |  ------------------
  ------------------
  |  Branch (1002:13): [True: 0, False: 0]
  ------------------
 1003|      0|	    print2buff("quote(", d);
 1004|      0|	}
 1005|  4.33k|	if (d_opts_in & S_COMPAT) {
  ------------------
  |  | 2075|  4.33k|#define S_COMPAT       		128
  ------------------
  |  Branch (1005:6): [True: 0, False: 4.33k]
  ------------------
 1006|      0|	    print2buff(quotify(PRINTNAME(s), '"'), d);
 1007|  4.33k|	} else if (d->backtick)
  ------------------
  |  Branch (1007:13): [True: 4.33k, False: 0]
  ------------------
 1008|  4.33k|	    print2buff(quotify(PRINTNAME(s), '`'), d);
 1009|      0|	else
 1010|      0|	    print2buff(CHAR(PRINTNAME(s)), d);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1011|  4.33k|	if (doquote) {
  ------------------
  |  Branch (1011:6): [True: 0, False: 4.33k]
  ------------------
 1012|      0|	    print2buff(")", d);
 1013|      0|	    if(attr >= STRUC_ATTR) attr2(s, d, (attr == STRUC_ATTR));
  ------------------
  |  Branch (1013:9): [True: 0, False: 0]
  ------------------
 1014|      0|	}
 1015|  4.33k|	break;
 1016|      0|    }
 1017|      0|    case CHARSXP:
  ------------------
  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (1017:5): [True: 0, False: 16.0k]
  ------------------
 1018|      0|    {
 1019|      0|	const void *vmax = vmaxget();
 1020|      0|	const char *ts = translateChar(s);
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
 1021|       |#ifdef longstring_WARN
 1022|       |	/* versions of R < 2.7.0 cannot parse strings longer than 8192 chars */
 1023|       |	if(strlen(ts) >= 8192) d->longstring = true;
 1024|       |#endif
 1025|      0|	print2buff(ts, d);
 1026|      0|	vmaxset(vmax);
 1027|      0|	break;
 1028|      0|    }
 1029|      0|    case SPECIALSXP:
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (1029:5): [True: 0, False: 16.0k]
  ------------------
 1030|      0|    case BUILTINSXP:
  ------------------
  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (1030:5): [True: 0, False: 16.0k]
  ------------------
 1031|      0|	print2buff(".Primitive(\"", d);
 1032|      0|	print2buff(PRIMNAME(s), d);
  ------------------
  |  | 1346|      0|#define PRIMNAME(x)	(R_FunTab[PRIMOFFSET(x)].name)
  ------------------
 1033|      0|	print2buff("\")", d);
 1034|      0|	break;
 1035|      0|    case PROMSXP:
  ------------------
  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (1035:5): [True: 0, False: 16.0k]
  ------------------
 1036|      0|	if(d->opts & DELAYPROMISES) {
  ------------------
  |  | 2073|      0|#define DELAYPROMISES 		32
  ------------------
  |  Branch (1036:5): [True: 0, False: 0]
  ------------------
 1037|      0|	    d->sourceable = false;
 1038|      0|	    print2buff("<promise: ", d);
 1039|      0|	    d->opts &= ~QUOTEEXPRESSIONS; /* don't want delay(quote()) */
  ------------------
  |  | 2069|      0|#define QUOTEEXPRESSIONS 	2
  ------------------
 1040|      0|	    deparse2buff(PREXPR(s), d);
  ------------------
  |  |  720|      0|#define PREXPR(e) R_PromiseExpr(e)
  ------------------
 1041|      0|	    d->opts = d_opts_in;
 1042|      0|	    print2buff(">", d);
 1043|      0|	} else {
 1044|      0|	    PROTECT(s = eval(s, R_EmptyEnv)); /* eval uses env of promise */
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1045|      0|	    deparse2buff(s, d);
 1046|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1047|      0|	}
 1048|      0|	break;
 1049|    128|    case CLOSXP:
  ------------------
  |  |  114|    128|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1049:5): [True: 128, False: 15.9k]
  ------------------
 1050|    128|	attr = (d_opts_in & SHOW_ATTR_OR_NMS) ? attr1(s, d) : SIMPLE;
  ------------------
  |  |  911|    128|#define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2070|    128|#define SHOWATTRIBUTES 		4
  |  |  ------------------
  |  |               #define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2078|    128|#define NICE_NAMES             	1024
  |  |  ------------------
  ------------------
  |  Branch (1050:9): [True: 128, False: 0]
  ------------------
 1051|    128|	if ((d->opts & USESOURCE)
  ------------------
  |  | 2071|    128|#define USESOURCE 		8
  ------------------
  |  Branch (1051:6): [True: 0, False: 128]
  ------------------
 1052|      0|	    && !isNull(t = getAttrib(s, R_SrcrefSymbol)))
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
              	    && !isNull(t = getAttrib(s, R_SrcrefSymbol)))
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (1052:9): [True: 0, False: 0]
  ------------------
 1053|      0|		src2buff1(t, d);
 1054|    128|	else {
 1055|       |	    /* We have established that we don't want to use the
 1056|       |	       source for this function */
 1057|    128|	    d->opts &= SIMPLE_OPTS & ~USESOURCE;
  ------------------
  |  |  908|    128|#define SIMPLE_OPTS (~QUOTEEXPRESSIONS & ~SHOWATTRIBUTES & ~DELAYPROMISES)
  |  |  ------------------
  |  |  |  | 2069|    128|#define QUOTEEXPRESSIONS 	2
  |  |  ------------------
  |  |               #define SIMPLE_OPTS (~QUOTEEXPRESSIONS & ~SHOWATTRIBUTES & ~DELAYPROMISES)
  |  |  ------------------
  |  |  |  | 2070|    128|#define SHOWATTRIBUTES 		4
  |  |  ------------------
  |  |               #define SIMPLE_OPTS (~QUOTEEXPRESSIONS & ~SHOWATTRIBUTES & ~DELAYPROMISES)
  |  |  ------------------
  |  |  |  | 2073|    128|#define DELAYPROMISES 		32
  |  |  ------------------
  ------------------
              	    d->opts &= SIMPLE_OPTS & ~USESOURCE;
  ------------------
  |  | 2071|    128|#define USESOURCE 		8
  ------------------
 1058|    128|	    print2buff("function (", d);
 1059|    128|	    args2buff(FORMALS(s), 0, 1, d);
 1060|    128|	    print2buff(") ", d);
 1061|       |
 1062|    128|	    writeline(d);
 1063|    128|	    deparse2buff(BODY_EXPR(s), d);
  ------------------
  |  | 1220|    128|#define BODY_EXPR(e) R_ClosureExpr(e)
  ------------------
 1064|    128|	    d->opts = d_opts_in;
 1065|    128|	}
 1066|    128|	if(attr >= STRUC_ATTR) attr2(s, d, (attr == STRUC_ATTR));
  ------------------
  |  Branch (1066:5): [True: 0, False: 128]
  ------------------
 1067|    128|	break;
 1068|      0|    case ENVSXP:
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (1068:5): [True: 0, False: 16.0k]
  ------------------
 1069|      0|	d->sourceable = false;
 1070|      0|	print2buff("<environment>", d);
 1071|      0|	break;
 1072|      0|    case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1072:5): [True: 0, False: 16.0k]
  ------------------
 1073|      0|	attr = (d_opts_in & SHOW_ATTR_OR_NMS) ? attr1(s, d) : SIMPLE;
  ------------------
  |  |  911|      0|#define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2070|      0|#define SHOWATTRIBUTES 		4
  |  |  ------------------
  |  |               #define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2078|      0|#define NICE_NAMES             	1024
  |  |  ------------------
  ------------------
  |  Branch (1073:9): [True: 0, False: 0]
  ------------------
 1074|      0|	print2buff("list(", d);
 1075|      0|	d->opts = d_opts_in;// vec2buff() must use unchanged d
 1076|      0|	vec2buff(s, d, attr == OK_NAMES || attr == STRUC_ATTR);
  ------------------
  |  Branch (1076:17): [True: 0, False: 0]
  |  Branch (1076:37): [True: 0, False: 0]
  ------------------
 1077|      0|	d->opts |= NICE_NAMES;
  ------------------
  |  | 2078|      0|#define NICE_NAMES             	1024
  ------------------
 1078|      0|	print2buff(")", d);
 1079|      0|	if(attr >= STRUC_ATTR) attr2(s, d, (attr == STRUC_ATTR));
  ------------------
  |  Branch (1079:5): [True: 0, False: 0]
  ------------------
 1080|      0|	d->opts = d_opts_in;
 1081|      0|	break;
 1082|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1082:5): [True: 0, False: 16.0k]
  ------------------
 1083|      0|	attr = (d_opts_in & SHOW_ATTR_OR_NMS) ? attr1(s, d) : SIMPLE;
  ------------------
  |  |  911|      0|#define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2070|      0|#define SHOWATTRIBUTES 		4
  |  |  ------------------
  |  |               #define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2078|      0|#define NICE_NAMES             	1024
  |  |  ------------------
  ------------------
  |  Branch (1083:9): [True: 0, False: 0]
  ------------------
 1084|      0|	if(length(s) <= 0)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1084:5): [True: 0, False: 0]
  ------------------
 1085|      0|	    print2buff("expression()", d);
 1086|      0|	else {
 1087|      0|	    int locOpts = d->opts;
 1088|      0|	    print2buff("expression(", d);
 1089|      0|	    d->opts &= SIMPLE_OPTS;
  ------------------
  |  |  908|      0|#define SIMPLE_OPTS (~QUOTEEXPRESSIONS & ~SHOWATTRIBUTES & ~DELAYPROMISES)
  |  |  ------------------
  |  |  |  | 2069|      0|#define QUOTEEXPRESSIONS 	2
  |  |  ------------------
  |  |               #define SIMPLE_OPTS (~QUOTEEXPRESSIONS & ~SHOWATTRIBUTES & ~DELAYPROMISES)
  |  |  ------------------
  |  |  |  | 2070|      0|#define SHOWATTRIBUTES 		4
  |  |  ------------------
  |  |               #define SIMPLE_OPTS (~QUOTEEXPRESSIONS & ~SHOWATTRIBUTES & ~DELAYPROMISES)
  |  |  ------------------
  |  |  |  | 2073|      0|#define DELAYPROMISES 		32
  |  |  ------------------
  ------------------
 1090|      0|	    vec2buff(s, d, attr == OK_NAMES || attr == STRUC_ATTR);
  ------------------
  |  Branch (1090:21): [True: 0, False: 0]
  |  Branch (1090:41): [True: 0, False: 0]
  ------------------
 1091|      0|	    d->opts = locOpts;
 1092|      0|	    print2buff(")", d);
 1093|      0|	}
 1094|      0|	if(attr >= STRUC_ATTR) attr2(s, d, (attr == STRUC_ATTR));
  ------------------
  |  Branch (1094:5): [True: 0, False: 0]
  ------------------
 1095|      0|	d->opts = d_opts_in;
 1096|      0|	break;
 1097|      0|    case LISTSXP: {
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1097:5): [True: 0, False: 16.0k]
  ------------------
 1098|      0|	attr = (d_opts_in & SHOW_ATTR_OR_NMS) ? attr1(s, d) : SIMPLE;
  ------------------
  |  |  911|      0|#define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2070|      0|#define SHOWATTRIBUTES 		4
  |  |  ------------------
  |  |               #define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2078|      0|#define NICE_NAMES             	1024
  |  |  ------------------
  ------------------
  |  Branch (1098:9): [True: 0, False: 0]
  ------------------
 1099|       |	/* pairlist(x=) cannot be evaluated, hence with missings we use
 1100|       |	   as.pairlist(alist(...)) to allow evaluation of deparsed formals */
 1101|      0|	bool missing = false;
 1102|      0|	for(t=s; t != R_NilValue; t=CDR(t))
  ------------------
  |  Branch (1102:11): [True: 0, False: 0]
  ------------------
 1103|      0|	    if (CAR(t) == R_MissingArg) {
  ------------------
  |  Branch (1103:10): [True: 0, False: 0]
  ------------------
 1104|      0|		missing = true;
 1105|      0|		break;
 1106|      0|	    }
 1107|      0|	if (missing)
  ------------------
  |  Branch (1107:6): [True: 0, False: 0]
  ------------------
 1108|      0|	    print2buff("as.pairlist(alist(", d);
 1109|      0|	else
 1110|      0|	    print2buff("pairlist(", d);
 1111|      0|	d->inlist++;
 1112|      0|	for (t=s ; CDR(t) != R_NilValue ; t=CDR(t) ) {
  ------------------
  |  Branch (1112:13): [True: 0, False: 0]
  ------------------
 1113|      0|	    if( TAG(t) != R_NilValue ) {
  ------------------
  |  Branch (1113:10): [True: 0, False: 0]
  ------------------
 1114|      0|		d->opts = SIMPLEDEPARSE; /* turn off quote()ing */
  ------------------
  |  | 2080|      0|#define SIMPLEDEPARSE		0
  ------------------
 1115|      0|		deparse2buff(TAG(t), d);
 1116|      0|		d->opts = d_opts_in;
 1117|      0|		print2buff(" = ", d);
 1118|      0|	    }
 1119|      0|	    deparse2buff(CAR(t), d);
 1120|      0|	    print2buff(", ", d);
 1121|      0|	}
 1122|      0|	if( TAG(t) != R_NilValue ) {
  ------------------
  |  Branch (1122:6): [True: 0, False: 0]
  ------------------
 1123|      0|	    d->opts = SIMPLEDEPARSE; /* turn off quote()ing */
  ------------------
  |  | 2080|      0|#define SIMPLEDEPARSE		0
  ------------------
 1124|      0|	    deparse2buff(TAG(t), d);
 1125|      0|	    d->opts = d_opts_in;
 1126|      0|	    print2buff(" = ", d);
 1127|      0|	}
 1128|      0|	deparse2buff(CAR(t), d);
 1129|      0|	if (missing)
  ------------------
  |  Branch (1129:6): [True: 0, False: 0]
  ------------------
 1130|      0|	    print2buff("))", d);
 1131|      0|	else
 1132|      0|	    print2buff(")", d);
 1133|      0|	d->inlist--;
 1134|      0|	if(attr >= STRUC_ATTR) attr2(s, d, (attr == STRUC_ATTR));
  ------------------
  |  Branch (1134:5): [True: 0, False: 0]
  ------------------
 1135|      0|	break;
 1136|      0|    }
 1137|  7.05k|    case LANGSXP:
  ------------------
  |  |  117|  7.05k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (1137:5): [True: 7.05k, False: 9.01k]
  ------------------
 1138|  7.05k|	if (!isNull(ATTRIB(s)))
  ------------------
  |  |  956|  7.05k|#define isNull			Rf_isNull
  ------------------
  |  Branch (1138:6): [True: 0, False: 7.05k]
  ------------------
 1139|      0|	    d->sourceable = false;
 1140|  7.05k|	SEXP op = CAR(s);
 1141|  7.05k|	bool doquote = false;
 1142|  7.05k|	bool maybe_quote = d_opts_in & QUOTEEXPRESSIONS;
  ------------------
  |  | 2069|  7.05k|#define QUOTEEXPRESSIONS 	2
  ------------------
 1143|  7.05k|	if (maybe_quote) {
  ------------------
  |  Branch (1143:6): [True: 0, False: 7.05k]
  ------------------
 1144|       |	    // do *not* quote() formulas:
 1145|      0|	    doquote = // := op is not `~` (tilde) :
 1146|      0|		!((TYPEOF(op) == SYMSXP) &&
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1146:5): [True: 0, False: 0]
  ------------------
 1147|      0|		  !strcmp(CHAR(PRINTNAME(op)), "~"));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1147:5): [True: 0, False: 0]
  ------------------
 1148|      0|	    if (doquote) {
  ------------------
  |  Branch (1148:10): [True: 0, False: 0]
  ------------------
 1149|      0|		print2buff("quote(", d);
 1150|      0|		d->opts &= SIMPLE_OPTS;
  ------------------
  |  |  908|      0|#define SIMPLE_OPTS (~QUOTEEXPRESSIONS & ~SHOWATTRIBUTES & ~DELAYPROMISES)
  |  |  ------------------
  |  |  |  | 2069|      0|#define QUOTEEXPRESSIONS 	2
  |  |  ------------------
  |  |               #define SIMPLE_OPTS (~QUOTEEXPRESSIONS & ~SHOWATTRIBUTES & ~DELAYPROMISES)
  |  |  ------------------
  |  |  |  | 2070|      0|#define SHOWATTRIBUTES 		4
  |  |  ------------------
  |  |               #define SIMPLE_OPTS (~QUOTEEXPRESSIONS & ~SHOWATTRIBUTES & ~DELAYPROMISES)
  |  |  ------------------
  |  |  |  | 2073|      0|#define DELAYPROMISES 		32
  |  |  ------------------
  ------------------
 1151|      0|	    } else { // `~`
 1152|      0|		d->opts &= ~QUOTEEXPRESSIONS;
  ------------------
  |  | 2069|      0|#define QUOTEEXPRESSIONS 	2
  ------------------
 1153|      0|	    }
 1154|      0|	}
 1155|       |
 1156|  7.05k|	if (TYPEOF(op) == SYMSXP) {
  ------------------
  |  |  112|  7.05k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1156:6): [True: 6.97k, False: 80]
  ------------------
 1157|  6.97k|	    int userbinop = 0;
 1158|  6.97k|	    if ((TYPEOF(SYMVALUE(op)) == BUILTINSXP) ||
  ------------------
  |  |  119|  6.97k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (1158:10): [True: 3.11k, False: 3.86k]
  ------------------
 1159|  3.86k|		(TYPEOF(SYMVALUE(op)) == SPECIALSXP) ||
  ------------------
  |  |  118|  3.86k|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (1159:3): [True: 596, False: 3.27k]
  ------------------
 1160|  3.70k|		(userbinop = isUserBinop(op))) {
  ------------------
  |  |  971|  3.27k|#define isUserBinop		Rf_isUserBinop
  ------------------
  |  Branch (1160:3): [True: 0, False: 3.27k]
  ------------------
 1161|  3.70k|		PPinfo fop;
 1162|  3.70k|		bool parens;
 1163|  3.70k|		s = CDR(s);
 1164|  3.70k|		if (userbinop) {
  ------------------
  |  Branch (1164:7): [True: 0, False: 3.70k]
  ------------------
 1165|      0|		    if (isNull(getAttrib(s, R_NamesSymbol))) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
              		    if (isNull(getAttrib(s, R_NamesSymbol))) {
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (1165:11): [True: 0, False: 0]
  ------------------
 1166|       |			// not quite right for spacing, but can't be unary :
 1167|      0|			fop.kind = PP_BINARY2;
 1168|      0|			fop.precedence = PREC_PERCENT;
 1169|      0|			fop.rightassoc = 0;
 1170|      0|		    } else
 1171|       |			// if args are named, deparse as function call (PR#15350):
 1172|      0|			fop.kind = PP_FUNCALL;
 1173|      0|		} else
 1174|  3.70k|		    fop = PPINFO(SYMVALUE(op));
  ------------------
  |  | 1349|  3.70k|#define PPINFO(x)	(R_FunTab[PRIMOFFSET(x)].gram)
  ------------------
 1175|       |
 1176|  3.70k|		switch (fop.kind) {
 1177|    240|		case PP_BINARY:
  ------------------
  |  Branch (1177:3): [True: 240, False: 3.46k]
  ------------------
 1178|    240|		    switch (length(s)) {
  ------------------
  |  |  987|    240|#define length(x)		Rf_length(x)
  ------------------
 1179|      8|		    case 1:
  ------------------
  |  Branch (1179:7): [True: 8, False: 232]
  ------------------
 1180|      8|			fop.kind = PP_UNARY;
 1181|      8|			if (fop.precedence == PREC_SUM)
  ------------------
  |  Branch (1181:8): [True: 8, False: 0]
  ------------------
 1182|       |			    // binary +/- precedence upgraded as unary
 1183|      8|			    fop.precedence = PREC_SIGN;
 1184|      8|			break;
 1185|    232|		    case 2:
  ------------------
  |  Branch (1185:7): [True: 232, False: 8]
  ------------------
 1186|    232|			break;
 1187|      0|		    default:
  ------------------
  |  Branch (1187:7): [True: 0, False: 240]
  ------------------
 1188|      0|			fop.kind = PP_FUNCALL;
 1189|      0|			break;
 1190|    240|		    }
 1191|    240|		    break;
 1192|  2.26k|		case PP_BINARY2:
  ------------------
  |  Branch (1192:3): [True: 2.26k, False: 1.43k]
  ------------------
 1193|  2.26k|		    if (length(s) != 2)
  ------------------
  |  |  987|  2.26k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1193:11): [True: 0, False: 2.26k]
  ------------------
 1194|      0|			fop.kind = PP_FUNCALL;
 1195|  2.26k|		    else if (userbinop)
  ------------------
  |  Branch (1195:16): [True: 0, False: 2.26k]
  ------------------
 1196|      0|			fop.kind = PP_BINARY;
 1197|  2.26k|		    break;
 1198|      0|		case PP_DOLLAR: {
  ------------------
  |  Branch (1198:3): [True: 0, False: 3.70k]
  ------------------
 1199|      0|		    if (length(s) != 2) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1199:11): [True: 0, False: 0]
  ------------------
 1200|      0|			fop.kind = PP_FUNCALL;
 1201|      0|			break;
 1202|      0|		    }
 1203|      0|		    SEXP rhs = CADR(s);
 1204|      0|		    if (TYPEOF(rhs) != SYMSXP && !(isValidString(rhs)
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
              		    if (TYPEOF(rhs) != SYMSXP && !(isValidString(rhs)
  ------------------
  |  |  972|      0|#define isValidString		Rf_isValidString
  ------------------
  |  Branch (1204:11): [True: 0, False: 0]
  |  Branch (1204:38): [True: 0, False: 0]
  ------------------
 1205|      0|						   && STRING_ELT(rhs, 0) != NA_STRING))
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1205:13): [True: 0, False: 0]
  ------------------
 1206|      0|			fop.kind = PP_FUNCALL;
 1207|      0|		    break;
 1208|      0|		}
 1209|  1.19k|		default:
  ------------------
  |  Branch (1209:3): [True: 1.19k, False: 2.50k]
  ------------------
 1210|  1.19k|		    break;
 1211|  3.70k|		}
 1212|  3.70k|		switch (fop.kind) {
 1213|      0|		case PP_IF:
  ------------------
  |  Branch (1213:3): [True: 0, False: 3.70k]
  ------------------
 1214|      0|		    print2buff("if (", d);
 1215|       |		    /* print the predicate */
 1216|      0|		    deparse2buff(CAR(s), d);
 1217|      0|		    print2buff(") ", d);
 1218|      0|		    if (d->incurly && !d->inlist ) {
  ------------------
  |  Branch (1218:11): [True: 0, False: 0]
  |  Branch (1218:25): [True: 0, False: 0]
  ------------------
 1219|      0|			lookahead = curlyahead(CADR(s));
 1220|      0|			if (!lookahead) {
  ------------------
  |  Branch (1220:8): [True: 0, False: 0]
  ------------------
 1221|      0|			    writeline(d);
 1222|      0|			    d->indent++;
 1223|      0|			}
 1224|      0|		    }
 1225|       |		    /* need to find out if there is an else */
 1226|      0|		    if (length(s) > 2) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1226:11): [True: 0, False: 0]
  ------------------
 1227|      0|			deparse2buff(CADR(s), d);
 1228|      0|			if (d->incurly && !d->inlist) {
  ------------------
  |  Branch (1228:8): [True: 0, False: 0]
  |  Branch (1228:22): [True: 0, False: 0]
  ------------------
 1229|      0|			    writeline(d);
 1230|      0|			    if (!lookahead)
  ------------------
  |  Branch (1230:12): [True: 0, False: 0]
  ------------------
 1231|      0|				d->indent--;
 1232|      0|			}
 1233|      0|			else
 1234|      0|			    print2buff(" ", d);
 1235|      0|			print2buff("else ", d);
 1236|      0|			deparse2buff(CADDR(s), d);
 1237|      0|		    }
 1238|      0|		    else {
 1239|      0|			deparse2buff(CADR(s), d);
 1240|      0|			if (d->incurly && !lookahead && !d->inlist )
  ------------------
  |  Branch (1240:8): [True: 0, False: 0]
  |  Branch (1240:22): [True: 0, False: 0]
  |  Branch (1240:36): [True: 0, False: 0]
  ------------------
 1241|      0|			    d->indent--;
 1242|      0|		    }
 1243|      0|		    break;
 1244|      0|		case PP_WHILE:
  ------------------
  |  Branch (1244:3): [True: 0, False: 3.70k]
  ------------------
 1245|      0|		    print2buff("while (", d);
 1246|      0|		    deparse2buff(CAR(s), d);
 1247|      0|		    print2buff(") ", d);
 1248|      0|		    deparse2buff(CADR(s), d);
 1249|      0|		    break;
 1250|      0|		case PP_FOR:
  ------------------
  |  Branch (1250:3): [True: 0, False: 3.70k]
  ------------------
 1251|      0|		    print2buff("for (", d);
 1252|      0|		    deparse2buff(CAR(s), d);
 1253|      0|		    print2buff(" in ", d);
 1254|      0|		    deparse2buff(CADR(s), d);
 1255|      0|		    print2buff(") ", d);
 1256|      0|		    deparse2buff(CADDR(s), d);
 1257|      0|		    break;
 1258|      0|		case PP_REPEAT:
  ------------------
  |  Branch (1258:3): [True: 0, False: 3.70k]
  ------------------
 1259|      0|		    print2buff("repeat ", d);
 1260|      0|		    deparse2buff(CAR(s), d);
 1261|      0|		    break;
 1262|    128|		case PP_CURLY:
  ------------------
  |  Branch (1262:3): [True: 128, False: 3.57k]
  ------------------
 1263|    128|		    print2buff("{", d);
 1264|    128|		    d->incurly += 1;
 1265|    128|		    d->indent++;
 1266|    128|		    writeline(d);
 1267|    552|		    while (s != R_NilValue) {
  ------------------
  |  Branch (1267:14): [True: 424, False: 128]
  ------------------
 1268|    424|			deparse2buff(CAR(s), d);
 1269|    424|			writeline(d);
 1270|    424|			s = CDR(s);
 1271|    424|		    }
 1272|    128|		    d->indent--;
 1273|    128|		    print2buff("}", d);
 1274|    128|		    d->incurly -= 1;
 1275|    128|		    break;
 1276|    227|		case PP_PAREN:
  ------------------
  |  Branch (1276:3): [True: 227, False: 3.47k]
  ------------------
 1277|    227|		    print2buff("(", d);
 1278|    227|		    deparse2buff(CAR(s), d);
 1279|    227|		    print2buff(")", d);
 1280|    227|		    break;
 1281|    188|		case PP_SUBSET:
  ------------------
  |  Branch (1281:3): [True: 188, False: 3.51k]
  ------------------
 1282|    188|		    if ((parens = needsparens(fop, CAR(s), 1, prevLeft)))
  ------------------
  |  Branch (1282:11): [True: 0, False: 188]
  ------------------
 1283|      0|			print2buff("(", d);
 1284|    188|		    deparse2buff(CAR(s), d);
 1285|    188|		    if (parens)
  ------------------
  |  Branch (1285:11): [True: 0, False: 188]
  ------------------
 1286|      0|			print2buff(")", d);
 1287|    188|		    if (PRIMVAL(SYMVALUE(op)) == 1)
  ------------------
  |  | 1347|    188|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1287:11): [True: 76, False: 112]
  ------------------
 1288|     76|			print2buff("[", d);
 1289|    112|		    else
 1290|    112|			print2buff("[[", d);
 1291|    188|		    args2buff(CDR(s), 0, 0, d);
 1292|    188|		    if (PRIMVAL(SYMVALUE(op)) == 1)
  ------------------
  |  | 1347|    188|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1292:11): [True: 76, False: 112]
  ------------------
 1293|     76|			print2buff("]", d);
 1294|    112|		    else
 1295|    112|			print2buff("]]", d);
 1296|    188|		    break;
 1297|    392|		case PP_FUNCALL:
  ------------------
  |  Branch (1297:3): [True: 392, False: 3.31k]
  ------------------
 1298|    392|		case PP_RETURN:
  ------------------
  |  Branch (1298:3): [True: 0, False: 3.70k]
  ------------------
 1299|    392|		    if (d->backtick)
  ------------------
  |  Branch (1299:11): [True: 392, False: 0]
  ------------------
 1300|    392|			print2buff(quotify(PRINTNAME(op), '`'), d);
 1301|      0|		    else
 1302|      0|			print2buff(quotify(PRINTNAME(op), '"'), d);
 1303|    392|		    print2buff("(", d);
 1304|    392|		    d->inlist++;
 1305|    392|		    args2buff(s, 0, 0, d);
 1306|    392|		    d->inlist--;
 1307|    392|		    print2buff(")", d);
 1308|    392|		    break;
 1309|      0|		case PP_FOREIGN:
  ------------------
  |  Branch (1309:3): [True: 0, False: 3.70k]
  ------------------
 1310|      0|		    print2buff(CHAR(PRINTNAME(op)), d); /* ASCII */
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1311|      0|		    print2buff("(", d);
 1312|      0|		    d->inlist++;
 1313|      0|		    args2buff(s, 1, 0, d);
 1314|      0|		    d->inlist--;
 1315|      0|		    print2buff(")", d);
 1316|      0|		    break;
 1317|      0|		case PP_FUNCTION:
  ------------------
  |  Branch (1317:3): [True: 0, False: 3.70k]
  ------------------
 1318|      0|		    if (!(d->opts & USESOURCE) || !isString(CADDR(s))) {
  ------------------
  |  | 2071|      0|#define USESOURCE 		8
  ------------------
              		    if (!(d->opts & USESOURCE) || !isString(CADDR(s))) {
  ------------------
  |  |  966|      0|#define isString		Rf_isString
  ------------------
  |  Branch (1318:11): [True: 0, False: 0]
  |  Branch (1318:37): [True: 0, False: 0]
  ------------------
 1319|      0|			print2buff(CHAR(PRINTNAME(op)), d); /* ASCII */
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1320|      0|			print2buff("(", d);
 1321|      0|			args2buff(FORMALS(s), 0, 1, d);
 1322|      0|			print2buff(") ", d);
 1323|      0|			deparse2buff(CADR(s), d);
 1324|      0|		    } else {
 1325|      0|			s = CADDR(s);
 1326|      0|			n = length(s);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 1327|      0|			const void *vmax = vmaxget();
 1328|      0|			for(i = 0 ; i < n ; i++) {
  ------------------
  |  Branch (1328:16): [True: 0, False: 0]
  ------------------
 1329|      0|			    print2buff(translateChar(STRING_ELT(s, i)), d);
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
 1330|      0|			    writeline(d);
 1331|      0|			}
 1332|      0|			vmaxset(vmax);
 1333|      0|		    }
 1334|      0|		    break;
 1335|    264|		case PP_ASSIGN:
  ------------------
  |  Branch (1335:3): [True: 264, False: 3.44k]
  ------------------
 1336|    264|		case PP_ASSIGN2: {
  ------------------
  |  Branch (1336:3): [True: 0, False: 3.70k]
  ------------------
 1337|    264|		    bool outerparens = fnarg && !strcmp(CHAR(PRINTNAME(op)), "=");
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1337:26): [True: 0, False: 264]
  |  Branch (1337:35): [True: 0, False: 0]
  ------------------
 1338|    264|		    if (outerparens)
  ------------------
  |  Branch (1338:11): [True: 0, False: 264]
  ------------------
 1339|      0|		    	print2buff("(", d);
 1340|    264|		    if ((parens = needsparens(fop, CAR(s), 1, prevLeft)))
  ------------------
  |  Branch (1340:11): [True: 0, False: 264]
  ------------------
 1341|      0|			print2buff("(", d);
 1342|    264|		    d->left = parens ? 0 : fop.precedence;
  ------------------
  |  Branch (1342:17): [True: 0, False: 264]
  ------------------
 1343|    264|		    deparse2buff(CAR(s), d);
 1344|    264|		    if (parens)
  ------------------
  |  Branch (1344:11): [True: 0, False: 264]
  ------------------
 1345|      0|			print2buff(")", d);
 1346|    264|		    print2buff(" ", d);
 1347|    264|		    print2buff(CHAR(PRINTNAME(op)), d); /* ASCII */
  ------------------
  |  |  203|    264|#define CHAR(x) R_CHAR(x)
  ------------------
 1348|    264|		    print2buff(" ", d);
 1349|    264|		    if ((parens = needsparens(fop, CADR(s), 0, prevLeft)))
  ------------------
  |  Branch (1349:11): [True: 0, False: 264]
  ------------------
 1350|      0|			print2buff("(", d);
 1351|    264|		    d->left = parens ? 0 : prevLeft;
  ------------------
  |  Branch (1351:17): [True: 0, False: 264]
  ------------------
 1352|    264|		    deparse2buff(CADR(s), d);
 1353|    264|		    if (parens)
  ------------------
  |  Branch (1353:11): [True: 0, False: 264]
  ------------------
 1354|      0|			print2buff(")", d);
 1355|    264|		    if (outerparens)
  ------------------
  |  Branch (1355:11): [True: 0, False: 264]
  ------------------
 1356|      0|		    	print2buff(")", d);
 1357|    264|		    d->left = 0;
 1358|    264|		    break;
 1359|    264|		}
 1360|      0|		case PP_DOLLAR:
  ------------------
  |  Branch (1360:3): [True: 0, False: 3.70k]
  ------------------
 1361|      0|		    if ((parens = needsparens(fop, CAR(s), 1, prevLeft)))
  ------------------
  |  Branch (1361:11): [True: 0, False: 0]
  ------------------
 1362|      0|			print2buff("(", d);
 1363|      0|		    d->left = parens ? 0 : fop.precedence;
  ------------------
  |  Branch (1363:17): [True: 0, False: 0]
  ------------------
 1364|      0|		    deparse2buff(CAR(s), d);
 1365|      0|		    if (parens)
  ------------------
  |  Branch (1365:11): [True: 0, False: 0]
  ------------------
 1366|      0|			print2buff(")", d);
 1367|      0|		    print2buff(CHAR(PRINTNAME(op)), d); /* ASCII */
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1368|       |		    /*temp fix to handle printing of x$a's */
 1369|      0|		    if( isString(CADR(s)) &&
  ------------------
  |  |  966|      0|#define isString		Rf_isString
  ------------------
  |  Branch (1369:11): [True: 0, False: 0]
  ------------------
 1370|      0|			isValidName(CHAR(STRING_ELT(CADR(s), 0))))
  ------------------
  |  | 1930|      0|# define isValidName		Rf_isValidName
  ------------------
              			isValidName(CHAR(STRING_ELT(CADR(s), 0))))
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1370:4): [True: 0, False: 0]
  ------------------
 1371|      0|			deparse2buff(STRING_ELT(CADR(s), 0), d);
 1372|      0|		    else {
 1373|      0|			if ((parens = needsparens(fop, CADR(s), 0, prevLeft)))
  ------------------
  |  Branch (1373:8): [True: 0, False: 0]
  ------------------
 1374|      0|			    print2buff("(", d);
 1375|      0|			d->left = parens ? 0 : prevLeft;
  ------------------
  |  Branch (1375:14): [True: 0, False: 0]
  ------------------
 1376|      0|			deparse2buff(CADR(s), d);
 1377|      0|			if (parens)
  ------------------
  |  Branch (1377:8): [True: 0, False: 0]
  ------------------
 1378|      0|			    print2buff(")", d);
 1379|      0|		    }
 1380|      0|		    d->left = 0;
 1381|      0|		    break;
 1382|    232|		case PP_BINARY:
  ------------------
  |  Branch (1382:3): [True: 232, False: 3.47k]
  ------------------
 1383|    232|		    if ((parens = needsparens(fop, CAR(s), 1, prevLeft)))
  ------------------
  |  Branch (1383:11): [True: 0, False: 232]
  ------------------
 1384|      0|			print2buff("(", d);
 1385|    232|		    d->left = parens ? 0 : fop.precedence;
  ------------------
  |  Branch (1385:17): [True: 0, False: 232]
  ------------------
 1386|    232|		    deparse2buff(CAR(s), d);
 1387|    232|		    if (parens)
  ------------------
  |  Branch (1387:11): [True: 0, False: 232]
  ------------------
 1388|      0|			print2buff(")", d);
 1389|    232|		    print2buff(" ", d);
 1390|    232|		    print2buff(CHAR(PRINTNAME(op)), d); /* ASCII */
  ------------------
  |  |  203|    232|#define CHAR(x) R_CHAR(x)
  ------------------
 1391|    232|		    print2buff(" ", d);
 1392|    232|		    linebreak(&lbreak, d);
 1393|       |
 1394|    232|		    if ((parens = needsparens(fop, CADR(s), 0, prevLeft)))
  ------------------
  |  Branch (1394:11): [True: 0, False: 232]
  ------------------
 1395|      0|			print2buff("(", d);
 1396|    232|		    d->left = parens ? 0 : prevLeft;
  ------------------
  |  Branch (1396:17): [True: 0, False: 232]
  ------------------
 1397|    232|		    deparse2buff(CADR(s), d);
 1398|    232|		    if (parens)
  ------------------
  |  Branch (1398:11): [True: 0, False: 232]
  ------------------
 1399|      0|			print2buff(")", d);
 1400|    232|		    if (lbreak) {
  ------------------
  |  Branch (1400:11): [True: 0, False: 232]
  ------------------
 1401|      0|			d->indent--;
 1402|      0|			lbreak = false;
 1403|      0|		    }
 1404|    232|		    d->left = 0;
 1405|    232|		    break;
 1406|  2.26k|		case PP_BINARY2:	/* no space between op and args */
  ------------------
  |  Branch (1406:3): [True: 2.26k, False: 1.43k]
  ------------------
 1407|  2.26k|		    if ((parens = needsparens(fop, CAR(s), 1, prevLeft)))
  ------------------
  |  Branch (1407:11): [True: 0, False: 2.26k]
  ------------------
 1408|      0|			print2buff("(", d);
 1409|  2.26k|		    d->left = parens ? 0 : fop.precedence;
  ------------------
  |  Branch (1409:17): [True: 0, False: 2.26k]
  ------------------
 1410|  2.26k|		    deparse2buff(CAR(s), d);
 1411|  2.26k|		    if (parens)
  ------------------
  |  Branch (1411:11): [True: 0, False: 2.26k]
  ------------------
 1412|      0|			print2buff(")", d);
 1413|       |
 1414|  2.26k|		    print2buff(CHAR(PRINTNAME(op)), d); /* ASCII */
  ------------------
  |  |  203|  2.26k|#define CHAR(x) R_CHAR(x)
  ------------------
 1415|  2.26k|		    if ((parens = needsparens(fop, CADR(s), 0, prevLeft)))
  ------------------
  |  Branch (1415:11): [True: 0, False: 2.26k]
  ------------------
 1416|      0|			print2buff("(", d);
 1417|  2.26k|		    d->left = parens ? 0 : prevLeft;
  ------------------
  |  Branch (1417:17): [True: 0, False: 2.26k]
  ------------------
 1418|  2.26k|		    deparse2buff(CADR(s), d);
 1419|  2.26k|		    if (parens)
  ------------------
  |  Branch (1419:11): [True: 0, False: 2.26k]
  ------------------
 1420|      0|			print2buff(")", d);
 1421|  2.26k|		    d->left = 0;
 1422|  2.26k|		    break;
 1423|      8|		case PP_UNARY:
  ------------------
  |  Branch (1423:3): [True: 8, False: 3.69k]
  ------------------
 1424|      8|		    print2buff(CHAR(PRINTNAME(op)), d); /* ASCII */
  ------------------
  |  |  203|      8|#define CHAR(x) R_CHAR(x)
  ------------------
 1425|      8|		    if ((parens = needsparens(fop, CAR(s), 0, prevLeft)))
  ------------------
  |  Branch (1425:11): [True: 0, False: 8]
  ------------------
 1426|      0|			print2buff("(", d);
 1427|      8|		    d->left = parens ? 0 : prevLeft;
  ------------------
  |  Branch (1427:17): [True: 0, False: 8]
  ------------------
 1428|      8|		    deparse2buff(CAR(s), d);
 1429|      8|		    if (parens)
  ------------------
  |  Branch (1429:11): [True: 0, False: 8]
  ------------------
 1430|      0|			print2buff(")", d);
 1431|      8|		    d->left = 0;
 1432|      8|		    break;
 1433|      0|		case PP_BREAK:
  ------------------
  |  Branch (1433:3): [True: 0, False: 3.70k]
  ------------------
 1434|      0|		    print2buff("break", d);
 1435|      0|		    break;
 1436|      0|		case PP_NEXT:
  ------------------
  |  Branch (1436:3): [True: 0, False: 3.70k]
  ------------------
 1437|      0|		    print2buff("next", d);
 1438|      0|		    break;
 1439|      0|		case PP_SUBASS:
  ------------------
  |  Branch (1439:3): [True: 0, False: 3.70k]
  ------------------
 1440|      0|		    if(d->opts & S_COMPAT) {
  ------------------
  |  | 2075|      0|#define S_COMPAT       		128
  ------------------
  |  Branch (1440:10): [True: 0, False: 0]
  ------------------
 1441|      0|			print2buff("\"", d);
 1442|      0|			print2buff(CHAR(PRINTNAME(op)), d); /* ASCII */
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1443|      0|			print2buff("\'(", d);
 1444|      0|		    } else {
 1445|      0|			print2buff("`", d);
 1446|      0|			print2buff(CHAR(PRINTNAME(op)), d); /* ASCII */
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1447|      0|			print2buff("`(", d);
 1448|      0|		    }
 1449|      0|		    args2buff(s, 0, 0, d);
 1450|      0|		    print2buff(")", d);
 1451|      0|		    break;
 1452|      0|		default:
  ------------------
  |  Branch (1452:3): [True: 0, False: 3.70k]
  ------------------
 1453|      0|		    d->sourceable = false;
 1454|      0|		    UNIMPLEMENTED("deparse2buff");
 1455|  3.70k|		}
 1456|  3.70k|	    }
 1457|  3.27k|	    else {
 1458|  3.27k|		SEXP val = R_NilValue; /* -Wall */
 1459|  3.27k|		if (isSymbol(CAR(s))) {
  ------------------
  |  |  953|  3.27k|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1459:7): [True: 3.27k, False: 0]
  ------------------
 1460|  3.27k|		    val = SYMVALUE(CAR(s));
 1461|  3.27k|		    if (TYPEOF(val) == PROMSXP)
  ------------------
  |  |  116|  3.27k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (1461:11): [True: 1.00k, False: 2.26k]
  ------------------
 1462|  1.00k|			val = eval(val, R_BaseEnv);
  ------------------
  |  |  913|  1.00k|#define eval			Rf_eval
  ------------------
 1463|  3.27k|		}
 1464|  3.27k|		if ( isSymbol(CAR(s))
  ------------------
  |  |  953|  3.27k|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1464:8): [True: 3.27k, False: 0]
  ------------------
 1465|  3.27k|		  && TYPEOF(val) == CLOSXP
  ------------------
  |  |  114|  6.54k|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1465:8): [True: 1.00k, False: 2.26k]
  ------------------
 1466|  1.00k|		  && streql(CHAR(PRINTNAME(CAR(s))), "::") ) { //  :: is special case
  ------------------
  |  | 1498|  1.00k|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 1.00k]
  |  |  ------------------
  ------------------
 1467|      0|		    deparse2buff(CADR(s), d);
 1468|      0|		    print2buff("::", d);
 1469|      0|		    deparse2buff(CADDR(s), d);
 1470|      0|		}
 1471|  3.27k|		else if ( isSymbol(CAR(s))
  ------------------
  |  |  953|  3.27k|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1471:13): [True: 3.27k, False: 0]
  ------------------
 1472|  3.27k|		  && TYPEOF(val) == CLOSXP
  ------------------
  |  |  114|  6.54k|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1472:8): [True: 1.00k, False: 2.26k]
  ------------------
 1473|  1.00k|		  && streql(CHAR(PRINTNAME(CAR(s))), ":::") ) { // ::: is special case
  ------------------
  |  | 1498|  1.00k|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 1.00k]
  |  |  ------------------
  ------------------
 1474|      0|		    deparse2buff(CADR(s), d);
 1475|      0|		    print2buff(":::", d);
 1476|      0|		    deparse2buff(CADDR(s), d);
 1477|      0|		}
 1478|  3.27k|		else {
 1479|  3.27k|		    if ( isSymbol(CAR(s)) ){
  ------------------
  |  |  953|  3.27k|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1479:12): [True: 3.27k, False: 0]
  ------------------
 1480|  3.27k|			if(d->opts & S_COMPAT)
  ------------------
  |  | 2075|  3.27k|#define S_COMPAT       		128
  ------------------
  |  Branch (1480:7): [True: 0, False: 3.27k]
  ------------------
 1481|      0|			    print2buff(quotify(PRINTNAME(CAR(s)), '\''), d);
 1482|  3.27k|			else
 1483|  3.27k|			    print2buff(quotify(PRINTNAME(CAR(s)), '`'), d);
 1484|  3.27k|		    }
 1485|      0|		    else
 1486|      0|			deparse2buff(CAR(s), d);
 1487|  3.27k|		    print2buff("(", d);
 1488|  3.27k|		    args2buff(CDR(s), 0, 0, d);
 1489|  3.27k|		    print2buff(")", d);
 1490|  3.27k|		}
 1491|  3.27k|	    }
 1492|  6.97k|	} // end{op : SYMSXP }
 1493|     80|	else if (TYPEOF(op) == CLOSXP || TYPEOF(op) == SPECIALSXP
  ------------------
  |  |  114|    160|#define CLOSXP	     3	  /* closures */
  ------------------
              	else if (TYPEOF(op) == CLOSXP || TYPEOF(op) == SPECIALSXP
  ------------------
  |  |  118|     96|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (1493:11): [True: 64, False: 16]
  |  Branch (1493:35): [True: 0, False: 16]
  ------------------
 1494|     64|		 || TYPEOF(op) == BUILTINSXP) {
  ------------------
  |  |  119|     16|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (1494:7): [True: 0, False: 16]
  ------------------
 1495|     64|	    if (parenthesizeCaller(op)) {
  ------------------
  |  Branch (1495:10): [True: 64, False: 0]
  ------------------
 1496|     64|		print2buff("(", d);
 1497|     64|		deparse2buff(op, d);
 1498|     64|		print2buff(")", d);
 1499|     64|	    } else
 1500|      0|		deparse2buff(op, d);
 1501|     64|	    print2buff("(", d);
 1502|     64|	    args2buff(CDR(s), 0, 0, d);
 1503|     64|	    print2buff(")", d);
 1504|     64|	}
 1505|     16|	else { /* we have a lambda expression */
 1506|     16|	    if (parenthesizeCaller(op)) {
  ------------------
  |  Branch (1506:10): [True: 0, False: 16]
  ------------------
 1507|      0|		print2buff("(", d);
 1508|      0|		deparse2buff(op, d);
 1509|      0|		print2buff(")", d);
 1510|      0|	    } else
 1511|     16|		deparse2buff(op, d);
 1512|     16|	    print2buff("(", d);
 1513|     16|	    args2buff(CDR(s), 0, 0, d);
 1514|     16|	    print2buff(")", d);
 1515|     16|	}
 1516|  7.05k|	if (maybe_quote) {
  ------------------
  |  Branch (1516:6): [True: 0, False: 7.05k]
  ------------------
 1517|      0|	    d->opts = d_opts_in;
 1518|      0|	    if(doquote)
  ------------------
  |  Branch (1518:9): [True: 0, False: 0]
  ------------------
 1519|      0|		print2buff(")", d);
 1520|      0|	}
 1521|  7.05k|	break; // end{case LANGSXP} ---------------------------------------------
 1522|    255|    case STRSXP:
  ------------------
  |  |  126|    255|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1522:5): [True: 255, False: 15.8k]
  ------------------
 1523|    496|    case LGLSXP:
  ------------------
  |  |  121|    496|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1523:5): [True: 241, False: 15.8k]
  ------------------
 1524|    748|    case INTSXP:
  ------------------
  |  |  123|    748|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1524:5): [True: 252, False: 15.8k]
  ------------------
 1525|  4.55k|    case REALSXP:
  ------------------
  |  |  124|  4.55k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1525:5): [True: 3.80k, False: 12.2k]
  ------------------
 1526|  4.55k|    case CPLXSXP:
  ------------------
  |  |  125|  4.55k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1526:5): [True: 0, False: 16.0k]
  ------------------
 1527|  4.55k|    case RAWSXP:
  ------------------
  |  |  136|  4.55k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1527:5): [True: 0, False: 16.0k]
  ------------------
 1528|  4.55k|	vector2buff(s, d);
 1529|  4.55k|	break;
 1530|      0|    case EXTPTRSXP:
  ------------------
  |  |  134|      0|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (1530:5): [True: 0, False: 16.0k]
  ------------------
 1531|      0|    {
 1532|      0|	char tpb[32]; /* need 12+2+2*sizeof(void*) */
 1533|      0|	d->sourceable = false;
 1534|      0|	snprintf(tpb, 32, "<pointer: %p>", R_ExternalPtrAddr(s));
 1535|      0|	tpb[31] = '\0';
 1536|      0|	print2buff(tpb, d);
 1537|      0|    }
 1538|      0|	break;
 1539|      0|    case BCODESXP:
  ------------------
  |  |  133|      0|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (1539:5): [True: 0, False: 16.0k]
  ------------------
 1540|      0|	d->sourceable = false;
 1541|      0|	print2buff("<bytecode>", d);
 1542|      0|	break;
 1543|      0|    case WEAKREFSXP:
  ------------------
  |  |  135|      0|#define WEAKREFSXP  23    /* weak reference */
  ------------------
  |  Branch (1543:5): [True: 0, False: 16.0k]
  ------------------
 1544|      0|	d->sourceable = false;
 1545|      0|	print2buff("<weak reference>", d);
 1546|      0|	break;
 1547|      0|    case OBJSXP:
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (1547:5): [True: 0, False: 16.0k]
  ------------------
 1548|       |	/* a bare OBJSXP, e.g. from S7; objects with the S4 bit
 1549|       |	   are dealt with above.  Deparse to  .OBJSXP() or  structure(.OBJSXP(), <attrs>)  */
 1550|      0|	if(d_opts_in & SHOW_ATTR_OR_NMS) {
  ------------------
  |  |  911|      0|#define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2070|      0|#define SHOWATTRIBUTES 		4
  |  |  ------------------
  |  |               #define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2078|      0|#define NICE_NAMES             	1024
  |  |  ------------------
  ------------------
  |  Branch (1550:5): [True: 0, False: 0]
  ------------------
 1551|      0|	    SEXP a = ATTRIB(s);
 1552|      0|	    print2buff("structure(.OBJSXP()", d);
 1553|      0|	    for( ; !isNull(a); a = CDR(a)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (1553:13): [True: 0, False: 0]
  ------------------
 1554|      0|		if(TAG(a) != R_SrcrefSymbol) {
  ------------------
  |  Branch (1554:6): [True: 0, False: 0]
  ------------------
 1555|      0|		    print2buff(", ", d);
 1556|      0|		    attrEntry(a, d);
 1557|      0|		}
 1558|      0|	    }
 1559|      0|	}
 1560|      0|	print2buff(")", d);
 1561|      0|	break;
 1562|      0|    default:
  ------------------
  |  Branch (1562:5): [True: 0, False: 16.0k]
  ------------------
 1563|      0|	d->sourceable = false;
 1564|      0|	UNIMPLEMENTED_TYPE("deparse2buff", s);
 1565|  16.0k|    }
 1566|       |
 1567|  16.0k|    d->left = prevLeft;
 1568|  16.0k|}
deparse.c:attr1:
  761|  4.68k|{
  762|  4.68k|    SEXP a = ATTRIB(s), nm = getAttrib(s, R_NamesSymbol);
  ------------------
  |  |  924|  4.68k|#define getAttrib		Rf_getAttrib
  ------------------
  763|  4.68k|    attr_type attr = UNKNOWN;
  764|  4.68k|    bool
  765|  4.68k|	nice_names = (bool) (d->opts & NICE_NAMES),
  ------------------
  |  | 2078|  4.68k|#define NICE_NAMES             	1024
  ------------------
  766|  4.68k|	show_attr  = d->opts & SHOWATTRIBUTES,
  ------------------
  |  | 2070|  4.68k|#define SHOWATTRIBUTES 		4
  ------------------
  767|  4.68k|	has_names = !isNull(nm), ok_names;
  ------------------
  |  |  956|  4.68k|#define isNull			Rf_isNull
  ------------------
  768|       |#ifdef DEBUG_DEPARSE
  769|       |    REprintf("  attr1(): has_names = %s", ChTF(has_names));
  770|       |#endif
  771|  4.68k|    if(has_names) {
  ------------------
  |  Branch (771:8): [True: 0, False: 4.68k]
  ------------------
  772|       |	// ok only if there's no  NA_character_,.. in names() nor all """
  773|      0|	ok_names = nice_names && usable_nice_names(nm, isVectorAtomic(s));
  ------------------
  |  |  975|      0|#define isVectorAtomic		Rf_isVectorAtomic
  ------------------
  |  Branch (773:13): [True: 0, False: 0]
  |  Branch (773:27): [True: 0, False: 0]
  ------------------
  774|       |#ifdef DEBUG_DEPARSE
  775|       |	REprintf(", ok_names = %s", ChTF(ok_names));
  776|       |#endif
  777|      0|	if(!ok_names)
  ------------------
  |  Branch (777:5): [True: 0, False: 0]
  ------------------
  778|      0|	    attr = show_attr ? STRUC_NMS_A :
  ------------------
  |  Branch (778:13): [True: 0, False: 0]
  ------------------
  779|      0|		/* nice_names */  OK_NAMES; // even when not ok
  780|      0|    }
  781|       |
  782|  4.68k|    while(attr == UNKNOWN && !isNull(a)) {
  ------------------
  |  |  956|  4.68k|#define isNull			Rf_isNull
  ------------------
  |  Branch (782:11): [True: 4.68k, False: 0]
  |  Branch (782:30): [True: 0, False: 4.68k]
  ------------------
  783|      0|	if(has_names && TAG(a) == R_NamesSymbol) {
  ------------------
  |  Branch (783:5): [True: 0, False: 0]
  |  Branch (783:18): [True: 0, False: 0]
  ------------------
  784|       |	    // also  ok_names = true
  785|      0|	} else if(show_attr && TAG(a) != R_SrcrefSymbol) {
  ------------------
  |  Branch (785:12): [True: 0, False: 0]
  |  Branch (785:25): [True: 0, False: 0]
  ------------------
  786|      0|	    attr = STRUC_ATTR;
  787|      0|	    break;
  788|      0|	}
  789|       |	// else
  790|      0|	a = CDR(a);
  791|      0|    }
  792|  4.68k|    if(attr == UNKNOWN)
  ------------------
  |  Branch (792:8): [True: 4.68k, False: 0]
  ------------------
  793|  4.68k|	attr = has_names ? OK_NAMES : SIMPLE;
  ------------------
  |  Branch (793:9): [True: 0, False: 4.68k]
  ------------------
  794|       |
  795|  4.68k|    if(attr >= STRUC_ATTR) {
  ------------------
  |  Branch (795:8): [True: 0, False: 4.68k]
  ------------------
  796|      0|	print2buff("structure(", d);
  797|  4.68k|    } else if(has_names) { // attr <= OK_NAMES
  ------------------
  |  Branch (797:15): [True: 0, False: 4.68k]
  ------------------
  798|      0|    }
  799|       |#ifdef DEBUG_DEPARSE
  800|       |    REprintf(", return()ing %s\n", attrT2char(attr));
  801|       |#endif
  802|  4.68k|    return attr;
  803|  4.68k|}
deparse.c:quotify:
  861|  9.88k|{
  862|  9.88k|    const char *s = CHAR(name);
  ------------------
  |  |  203|  9.88k|#define CHAR(x) R_CHAR(x)
  ------------------
  863|       |
  864|       |    /* If a symbol is not a valid name, put it in quotes, escaping
  865|       |     * any quotes in the string itself */
  866|       |
  867|  9.88k|    if (isValidName(s) || *s == '\0') return s;
  ------------------
  |  | 1930|  9.88k|# define isValidName		Rf_isValidName
  ------------------
  |  Branch (867:9): [True: 9.88k, False: 0]
  |  Branch (867:27): [True: 0, False: 0]
  ------------------
  868|       |
  869|      0|    return EncodeString(name, 0, quote, Rprt_adj_none);
  ------------------
  |  | 1893|      0|# define EncodeString           Rf_EncodeString
  ------------------
  870|  9.88k|}
deparse.c:args2buff:
 1967|  4.06k|{
 1968|  4.06k|    bool lbreak = false;
 1969|       |
 1970|  11.6k|    while (arglist != R_NilValue) {
  ------------------
  |  Branch (1970:12): [True: 7.60k, False: 4.06k]
  ------------------
 1971|  7.60k|	if (TYPEOF(arglist) != LISTSXP && TYPEOF(arglist) != LANGSXP)
  ------------------
  |  |  113|  15.2k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
              	if (TYPEOF(arglist) != LISTSXP && TYPEOF(arglist) != LANGSXP)
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (1971:6): [True: 0, False: 7.60k]
  |  Branch (1971:36): [True: 0, False: 0]
  ------------------
 1972|      0|	    error(_("badly formed function expression"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("badly formed function expression"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1973|  7.60k|	if (TAG(arglist) != R_NilValue) {
  ------------------
  |  Branch (1973:6): [True: 1.88k, False: 5.71k]
  ------------------
 1974|  1.88k|	    SEXP s = TAG(arglist);
 1975|       |
 1976|  1.88k|	    if( s == R_DotsSymbol )
  ------------------
  |  Branch (1976:10): [True: 0, False: 1.88k]
  ------------------
 1977|      0|		print2buff(CHAR(PRINTNAME(s)), d);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1978|  1.88k|	    else if(d->backtick)
  ------------------
  |  Branch (1978:14): [True: 1.88k, False: 0]
  ------------------
 1979|  1.88k|		print2buff(quotify(PRINTNAME(s), '`'), d);
 1980|      0|	    else
 1981|      0|		print2buff(quotify(PRINTNAME(s), '"'), d);
 1982|       |
 1983|  1.88k|	    if(formals) {
  ------------------
  |  Branch (1983:9): [True: 128, False: 1.75k]
  ------------------
 1984|    128|		if (CAR(arglist) != R_MissingArg) {
  ------------------
  |  Branch (1984:7): [True: 0, False: 128]
  ------------------
 1985|      0|		    print2buff(" = ", d);
 1986|      0|		    d->fnarg = true;
 1987|      0|		    deparse2buff(CAR(arglist), d);
 1988|      0|		}
 1989|    128|	    }
 1990|  1.75k|	    else {
 1991|  1.75k|		print2buff(" = ", d);
 1992|  1.75k|		if (CAR(arglist) != R_MissingArg) {
  ------------------
  |  Branch (1992:7): [True: 1.75k, False: 0]
  ------------------
 1993|  1.75k|		    d->fnarg = true;
 1994|  1.75k|		    deparse2buff(CAR(arglist), d);
 1995|  1.75k|		}
 1996|  1.75k|	    }
 1997|  1.88k|	}
 1998|  5.71k|	else {
 1999|  5.71k|	  d->fnarg = true;
 2000|  5.71k|	  deparse2buff(CAR(arglist), d);
 2001|  5.71k|	}
 2002|  7.60k|	arglist = CDR(arglist);
 2003|  7.60k|	if (arglist != R_NilValue) {
  ------------------
  |  Branch (2003:6): [True: 3.56k, False: 4.04k]
  ------------------
 2004|  3.56k|	    print2buff(", ", d);
 2005|  3.56k|	    linebreak(&lbreak, d);
 2006|  3.56k|	}
 2007|  7.60k|    }
 2008|  4.06k|    if (lbreak)
  ------------------
  |  Branch (2008:9): [True: 104, False: 3.95k]
  ------------------
 2009|    104|	d->indent--;
 2010|  4.06k|}
deparse.c:needsparens:
  596|  5.72k|{
  597|  5.72k|    PPinfo arginfo;
  598|  5.72k|    if (TYPEOF(arg) == LANGSXP) {
  ------------------
  |  |  117|  5.72k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (598:9): [True: 1.34k, False: 4.37k]
  ------------------
  599|  1.34k|	if (TYPEOF(CAR(arg)) == SYMSXP) {
  ------------------
  |  |  112|  1.34k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (599:6): [True: 1.34k, False: 0]
  ------------------
  600|  1.34k|	    if ((TYPEOF(SYMVALUE(CAR(arg))) == BUILTINSXP) ||
  ------------------
  |  |  119|  1.34k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (600:10): [True: 331, False: 1.01k]
  ------------------
  601|  1.01k|		(TYPEOF(SYMVALUE(CAR(arg))) == SPECIALSXP)) {
  ------------------
  |  |  118|  1.01k|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (601:3): [True: 112, False: 905]
  ------------------
  602|    443|		arginfo = PPINFO(SYMVALUE(CAR(arg)));
  ------------------
  |  | 1349|    443|#define PPINFO(x)	(R_FunTab[PRIMOFFSET(x)].gram)
  ------------------
  603|       |
  604|       |		/* Not all binary ops are binary! */
  605|    443|		switch(arginfo.kind) {
  606|      0|		case PP_BINARY:
  ------------------
  |  Branch (606:3): [True: 0, False: 443]
  ------------------
  607|      0|		case PP_BINARY2:
  ------------------
  |  Branch (607:3): [True: 0, False: 443]
  ------------------
  608|      0|		    switch(length(CDR(arg))) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  609|      0|		    case 1:
  ------------------
  |  Branch (609:7): [True: 0, False: 0]
  ------------------
  610|       |			/* binary +/- precedence upgraded as unary */
  611|      0|			if (arginfo.precedence == PREC_SUM)
  ------------------
  |  Branch (611:8): [True: 0, False: 0]
  ------------------
  612|      0|			    arginfo.precedence = PREC_SIGN;
  613|      0|			arginfo.kind = PP_UNARY;
  614|      0|			break;
  615|      0|		    case 2:
  ------------------
  |  Branch (615:7): [True: 0, False: 0]
  ------------------
  616|      0|			break;
  617|      0|		    default:
  ------------------
  |  Branch (617:7): [True: 0, False: 0]
  ------------------
  618|      0|			return false;
  619|      0|		    }
  620|    443|		default:
  ------------------
  |  Branch (620:3): [True: 443, False: 0]
  ------------------
  621|    443|		    break;
  622|    443|		}
  623|       |
  624|    443|		switch(arginfo.kind) {
  625|    112|		case PP_SUBSET:
  ------------------
  |  Branch (625:3): [True: 112, False: 331]
  ------------------
  626|    112|		    switch (mainop.kind) {
  627|      0|		    case PP_DOLLAR:
  ------------------
  |  Branch (627:7): [True: 0, False: 112]
  ------------------
  628|      0|		    case PP_SUBSET:
  ------------------
  |  Branch (628:7): [True: 0, False: 112]
  ------------------
  629|      0|			if (mainop.precedence > arginfo.precedence)
  ------------------
  |  Branch (629:8): [True: 0, False: 0]
  ------------------
  630|      0|			    return false;
  631|       |			/* else fall through */
  632|    112|		    default:
  ------------------
  |  Branch (632:7): [True: 112, False: 0]
  ------------------
  633|    112|			break;
  634|    112|		    }
  635|    112|		case PP_BINARY:
  ------------------
  |  Branch (635:3): [True: 0, False: 443]
  ------------------
  636|    112|		case PP_BINARY2:
  ------------------
  |  Branch (636:3): [True: 0, False: 443]
  ------------------
  637|    112|		    if (mainop.precedence == PREC_COMPARE &&
  ------------------
  |  Branch (637:11): [True: 0, False: 112]
  ------------------
  638|      0|			arginfo.precedence == PREC_COMPARE)
  ------------------
  |  Branch (638:4): [True: 0, False: 0]
  ------------------
  639|      0|			return true;     /*   a < b < c   is not legal syntax */
  640|       |		    /* else fall through */
  641|    112|		case PP_ASSIGN:
  ------------------
  |  Branch (641:3): [True: 0, False: 443]
  ------------------
  642|    112|		case PP_ASSIGN2:
  ------------------
  |  Branch (642:3): [True: 0, False: 443]
  ------------------
  643|    112|		case PP_DOLLAR:
  ------------------
  |  Branch (643:3): [True: 0, False: 443]
  ------------------
  644|    112|		    if (mainop.precedence > arginfo.precedence
  ------------------
  |  Branch (644:11): [True: 0, False: 112]
  ------------------
  645|    112|			|| (mainop.precedence == arginfo.precedence && left == mainop.rightassoc)) {
  ------------------
  |  Branch (645:8): [True: 0, False: 112]
  |  Branch (645:51): [True: 0, False: 0]
  ------------------
  646|      0|			return true;
  647|      0|		    }
  648|    112|		    break;
  649|    112|		case PP_UNARY:
  ------------------
  |  Branch (649:3): [True: 0, False: 443]
  ------------------
  650|      0|		    return (left && mainop.precedence > arginfo.precedence)
  ------------------
  |  Branch (650:15): [True: 0, False: 0]
  |  Branch (650:23): [True: 0, False: 0]
  ------------------
  651|      0|			|| (deepLeft && deepLeft > arginfo.precedence);
  ------------------
  |  Branch (651:8): [True: 0, False: 0]
  |  Branch (651:20): [True: 0, False: 0]
  ------------------
  652|      0|		case PP_FOR:
  ------------------
  |  Branch (652:3): [True: 0, False: 443]
  ------------------
  653|      0|		case PP_IF:
  ------------------
  |  Branch (653:3): [True: 0, False: 443]
  ------------------
  654|      0|		case PP_WHILE:
  ------------------
  |  Branch (654:3): [True: 0, False: 443]
  ------------------
  655|      0|		case PP_REPEAT:
  ------------------
  |  Branch (655:3): [True: 0, False: 443]
  ------------------
  656|      0|		    return left || deepLeft;
  ------------------
  |  Branch (656:14): [True: 0, False: 0]
  |  Branch (656:22): [True: 0, False: 0]
  ------------------
  657|    331|		default:
  ------------------
  |  Branch (657:3): [True: 331, False: 112]
  ------------------
  658|    331|		    return false;
  659|    443|		}
  660|    905|	    } else if (isUserBinop(CAR(arg))) {
  ------------------
  |  |  971|    905|#define isUserBinop		Rf_isUserBinop
  ------------------
  |  Branch (660:17): [True: 0, False: 905]
  ------------------
  661|      0|		if (mainop.precedence > PREC_PERCENT
  ------------------
  |  Branch (661:7): [True: 0, False: 0]
  ------------------
  662|      0|		    || (mainop.precedence == PREC_PERCENT && left == mainop.rightassoc)) {
  ------------------
  |  Branch (662:11): [True: 0, False: 0]
  |  Branch (662:48): [True: 0, False: 0]
  ------------------
  663|      0|		    return true;
  664|      0|		}
  665|      0|	    }
  666|  1.34k|	}
  667|  1.34k|    }
  668|  4.37k|    else if ((TYPEOF(arg) == CPLXSXP) && (length(arg) == 1)) {
  ------------------
  |  |  125|  4.37k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
                  else if ((TYPEOF(arg) == CPLXSXP) && (length(arg) == 1)) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (668:14): [True: 0, False: 4.37k]
  |  Branch (668:42): [True: 0, False: 0]
  ------------------
  669|      0|	if (mainop.precedence > PREC_SUM
  ------------------
  |  Branch (669:6): [True: 0, False: 0]
  ------------------
  670|      0|	    || (mainop.precedence == PREC_SUM && left == mainop.rightassoc)) {
  ------------------
  |  Branch (670:10): [True: 0, False: 0]
  |  Branch (670:43): [True: 0, False: 0]
  ------------------
  671|      0|	    return true;
  672|      0|	}
  673|      0|    }
  674|  4.37k|    else if (ATTRIB(arg) == R_NilValue && length(arg) == 1 &&
  ------------------
  |  |  987|  4.37k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (674:14): [True: 4.37k, False: 0]
  |  Branch (674:43): [True: 4.37k, False: 0]
  ------------------
  675|  4.37k|	     ((TYPEOF(arg) == REALSXP && REAL(arg)[0] < 0) ||
  ------------------
  |  |  124|  8.74k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (675:9): [True: 2.42k, False: 1.95k]
  |  Branch (675:35): [True: 0, False: 2.42k]
  ------------------
  676|  4.37k|	      (TYPEOF(arg) == INTSXP && INTEGER(arg)[0] != NA_INTEGER &&
  ------------------
  |  |  123|  8.74k|#define INTSXP	    13	  /* integer vectors */
  ------------------
              	      (TYPEOF(arg) == INTSXP && INTEGER(arg)[0] != NA_INTEGER &&
  ------------------
  |  |   56|  4.45k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (676:9): [True: 84, False: 4.29k]
  |  Branch (676:34): [True: 84, False: 0]
  ------------------
  677|     84|	       INTEGER(arg)[0] < 0))) {
  ------------------
  |  Branch (677:9): [True: 0, False: 84]
  ------------------
  678|       |	/* a negative constant deparses with a unary minus, so it binds
  679|       |	   like one: call("^", -2, 2) must become (-2)^2, not -2^2.
  680|       |	   NA_INTEGER is INT_MIN and must be excluded explicitly; NA_real_
  681|       |	   and NaN already fail the < 0 test. */
  682|      0|	return (left && mainop.precedence > PREC_SIGN)
  ------------------
  |  Branch (682:10): [True: 0, False: 0]
  |  Branch (682:18): [True: 0, False: 0]
  ------------------
  683|      0|	    || (deepLeft && deepLeft > PREC_SIGN);
  ------------------
  |  Branch (683:10): [True: 0, False: 0]
  |  Branch (683:22): [True: 0, False: 0]
  ------------------
  684|      0|    }
  685|  5.39k|    return false;
  686|  5.72k|}
deparse.c:linebreak:
  557|  3.79k|{
  558|  3.79k|    if (d->len > d->cutoff) {
  ------------------
  |  Branch (558:9): [True: 104, False: 3.68k]
  ------------------
  559|    104|	if (!*lbreak) {
  ------------------
  |  Branch (559:6): [True: 104, False: 0]
  ------------------
  560|    104|	    *lbreak = true;
  561|    104|	    d->indent++;
  562|    104|	}
  563|    104|	writeline(d);
  564|    104|    }
  565|  3.79k|}
deparse.c:parenthesizeCaller:
  884|     80|{
  885|     80|    SEXP op, sym;
  886|     80|    if (TYPEOF(s) == LANGSXP) { /* unevaluated */
  ------------------
  |  |  117|     80|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (886:9): [True: 16, False: 64]
  ------------------
  887|     16|	op = CAR(s);
  888|     16|	if (TYPEOF(op) == SYMSXP) {
  ------------------
  |  |  112|     16|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (888:6): [True: 16, False: 0]
  ------------------
  889|     16|	    if (isUserBinop(op)) return true;   /* %foo% */
  ------------------
  |  |  971|     16|#define isUserBinop		Rf_isUserBinop
  ------------------
  |  Branch (889:10): [True: 0, False: 16]
  ------------------
  890|     16|	    sym = SYMVALUE(op);
  891|     16|	    if (TYPEOF(sym) == BUILTINSXP
  ------------------
  |  |  119|     32|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (891:10): [True: 0, False: 16]
  ------------------
  892|     16|		|| TYPEOF(sym) == SPECIALSXP) {
  ------------------
  |  |  118|     16|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (892:6): [True: 0, False: 16]
  ------------------
  893|      0|		if (PPINFO(sym).precedence >= PREC_SUBSET
  ------------------
  |  | 1349|      0|#define PPINFO(x)	(R_FunTab[PRIMOFFSET(x)].gram)
  ------------------
  |  Branch (893:7): [True: 0, False: 0]
  ------------------
  894|      0|		    || PPINFO(sym).kind == PP_FUNCALL
  ------------------
  |  | 1349|      0|#define PPINFO(x)	(R_FunTab[PRIMOFFSET(x)].gram)
  ------------------
  |  Branch (894:10): [True: 0, False: 0]
  ------------------
  895|      0|		    || PPINFO(sym).kind == PP_PAREN
  ------------------
  |  | 1349|      0|#define PPINFO(x)	(R_FunTab[PRIMOFFSET(x)].gram)
  ------------------
  |  Branch (895:10): [True: 0, False: 0]
  ------------------
  896|      0|		    || PPINFO(sym).kind == PP_CURLY) return false; /* x$f(z) or x[n](z) or f(z) or (f) or {f} */
  ------------------
  |  | 1349|      0|#define PPINFO(x)	(R_FunTab[PRIMOFFSET(x)].gram)
  ------------------
  |  Branch (896:10): [True: 0, False: 0]
  ------------------
  897|      0|		else return true;		/* (f+g)(z) etc. */
  898|      0|	    }
  899|     16|	    return false;			/* regular function call */
  900|     16|	 } else
  901|      0|	    return true;			/* something strange, like (1)(x) */
  902|     16|    } else
  903|     64|	return TYPEOF(s) == CLOSXP;
  ------------------
  |  |  114|     64|#define CLOSXP	     3	  /* closures */
  ------------------
  904|     80|}
deparse.c:vector2buff:
 1675|  4.55k|{
 1676|       |    // Known here:  TYPEOF(vector)  is one of the 6 atomic *SXPs
 1677|  4.55k|    const char *strp;
 1678|  4.55k|    char *buff = 0, hex[64]; // 64 is more than enough
 1679|  4.55k|    int i, d_opts_in = d->opts,
 1680|  4.55k|	tlen = length(vector),
  ------------------
  |  |  987|  4.55k|#define length(x)		Rf_length(x)
  ------------------
 1681|  4.55k|	quote = isString(vector) ? '"' : 0;
  ------------------
  |  |  966|  4.55k|#define isString		Rf_isString
  ------------------
  |  Branch (1681:10): [True: 255, False: 4.29k]
  ------------------
 1682|  4.55k|    bool surround = false, allNA,
 1683|  4.55k|	intSeq = false; // := true iff integer sequence 'm:n' (up *or* down)
 1684|  4.55k|    if(TYPEOF(vector) == INTSXP && tlen > 1) {
  ------------------
  |  |  123|  9.10k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1684:8): [True: 252, False: 4.30k]
  |  Branch (1684:36): [True: 0, False: 252]
  ------------------
 1685|      0|	int *vec = INTEGER(vector);
 1686|       |	// vec[1] - vec[0] could overflow, and does in package Rmpfr
 1687|      0|	double d_i = (double) vec[1] - (double)vec[0];
 1688|      0|	intSeq = (vec[0] != NA_INTEGER &&
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1688:12): [True: 0, False: 0]
  ------------------
 1689|      0|		  vec[1] != NA_INTEGER &&
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1689:5): [True: 0, False: 0]
  ------------------
 1690|      0|		  fabs(d_i) == 1);
  ------------------
  |  Branch (1690:5): [True: 0, False: 0]
  ------------------
 1691|      0|	if(intSeq) for(i = 2; i < tlen; i++) {
  ------------------
  |  Branch (1691:5): [True: 0, False: 0]
  |  Branch (1691:24): [True: 0, False: 0]
  ------------------
 1692|      0|	    if((vec[i] == NA_INTEGER) ||
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1692:9): [True: 0, False: 0]
  ------------------
 1693|      0|	       ((double)vec[i] - (double)vec[i-1]) != d_i) {
  ------------------
  |  Branch (1693:9): [True: 0, False: 0]
  ------------------
 1694|      0|		intSeq = false;
 1695|      0|		break;
 1696|      0|	    }
 1697|      0|	}
 1698|      0|    }
 1699|       |
 1700|  4.55k|    SEXP nv = R_NilValue;
 1701|  4.55k|    bool do_names = (bool)(d_opts_in & SHOW_ATTR_OR_NMS);// iff true use '<tag_i> = <comp_i>'
  ------------------
  |  |  911|  4.55k|#define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2070|  4.55k|#define SHOWATTRIBUTES 		4
  |  |  ------------------
  |  |               #define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2078|  4.55k|#define NICE_NAMES             	1024
  |  |  ------------------
  ------------------
 1702|  4.55k|    if(do_names) {
  ------------------
  |  Branch (1702:8): [True: 4.55k, False: 0]
  ------------------
 1703|  4.55k|	nv = getAttrib(vector, R_NamesSymbol); // only "do names" if have names:
  ------------------
  |  |  924|  4.55k|#define getAttrib		Rf_getAttrib
  ------------------
 1704|  4.55k|	if(isNull(nv))
  ------------------
  |  |  956|  4.55k|#define isNull			Rf_isNull
  ------------------
  |  Branch (1704:5): [True: 4.55k, False: 0]
  ------------------
 1705|  4.55k|	    do_names = false;
 1706|  4.55k|    }
 1707|  4.55k|    PROTECT(nv);
  ------------------
  |  |  357|  4.55k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1708|  4.55k|    bool
 1709|  4.55k|	STR_names, // if true, use structure(.,*) for names even if(nice_names)
 1710|  4.55k|	need_c = tlen > 1; // (?) only true iff SHOW_ATTR_OR_NMS
 1711|  4.55k|    STR_names = do_names && (intSeq || tlen == 0);
  ------------------
  |  Branch (1711:17): [True: 0, False: 4.55k]
  |  Branch (1711:30): [True: 0, False: 0]
  |  Branch (1711:40): [True: 0, False: 0]
  ------------------
 1712|       |#ifdef DEBUG_DEPARSE
 1713|       |    REprintf("vector2buff(v): length(v) = %d; initial (do|STR)_names) = (%s,%s)\n",
 1714|       |	     tlen, ChTF(do_names), ChTF(STR_names));
 1715|       |#endif
 1716|  4.55k|    if (STR_names) // use structure(.,*) for names even if(nice_names)
  ------------------
  |  Branch (1716:9): [True: 0, False: 4.55k]
  ------------------
 1717|      0|	d->opts &= ~NICE_NAMES;
  ------------------
  |  | 2078|      0|#define NICE_NAMES             	1024
  ------------------
 1718|  4.55k|    attr_type attr = (d_opts_in & SHOW_ATTR_OR_NMS) ? attr1(vector, d) : SIMPLE;
  ------------------
  |  |  911|  4.55k|#define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2070|  4.55k|#define SHOWATTRIBUTES 		4
  |  |  ------------------
  |  |               #define SHOW_ATTR_OR_NMS (SHOWATTRIBUTES | NICE_NAMES)
  |  |  ------------------
  |  |  |  | 2078|  4.55k|#define NICE_NAMES             	1024
  |  |  ------------------
  ------------------
  |  Branch (1718:22): [True: 4.55k, False: 0]
  ------------------
 1719|  4.55k|    if(do_names) do_names = (attr == OK_NAMES || attr == STRUC_ATTR);
  ------------------
  |  Branch (1719:8): [True: 0, False: 4.55k]
  |  Branch (1719:30): [True: 0, False: 0]
  |  Branch (1719:50): [True: 0, False: 0]
  ------------------
 1720|  4.55k|    if(!need_c) need_c = do_names; // c(a = *) but not c(1)
  ------------------
  |  Branch (1720:8): [True: 4.55k, False: 0]
  ------------------
 1721|       |#ifdef DEBUG_DEPARSE
 1722|       |    REprintf(" -> final (do|STR)_names) = (%s,%s), attr = %s\n",
 1723|       |	     ChTF(do_names), ChTF(STR_names), attrT2char(attr));
 1724|       |#endif
 1725|  4.55k|    if (tlen == 0) {
  ------------------
  |  Branch (1725:9): [True: 0, False: 4.55k]
  ------------------
 1726|      0|	switch(TYPEOF(vector)) {
 1727|      0|	case LGLSXP: print2buff("logical(0)", d); break;
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1727:2): [True: 0, False: 0]
  ------------------
 1728|      0|	case INTSXP: print2buff("integer(0)", d); break;
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1728:2): [True: 0, False: 0]
  ------------------
 1729|      0|	case REALSXP: print2buff("numeric(0)", d); break;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1729:2): [True: 0, False: 0]
  ------------------
 1730|      0|	case CPLXSXP: print2buff("complex(0)", d); break;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1730:2): [True: 0, False: 0]
  ------------------
 1731|      0|	case STRSXP: print2buff("character(0)", d); break;
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1731:2): [True: 0, False: 0]
  ------------------
 1732|      0|	case RAWSXP: print2buff("raw(0)", d); break;
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1732:2): [True: 0, False: 0]
  ------------------
 1733|      0|	default: UNIMPLEMENTED_TYPE("vector2buff", vector);
  ------------------
  |  Branch (1733:2): [True: 0, False: 0]
  ------------------
 1734|      0|	}
 1735|      0|    }
 1736|  4.55k|    else if(TYPEOF(vector) == INTSXP) {
  ------------------
  |  |  123|  4.55k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1736:13): [True: 252, False: 4.30k]
  ------------------
 1737|       |	/* We treat integer separately, as S_compatible is relevant.
 1738|       |
 1739|       |	   Also, it is neat to deparse m:n in that form,
 1740|       |	   so we do so as from 2.5.0, and for m > n, from 3.5.0
 1741|       |	 */
 1742|    252|	if(intSeq) { // m:n
  ------------------
  |  Branch (1742:5): [True: 0, False: 252]
  ------------------
 1743|      0|		strp = EncodeElement(vector, 0, '"', '.');
  ------------------
  |  |   37|      0|#define EncodeElement       Rf_EncodeElement
  ------------------
 1744|      0|		print2buff(strp, d);
 1745|      0|		print2buff(":", d);
 1746|      0|		strp = EncodeElement(vector, tlen - 1, '"', '.');
  ------------------
  |  |   37|      0|#define EncodeElement       Rf_EncodeElement
  ------------------
 1747|      0|		print2buff(strp, d);
 1748|    252|	} else {
 1749|    252|	    int *vec = INTEGER(vector);
 1750|    252|	    bool addL = d->opts & KEEPINTEGER & !(d->opts & S_COMPAT);
  ------------------
  |  | 2068|    252|#define KEEPINTEGER 		1
  ------------------
              	    bool addL = d->opts & KEEPINTEGER & !(d->opts & S_COMPAT);
  ------------------
  |  | 2075|    252|#define S_COMPAT       		128
  ------------------
 1751|    252|	    allNA = (d->opts & KEEPNA) || addL;
  ------------------
  |  | 2074|    252|#define KEEPNA			64
  ------------------
  |  Branch (1751:14): [True: 252, False: 0]
  |  Branch (1751:36): [True: 0, False: 0]
  ------------------
 1752|    252|	    for(i = 0; i < tlen; i++)
  ------------------
  |  Branch (1752:17): [True: 252, False: 0]
  ------------------
 1753|    252|		if(vec[i] != NA_INTEGER) {
  ------------------
  |  |   56|    252|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1753:6): [True: 252, False: 0]
  ------------------
 1754|    252|		    allNA = false;
 1755|    252|		    break;
 1756|    252|		}
 1757|    252|	    if((d->opts & KEEPINTEGER && (d->opts & S_COMPAT))) {
  ------------------
  |  | 2068|    504|#define KEEPINTEGER 		1
  ------------------
              	    if((d->opts & KEEPINTEGER && (d->opts & S_COMPAT))) {
  ------------------
  |  | 2075|    252|#define S_COMPAT       		128
  ------------------
  |  Branch (1757:10): [True: 252, False: 0]
  |  Branch (1757:35): [True: 0, False: 252]
  ------------------
 1758|      0|		print2buff("as.integer(", d); surround = true;
 1759|      0|	    }
 1760|    252|	    allNA = allNA && !(d->opts & S_COMPAT);
  ------------------
  |  | 2075|      0|#define S_COMPAT       		128
  ------------------
  |  Branch (1760:14): [True: 0, False: 252]
  |  Branch (1760:23): [True: 0, False: 0]
  ------------------
 1761|    252|	    if(need_c) print2buff("c(", d);
  ------------------
  |  Branch (1761:9): [True: 0, False: 252]
  ------------------
 1762|    504|	    for (i = 0; i < tlen; i++) {
  ------------------
  |  Branch (1762:18): [True: 252, False: 252]
  ------------------
 1763|    252|		if(do_names) // put '<tag> = '
  ------------------
  |  Branch (1763:6): [True: 0, False: 252]
  ------------------
 1764|      0|		    deparse2buf_name(nv, i, d);
 1765|    252|		if(allNA && vec[i] == NA_INTEGER) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1765:6): [True: 0, False: 252]
  |  Branch (1765:15): [True: 0, False: 0]
  ------------------
 1766|      0|		    print2buff("NA_integer_", d);
 1767|    252|		} else {
 1768|    252|		    strp = EncodeElement(vector, i, quote, '.');
  ------------------
  |  |   37|    252|#define EncodeElement       Rf_EncodeElement
  ------------------
 1769|    252|		    print2buff(strp, d);
 1770|    252|		    if(addL && vec[i] != NA_INTEGER) print2buff("L", d);
  ------------------
  |  |   56|    252|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1770:10): [True: 252, False: 0]
  |  Branch (1770:18): [True: 252, False: 0]
  ------------------
 1771|    252|		}
 1772|    252|		if (i < (tlen - 1)) print2buff(", ", d);
  ------------------
  |  Branch (1772:7): [True: 0, False: 252]
  ------------------
 1773|    252|		if (tlen > 1 && d->len > d->cutoff) writeline(d);
  ------------------
  |  Branch (1773:7): [True: 0, False: 252]
  |  Branch (1773:19): [True: 0, False: 0]
  ------------------
 1774|    252|		if (!d->active) break;
  ------------------
  |  Branch (1774:7): [True: 0, False: 252]
  ------------------
 1775|    252|	    }
 1776|    252|	    if(need_c)   print2buff(")", d);
  ------------------
  |  Branch (1776:9): [True: 0, False: 252]
  ------------------
 1777|    252|	    if(surround) print2buff(")", d);
  ------------------
  |  Branch (1777:9): [True: 0, False: 252]
  ------------------
 1778|    252|	}
 1779|  4.30k|    } else { // tlen > 0;  _not_ INTSXP
 1780|  4.30k|	allNA = d->opts & KEEPNA;
  ------------------
  |  | 2074|  4.30k|#define KEEPNA			64
  ------------------
 1781|  4.30k|	if((d->opts & KEEPNA) && TYPEOF(vector) == REALSXP) {
  ------------------
  |  | 2074|  4.30k|#define KEEPNA			64
  ------------------
              	if((d->opts & KEEPNA) && TYPEOF(vector) == REALSXP) {
  ------------------
  |  |  124|  4.30k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1781:5): [True: 4.30k, False: 0]
  |  Branch (1781:27): [True: 3.80k, False: 496]
  ------------------
 1782|  3.80k|	    for(i = 0; i < tlen; i++)
  ------------------
  |  Branch (1782:17): [True: 3.80k, False: 0]
  ------------------
 1783|  3.80k|		if(!ISNA(REAL(vector)[i])) {
  ------------------
  |  |   64|  3.80k|#define ISNA(x)	       R_IsNA(x)
  ------------------
  |  Branch (1783:6): [True: 3.80k, False: 0]
  ------------------
 1784|  3.80k|		    allNA = false;
 1785|  3.80k|		    break;
 1786|  3.80k|		}
 1787|  3.80k|	    if(allNA && (d->opts & S_COMPAT)) {
  ------------------
  |  | 2075|      0|#define S_COMPAT       		128
  ------------------
  |  Branch (1787:9): [True: 0, False: 3.80k]
  |  Branch (1787:18): [True: 0, False: 0]
  ------------------
 1788|      0|		print2buff("as.double(", d); surround = true;
 1789|      0|	    }
 1790|  3.80k|	} else if((d->opts & KEEPNA) && TYPEOF(vector) == CPLXSXP) {
  ------------------
  |  | 2074|    496|#define KEEPNA			64
  ------------------
              	} else if((d->opts & KEEPNA) && TYPEOF(vector) == CPLXSXP) {
  ------------------
  |  |  125|    496|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1790:12): [True: 496, False: 0]
  |  Branch (1790:34): [True: 0, False: 496]
  ------------------
 1791|      0|	    Rcomplex *vec = COMPLEX(vector);
 1792|      0|	    for(i = 0; i < tlen; i++) {
  ------------------
  |  Branch (1792:17): [True: 0, False: 0]
  ------------------
 1793|      0|		if( !ISNA(vec[i].r) && !ISNA(vec[i].i) ) {
  ------------------
  |  |   64|      0|#define ISNA(x)	       R_IsNA(x)
  ------------------
              		if( !ISNA(vec[i].r) && !ISNA(vec[i].i) ) {
  ------------------
  |  |   64|      0|#define ISNA(x)	       R_IsNA(x)
  ------------------
  |  Branch (1793:7): [True: 0, False: 0]
  |  Branch (1793:26): [True: 0, False: 0]
  ------------------
 1794|      0|		    allNA = false;
 1795|      0|		    break;
 1796|      0|		}
 1797|      0|	    }
 1798|      0|	    if(allNA && (d->opts & S_COMPAT)) {
  ------------------
  |  | 2075|      0|#define S_COMPAT       		128
  ------------------
  |  Branch (1798:9): [True: 0, False: 0]
  |  Branch (1798:18): [True: 0, False: 0]
  ------------------
 1799|      0|		print2buff("as.complex(", d); surround = true;
 1800|       |
 1801|      0|	    }
 1802|    496|	} else if((d->opts & KEEPNA) && TYPEOF(vector) == STRSXP) {
  ------------------
  |  | 2074|    496|#define KEEPNA			64
  ------------------
              	} else if((d->opts & KEEPNA) && TYPEOF(vector) == STRSXP) {
  ------------------
  |  |  126|    496|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1802:12): [True: 496, False: 0]
  |  Branch (1802:34): [True: 255, False: 241]
  ------------------
 1803|    255|	    for(i = 0; i < tlen; i++)
  ------------------
  |  Branch (1803:17): [True: 255, False: 0]
  ------------------
 1804|    255|		if(STRING_ELT(vector, i) != NA_STRING) {
  ------------------
  |  |  433|    255|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1804:6): [True: 255, False: 0]
  ------------------
 1805|    255|		    allNA = false;
 1806|    255|		    break;
 1807|    255|		}
 1808|    255|	    if(allNA && (d->opts & S_COMPAT)) {
  ------------------
  |  | 2075|      0|#define S_COMPAT       		128
  ------------------
  |  Branch (1808:9): [True: 0, False: 255]
  |  Branch (1808:18): [True: 0, False: 0]
  ------------------
 1809|      0|		print2buff("as.character(", d); surround = true;
 1810|      0|	    }
 1811|    255|	} else if(TYPEOF(vector) == RAWSXP) {
  ------------------
  |  |  136|    241|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1811:12): [True: 0, False: 241]
  ------------------
 1812|      0|	    print2buff("as.raw(", d); surround = true;
 1813|      0| 	}
 1814|  4.30k|	if(need_c) print2buff("c(", d);
  ------------------
  |  Branch (1814:5): [True: 0, False: 4.30k]
  ------------------
 1815|  4.30k|	allNA = allNA && !(d->opts & S_COMPAT);
  ------------------
  |  | 2075|    241|#define S_COMPAT       		128
  ------------------
  |  Branch (1815:10): [True: 241, False: 4.06k]
  |  Branch (1815:19): [True: 241, False: 0]
  ------------------
 1816|  8.60k|	for (i = 0; i < tlen; i++) {
  ------------------
  |  Branch (1816:14): [True: 4.30k, False: 4.30k]
  ------------------
 1817|  4.30k|	    if(do_names) // put '<tag> = '
  ------------------
  |  Branch (1817:9): [True: 0, False: 4.30k]
  ------------------
 1818|      0|		deparse2buf_name(nv, i, d);
 1819|  4.30k|	    if(allNA && TYPEOF(vector) == REALSXP &&
  ------------------
  |  |  124|  4.54k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1819:9): [True: 241, False: 4.06k]
  |  Branch (1819:18): [True: 0, False: 241]
  ------------------
 1820|      0|	       ISNA(REAL(vector)[i])) {
  ------------------
  |  |   64|      0|#define ISNA(x)	       R_IsNA(x)
  |  |  ------------------
  |  |  |  Branch (64:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1821|      0|		strp = "NA_real_";
 1822|  4.30k|	    } else if (TYPEOF(vector) == CPLXSXP &&
  ------------------
  |  |  125|  8.60k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1822:17): [True: 0, False: 4.30k]
  ------------------
 1823|      0|		       (ISNA(COMPLEX(vector)[i].r)
  ------------------
  |  |   64|      0|#define ISNA(x)	       R_IsNA(x)
  |  |  ------------------
  |  |  |  Branch (64:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1824|      0|			&& ISNA(COMPLEX(vector)[i].i)) ) {
  ------------------
  |  |   64|      0|#define ISNA(x)	       R_IsNA(x)
  |  |  ------------------
  |  |  |  Branch (64:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1825|      0|		strp = allNA ? "NA_complex_" : EncodeElement(vector, i, quote, '.');
  ------------------
  |  |   37|      0|#define EncodeElement       Rf_EncodeElement
  ------------------
  |  Branch (1825:10): [True: 0, False: 0]
  ------------------
 1826|  4.30k|	    } else if(TYPEOF(vector) == CPLXSXP &&
  ------------------
  |  |  125|  8.60k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1826:16): [True: 0, False: 4.30k]
  ------------------
 1827|      0|		      (ISNAN(COMPLEX(vector)[i].r) || !R_FINITE(COMPLEX(vector)[i].i)) ) {
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              		      (ISNAN(COMPLEX(vector)[i].r) || !R_FINITE(COMPLEX(vector)[i].i)) ) {
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (1827:41): [True: 0, False: 0]
  ------------------
 1828|      0|		if (!buff)
  ------------------
  |  Branch (1828:7): [True: 0, False: 0]
  ------------------
 1829|      0|		    buff = alloca(NB2);
  ------------------
  |  | 2562|      0|# define alloca(x) __builtin_alloca((x))
  ------------------
 1830|      0|		strp = EncodeNonFiniteComplexElement(COMPLEX(vector)[i], buff);
 1831|  4.30k|	    } else if (allNA && TYPEOF(vector) == STRSXP &&
  ------------------
  |  |  126|  4.54k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1831:17): [True: 241, False: 4.06k]
  |  Branch (1831:26): [True: 0, False: 241]
  ------------------
 1832|      0|		       STRING_ELT(vector, i) == NA_STRING) {
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1832:10): [True: 0, False: 0]
  ------------------
 1833|      0|		strp = "NA_character_";
 1834|  4.30k|	    } else if (TYPEOF(vector) == REALSXP && (d->opts & S_COMPAT)) {
  ------------------
  |  |  124|  8.60k|#define REALSXP	    14	  /* real variables */
  ------------------
              	    } else if (TYPEOF(vector) == REALSXP && (d->opts & S_COMPAT)) {
  ------------------
  |  | 2075|  3.80k|#define S_COMPAT       		128
  ------------------
  |  Branch (1834:17): [True: 3.80k, False: 496]
  |  Branch (1834:46): [True: 0, False: 3.80k]
  ------------------
 1835|      0|		int w, d, e;
 1836|      0|		formatReal(&REAL(vector)[i], 1, &w, &d, &e, 0);
  ------------------
  |  |   41|      0|#define formatReal         Rf_formatReal
  ------------------
 1837|      0|		strp = EncodeReal2(REAL(vector)[i], w, d, e);
  ------------------
  |  | 1892|      0|# define EncodeReal2            Rf_EncodeReal2
  ------------------
 1838|  4.30k|	    } else if (TYPEOF(vector) == STRSXP) {
  ------------------
  |  |  126|  4.30k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1838:17): [True: 255, False: 4.04k]
  ------------------
 1839|    255|		const void *vmax = vmaxget();
 1840|       |#ifdef longstring_WARN
 1841|       |		const char *ts = translateChar(STRING_ELT(vector, i));
 1842|       |		/* versions of R < 2.7.0 cannot parse strings longer than 8192 chars */
 1843|       |		if(strlen(ts) >= 8192) d->longstring = true;
 1844|       |#endif
 1845|    255|		strp = EncodeElement(vector, i, quote, '.');
  ------------------
  |  |   37|    255|#define EncodeElement       Rf_EncodeElement
  ------------------
 1846|    255|		vmaxset(vmax);
 1847|  4.04k|	    } else if (TYPEOF(vector) == RAWSXP) {
  ------------------
  |  |  136|  4.04k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1847:17): [True: 0, False: 4.04k]
  ------------------
 1848|      0|		strp = EncodeRaw(RAW(vector)[i], "0x");
  ------------------
  |  | 1891|      0|# define EncodeRaw              Rf_EncodeRaw
  ------------------
 1849|  4.04k|	    } else if (TYPEOF(vector) == REALSXP && (d->opts & HEXNUMERIC)) {
  ------------------
  |  |  124|  8.09k|#define REALSXP	    14	  /* real variables */
  ------------------
              	    } else if (TYPEOF(vector) == REALSXP && (d->opts & HEXNUMERIC)) {
  ------------------
  |  | 2076|  3.80k|#define HEXNUMERIC             	256
  ------------------
  |  Branch (1849:17): [True: 3.80k, False: 241]
  |  Branch (1849:46): [True: 0, False: 3.80k]
  ------------------
 1850|      0|		double x = REAL(vector)[i];
 1851|       |		// Windows warns here, but incorrectly as this is C99
 1852|       |		// and the snprintf used from trio is compliant.
 1853|      0|		if (R_FINITE(x)) {
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (1853:7): [True: 0, False: 0]
  ------------------
 1854|      0|		    snprintf(hex, 32, "%a", x);
 1855|      0|		    strp = hex;
 1856|      0|		} else
 1857|      0|		    strp = EncodeElement(vector, i, quote, '.');
  ------------------
  |  |   37|      0|#define EncodeElement       Rf_EncodeElement
  ------------------
 1858|  4.04k|	    } else if (TYPEOF(vector) == REALSXP && (d->opts & DIGITS17)) {
  ------------------
  |  |  124|  8.09k|#define REALSXP	    14	  /* real variables */
  ------------------
              	    } else if (TYPEOF(vector) == REALSXP && (d->opts & DIGITS17)) {
  ------------------
  |  | 2077|  3.80k|#define DIGITS17		512
  ------------------
  |  Branch (1858:17): [True: 3.80k, False: 241]
  |  Branch (1858:46): [True: 0, False: 3.80k]
  ------------------
 1859|      0|		double x = REAL(vector)[i];
 1860|      0|		if (R_FINITE(x)) {
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (1860:7): [True: 0, False: 0]
  ------------------
 1861|      0|		    snprintf(hex, 32, "%.17g", x);
 1862|      0|		    strp = hex;
 1863|      0|		} else
 1864|      0|		    strp = EncodeElement(vector, i, quote, '.');
  ------------------
  |  |   37|      0|#define EncodeElement       Rf_EncodeElement
  ------------------
 1865|  4.04k|	    } else if (TYPEOF(vector) == CPLXSXP && (d->opts & HEXNUMERIC)) {
  ------------------
  |  |  125|  8.09k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
              	    } else if (TYPEOF(vector) == CPLXSXP && (d->opts & HEXNUMERIC)) {
  ------------------
  |  | 2076|      0|#define HEXNUMERIC             	256
  ------------------
  |  Branch (1865:17): [True: 0, False: 4.04k]
  |  Branch (1865:46): [True: 0, False: 0]
  ------------------
 1866|      0|		Rcomplex z =  COMPLEX(vector)[i];
 1867|      0|		if (R_FINITE(z.r) && R_FINITE(z.i)) {
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
              		if (R_FINITE(z.r) && R_FINITE(z.i)) {
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (1867:7): [True: 0, False: 0]
  |  Branch (1867:24): [True: 0, False: 0]
  ------------------
 1868|      0|		    snprintf(hex, 64, "%a + %ai", z.r, z.i);
 1869|      0|		    strp = hex;
 1870|      0|		} else
 1871|      0|		    strp = EncodeElement(vector, i, quote, '.');
  ------------------
  |  |   37|      0|#define EncodeElement       Rf_EncodeElement
  ------------------
 1872|  4.04k|	    } else if (TYPEOF(vector) == CPLXSXP && (d->opts & DIGITS17)) {
  ------------------
  |  |  125|  8.09k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
              	    } else if (TYPEOF(vector) == CPLXSXP && (d->opts & DIGITS17)) {
  ------------------
  |  | 2077|      0|#define DIGITS17		512
  ------------------
  |  Branch (1872:17): [True: 0, False: 4.04k]
  |  Branch (1872:46): [True: 0, False: 0]
  ------------------
 1873|      0|		Rcomplex z =  COMPLEX(vector)[i];
 1874|      0|		if (R_FINITE(z.r) && R_FINITE(z.i)) {
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
              		if (R_FINITE(z.r) && R_FINITE(z.i)) {
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (1874:7): [True: 0, False: 0]
  |  Branch (1874:24): [True: 0, False: 0]
  ------------------
 1875|      0|		    snprintf(hex, 64, "%.17g%+.17gi", z.r, z.i);
 1876|      0|		    strp = hex;
 1877|      0|		} else
 1878|      0|		    strp = EncodeElement(vector, i, quote, '.');
  ------------------
  |  |   37|      0|#define EncodeElement       Rf_EncodeElement
  ------------------
 1879|      0|	    } else
 1880|  4.04k|		strp = EncodeElement(vector, i, quote, '.');
  ------------------
  |  |   37|  4.04k|#define EncodeElement       Rf_EncodeElement
  ------------------
 1881|  4.30k|	    print2buff(strp, d);
 1882|  4.30k|	    if (i < (tlen - 1)) print2buff(", ", d);
  ------------------
  |  Branch (1882:10): [True: 0, False: 4.30k]
  ------------------
 1883|  4.30k|	    if (tlen > 1 && d->len > d->cutoff) writeline(d);
  ------------------
  |  Branch (1883:10): [True: 0, False: 4.30k]
  |  Branch (1883:22): [True: 0, False: 0]
  ------------------
 1884|  4.30k|	    if (!d->active) break;
  ------------------
  |  Branch (1884:10): [True: 0, False: 4.30k]
  ------------------
 1885|  4.30k|	} // for(i in 1:tlen)
 1886|  4.30k|	if(need_c  ) print2buff(")", d);
  ------------------
  |  Branch (1886:5): [True: 0, False: 4.30k]
  ------------------
 1887|  4.30k|	if(surround) print2buff(")", d);
  ------------------
  |  Branch (1887:5): [True: 0, False: 4.30k]
  ------------------
 1888|  4.30k|    }
 1889|  4.55k|    if(attr >= STRUC_ATTR) attr2(vector, d, (attr == STRUC_ATTR));
  ------------------
  |  Branch (1889:8): [True: 0, False: 4.55k]
  ------------------
 1890|  4.55k|    if (STR_names) d->opts = d_opts_in;
  ------------------
  |  Branch (1890:9): [True: 0, False: 4.55k]
  ------------------
 1891|  4.55k|    UNPROTECT(1); /* nv */
  ------------------
  |  |  358|  4.55k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1892|  4.55k|} // vector2buff()
deparse.c:writeline:
 1575|  2.82k|{
 1576|  2.82k|    if (d->strvec != R_NilValue && d->linenumber < d->maxlines)
  ------------------
  |  Branch (1576:9): [True: 2.36k, False: 452]
  |  Branch (1576:36): [True: 2.36k, False: 8]
  ------------------
 1577|  2.36k|	SET_STRING_ELT(d->strvec, d->linenumber, mkChar(d->buffer.data));
  ------------------
  |  |  998|  2.36k|#define mkChar			Rf_mkChar
  ------------------
 1578|  2.82k|    d->linenumber++;
 1579|  2.82k|    if (d->linenumber >= d->maxlines) d->active = false;
  ------------------
  |  Branch (1579:9): [True: 1.91k, False: 904]
  ------------------
 1580|       |    /* reset */
 1581|  2.82k|    d->len = 0;
 1582|  2.82k|    d->buffer.data[0] = '\0';
 1583|  2.82k|    d->startline = true;
 1584|  2.82k|}

Rf_NoDevices:
  117|  1.91k|{
  118|  1.91k|    return (R_NumDevices == 1 || R_CurrentDevice == 0);
  ------------------
  |  Branch (118:13): [True: 1.91k, False: 0]
  |  Branch (118:34): [True: 0, False: 0]
  ------------------
  119|  1.91k|}
GEgetDevice:
  175|  20.3k|{
  176|  20.3k|    return R_Devices[i];
  177|  20.3k|}
Rf_InitGraphics:
  684|      2|{
  685|      2|    R_Devices[0] = &nullDevice;
  686|      2|    active[0] = TRUE;
  687|       |    // these are static arrays, not really needed
  688|    128|    for (int i = 1; i < R_MaxDevices; i++) {
  ------------------
  |  | 2390|    128|#define R_MaxDevices 64
  ------------------
  |  Branch (688:21): [True: 126, False: 2]
  ------------------
  689|    126|	R_Devices[i] = NULL;
  690|    126|	active[i] = FALSE;
  691|    126|    }
  692|       |
  693|       |    /* init .Device and .Devices */
  694|      2|    SEXP s = PROTECT(mkString("null device"));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
  695|      2|    gsetVar(R_DeviceSymbol, s, R_BaseEnv);
  ------------------
  |  |  932|      2|#define gsetVar			Rf_gsetVar
  ------------------
  696|      2|    s = PROTECT(mkString("null device"));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
  697|      2|    gsetVar(R_DevicesSymbol, CONS(s, R_NilValue), R_BaseEnv);
  ------------------
  |  |  932|      2|#define gsetVar			Rf_gsetVar
  ------------------
                  gsetVar(R_DevicesSymbol, CONS(s, R_NilValue), R_BaseEnv);
  ------------------
  |  |  309|      2|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  698|      2|    UNPROTECT(2);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  699|      2|}

R_dotCallFn:
  179|  4.77k|DL_FUNC R_dotCallFn(SEXP op, SEXP call, int nargs) {
  180|  4.77k|    R_RegisteredNativeSymbol symbol = {R_CALL_SYM, {NULL}, NULL};
  181|  4.77k|    DL_FUNC fun = NULL;
  182|  4.77k|    checkValidSymbolId(op, call, &fun, &symbol, NULL);
  183|       |    /* should check arg count here as well */
  184|  4.77k|    return fun;
  185|  4.77k|}
do_External:
  547|      4|{
  548|      4|    DL_FUNC ofun = NULL;
  549|      4|    SEXP retval;
  550|      4|    R_RegisteredNativeSymbol symbol = {R_EXTERNAL_SYM, {NULL}, NULL};
  551|      4|    const void *vmax = vmaxget();
  552|      4|    char buf[MaxSymbolBytes];
  553|       |
  554|      4|    if (length(args) < 1) errorcall(call, _("'.NAME' is missing"));
  ------------------
  |  |  987|      4|#define length(x)		Rf_length(x)
  ------------------
                  if (length(args) < 1) errorcall(call, _("'.NAME' is missing"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
                  if (length(args) < 1) errorcall(call, _("'.NAME' is missing"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (554:9): [True: 0, False: 4]
  ------------------
  555|      4|    check1arg2(args, call, ".NAME");
  556|      4|    args = resolveNativeRoutine(args, &ofun, &symbol, buf, NULL, NULL,
  557|      4|				call, env);
  558|       |
  559|      4|    if(symbol.symbol.external && symbol.symbol.external->numArgs > -1) {
  ------------------
  |  Branch (559:8): [True: 4, False: 0]
  |  Branch (559:34): [True: 4, False: 0]
  ------------------
  560|      4|	int nargs = length(args) - 1;
  ------------------
  |  |  987|      4|#define length(x)		Rf_length(x)
  ------------------
  561|      4|	if(symbol.symbol.external->numArgs != nargs)
  ------------------
  |  Branch (561:5): [True: 0, False: 4]
  ------------------
  562|      0|	    errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  563|      0|		      _("Incorrect number of arguments (%d), expecting %d for '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  564|      0|		      nargs, symbol.symbol.external->numArgs, buf);
  565|      4|    }
  566|       |
  567|       |    /* args is escaping into user C code and might get captured, so
  568|       |       make sure it is reference counting. */
  569|      4|    R_args_enable_refcnt(args);
  570|       |
  571|      4|    if (PRIMVAL(op) == 1) {
  ------------------
  |  | 1347|      4|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (571:9): [True: 0, False: 4]
  ------------------
  572|      0|	R_ExternalRoutine2 fun = (R_ExternalRoutine2) ofun;
  573|      0|	retval = fun(call, op, args, env);
  574|      4|    } else {
  575|      4|	R_ExternalRoutine fun = (R_ExternalRoutine) ofun;
  576|      4|	retval = fun(args);
  577|      4|    }
  578|       |
  579|      4|    R_try_clear_args_refcnt(args);
  580|       |
  581|      4|    vmaxset(vmax);
  582|      4|    return check_retval(call, retval);
  583|      4|}
R_doDotCall:
  747|  4.77k|				  SEXP call) {
  748|  4.77k|    SEXP retval = R_NilValue;	/* -Wall */
  749|  4.77k|    switch (nargs) {
  750|      2|    case 0:
  ------------------
  |  Branch (750:5): [True: 2, False: 4.77k]
  ------------------
  751|      2|	retval = ((FUNS0)fun)();
  752|      2|	break;
  753|      8|    case 1:
  ------------------
  |  Branch (753:5): [True: 8, False: 4.76k]
  ------------------
  754|      8|	retval = ((FUNS1)fun)(cargs[0]);
  755|      8|	break;
  756|  4.76k|    case 2:
  ------------------
  |  Branch (756:5): [True: 4.76k, False: 12]
  ------------------
  757|  4.76k|	retval = ((FUNS2)fun)(cargs[0], cargs[1]);
  758|  4.76k|	break;
  759|      0|    case 3:
  ------------------
  |  Branch (759:5): [True: 0, False: 4.77k]
  ------------------
  760|      0|	retval = ((FUNS3)fun)(cargs[0], cargs[1], cargs[2]);
  761|      0|	break;
  762|      0|    case 4:
  ------------------
  |  Branch (762:5): [True: 0, False: 4.77k]
  ------------------
  763|      0|	retval = ((FUNS4)fun)(cargs[0], cargs[1], cargs[2], cargs[3]);
  764|      0|	break;
  765|      2|    case 5:
  ------------------
  |  Branch (765:5): [True: 2, False: 4.77k]
  ------------------
  766|      2|	retval = ((FUNS5)fun)(
  767|      2|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4]);
  768|      2|	break;
  769|      0|    case 6:
  ------------------
  |  Branch (769:5): [True: 0, False: 4.77k]
  ------------------
  770|      0|	retval = ((FUNS6)fun)(
  771|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  772|      0|	    cargs[5]);
  773|      0|	break;
  774|      0|    case 7:
  ------------------
  |  Branch (774:5): [True: 0, False: 4.77k]
  ------------------
  775|      0|	retval = ((FUNS7)fun)(
  776|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  777|      0|	    cargs[5],  cargs[6]);
  778|      0|	break;
  779|      0|    case 8:
  ------------------
  |  Branch (779:5): [True: 0, False: 4.77k]
  ------------------
  780|      0|	retval = ((FUNS8)fun)(
  781|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  782|      0|	    cargs[5],  cargs[6],  cargs[7]);
  783|      0|	break;
  784|      0|    case 9:
  ------------------
  |  Branch (784:5): [True: 0, False: 4.77k]
  ------------------
  785|      0|	retval = ((FUNS9)fun)(
  786|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  787|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8]);
  788|      0|	break;
  789|      0|    case 10:
  ------------------
  |  Branch (789:5): [True: 0, False: 4.77k]
  ------------------
  790|      0|	retval = ((FUNS10)fun)(
  791|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  792|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9]);
  793|      0|	break;
  794|      0|    case 11:
  ------------------
  |  Branch (794:5): [True: 0, False: 4.77k]
  ------------------
  795|      0|	retval = ((FUNS11)fun)(
  796|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  797|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  798|      0|	    cargs[10]);
  799|      0|	break;
  800|      0|    case 12:
  ------------------
  |  Branch (800:5): [True: 0, False: 4.77k]
  ------------------
  801|      0|	retval = ((FUNS12)fun)(
  802|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  803|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  804|      0|	    cargs[10], cargs[11]);
  805|      0|	break;
  806|      0|    case 13:
  ------------------
  |  Branch (806:5): [True: 0, False: 4.77k]
  ------------------
  807|      0|	retval = ((FUNS13)fun)(
  808|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  809|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  810|      0|	    cargs[10], cargs[11], cargs[12]);
  811|      0|	break;
  812|      0|    case 14:
  ------------------
  |  Branch (812:5): [True: 0, False: 4.77k]
  ------------------
  813|      0|	retval = ((FUNS14)fun)(
  814|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  815|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  816|      0|	    cargs[10], cargs[11], cargs[12], cargs[13]);
  817|      0|	break;
  818|      0|    case 15:
  ------------------
  |  Branch (818:5): [True: 0, False: 4.77k]
  ------------------
  819|      0|	retval = ((FUNS15)fun)(
  820|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  821|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  822|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14]);
  823|      0|	break;
  824|      0|    case 16:
  ------------------
  |  Branch (824:5): [True: 0, False: 4.77k]
  ------------------
  825|      0|	retval = ((FUNS16)fun)(
  826|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  827|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  828|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  829|      0|	    cargs[15]);
  830|      0|	break;
  831|      0|    case 17:
  ------------------
  |  Branch (831:5): [True: 0, False: 4.77k]
  ------------------
  832|      0|	retval = ((FUNS17)fun)(
  833|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  834|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  835|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  836|      0|	    cargs[15], cargs[16]);
  837|      0|	break;
  838|      0|    case 18:
  ------------------
  |  Branch (838:5): [True: 0, False: 4.77k]
  ------------------
  839|      0|	retval = ((FUNS18)fun)(
  840|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  841|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  842|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  843|      0|	    cargs[15], cargs[16], cargs[17]);
  844|      0|	break;
  845|      0|    case 19:
  ------------------
  |  Branch (845:5): [True: 0, False: 4.77k]
  ------------------
  846|      0|	retval = ((FUNS19)fun)(
  847|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  848|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  849|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  850|      0|	    cargs[15], cargs[16], cargs[17], cargs[18]);
  851|      0|	break;
  852|      0|    case 20:
  ------------------
  |  Branch (852:5): [True: 0, False: 4.77k]
  ------------------
  853|      0|	retval = ((FUNS20)fun)(
  854|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  855|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  856|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  857|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19]);
  858|      0|	break;
  859|      0|    case 21:
  ------------------
  |  Branch (859:5): [True: 0, False: 4.77k]
  ------------------
  860|      0|	retval = ((FUNS21)fun)(
  861|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  862|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  863|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  864|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  865|      0|	    cargs[20]);
  866|      0|	break;
  867|      0|    case 22:
  ------------------
  |  Branch (867:5): [True: 0, False: 4.77k]
  ------------------
  868|      0|	retval = ((FUNS22)fun)(
  869|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  870|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  871|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  872|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  873|      0|	    cargs[20], cargs[21]);
  874|      0|	break;
  875|      0|    case 23:
  ------------------
  |  Branch (875:5): [True: 0, False: 4.77k]
  ------------------
  876|      0|	retval = ((FUNS23)fun)(
  877|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  878|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  879|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  880|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  881|      0|	    cargs[20], cargs[21], cargs[22]);
  882|      0|	break;
  883|      0|    case 24:
  ------------------
  |  Branch (883:5): [True: 0, False: 4.77k]
  ------------------
  884|      0|	retval = ((FUNS24)fun)(
  885|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  886|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  887|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  888|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  889|      0|	    cargs[20], cargs[21], cargs[22], cargs[23]);
  890|      0|	break;
  891|      0|    case 25:
  ------------------
  |  Branch (891:5): [True: 0, False: 4.77k]
  ------------------
  892|      0|	retval = ((FUNS25)fun)(
  893|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  894|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  895|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  896|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  897|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24]);
  898|      0|	break;
  899|      0|    case 26:
  ------------------
  |  Branch (899:5): [True: 0, False: 4.77k]
  ------------------
  900|      0|	retval = ((FUNS26)fun)(
  901|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  902|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  903|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  904|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  905|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
  906|      0|	    cargs[25]);
  907|      0|	break;
  908|      0|    case 27:
  ------------------
  |  Branch (908:5): [True: 0, False: 4.77k]
  ------------------
  909|      0|	retval = ((FUNS27)fun)(
  910|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  911|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  912|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  913|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  914|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
  915|      0|	    cargs[25], cargs[26]);
  916|      0|	break;
  917|      0|    case 28:
  ------------------
  |  Branch (917:5): [True: 0, False: 4.77k]
  ------------------
  918|      0|	retval = ((FUNS28)fun)(
  919|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  920|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  921|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  922|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  923|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
  924|      0|	    cargs[25], cargs[26], cargs[27]);
  925|      0|	break;
  926|      0|    case 29:
  ------------------
  |  Branch (926:5): [True: 0, False: 4.77k]
  ------------------
  927|      0|	retval = ((FUNS29)fun)(
  928|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  929|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  930|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  931|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  932|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
  933|      0|	    cargs[25], cargs[26], cargs[27], cargs[28]);
  934|      0|	break;
  935|      0|    case 30:
  ------------------
  |  Branch (935:5): [True: 0, False: 4.77k]
  ------------------
  936|      0|	retval = ((FUNS30)fun)(
  937|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  938|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  939|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  940|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  941|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
  942|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29]);
  943|      0|	break;
  944|      0|    case 31:
  ------------------
  |  Branch (944:5): [True: 0, False: 4.77k]
  ------------------
  945|      0|	retval = ((FUNS31)fun)(
  946|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  947|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  948|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  949|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  950|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
  951|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
  952|      0|	    cargs[30]);
  953|      0|	break;
  954|      0|    case 32:
  ------------------
  |  Branch (954:5): [True: 0, False: 4.77k]
  ------------------
  955|      0|	retval = ((FUNS32)fun)(
  956|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  957|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  958|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  959|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  960|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
  961|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
  962|      0|	    cargs[30], cargs[31]);
  963|      0|	break;
  964|      0|    case 33:
  ------------------
  |  Branch (964:5): [True: 0, False: 4.77k]
  ------------------
  965|      0|	retval = ((FUNS33)fun)(
  966|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  967|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  968|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  969|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  970|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
  971|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
  972|      0|	    cargs[30], cargs[31], cargs[32]);
  973|      0|	break;
  974|      0|    case 34:
  ------------------
  |  Branch (974:5): [True: 0, False: 4.77k]
  ------------------
  975|      0|	retval = ((FUNS34)fun)(
  976|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  977|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  978|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  979|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  980|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
  981|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
  982|      0|	    cargs[30], cargs[31], cargs[32], cargs[33]);
  983|      0|	break;
  984|      0|    case 35:
  ------------------
  |  Branch (984:5): [True: 0, False: 4.77k]
  ------------------
  985|      0|	retval = ((FUNS35)fun)(
  986|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  987|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  988|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  989|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
  990|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
  991|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
  992|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34]);
  993|      0|	break;
  994|      0|    case 36:
  ------------------
  |  Branch (994:5): [True: 0, False: 4.77k]
  ------------------
  995|      0|	retval = ((FUNS36)fun)(
  996|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
  997|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
  998|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
  999|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1000|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1001|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1002|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1003|      0|	    cargs[35]);
 1004|      0|	break;
 1005|      0|    case 37:
  ------------------
  |  Branch (1005:5): [True: 0, False: 4.77k]
  ------------------
 1006|      0|	retval = ((FUNS37)fun)(
 1007|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1008|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1009|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1010|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1011|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1012|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1013|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1014|      0|	    cargs[35], cargs[36]);
 1015|      0|	break;
 1016|      0|    case 38:
  ------------------
  |  Branch (1016:5): [True: 0, False: 4.77k]
  ------------------
 1017|      0|	retval = ((FUNS38)fun)(
 1018|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1019|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1020|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1021|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1022|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1023|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1024|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1025|      0|	    cargs[35], cargs[36], cargs[37]);
 1026|      0|	break;
 1027|      0|    case 39:
  ------------------
  |  Branch (1027:5): [True: 0, False: 4.77k]
  ------------------
 1028|      0|	retval = ((FUNS39)fun)(
 1029|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1030|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1031|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1032|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1033|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1034|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1035|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1036|      0|	    cargs[35], cargs[36], cargs[37], cargs[38]);
 1037|      0|	break;
 1038|      0|    case 40:
  ------------------
  |  Branch (1038:5): [True: 0, False: 4.77k]
  ------------------
 1039|      0|	retval = ((FUNS40)fun)(
 1040|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1041|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1042|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1043|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1044|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1045|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1046|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1047|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39]);
 1048|      0|	break;
 1049|      0|    case 41:
  ------------------
  |  Branch (1049:5): [True: 0, False: 4.77k]
  ------------------
 1050|      0|	retval = ((FUNS41)fun)(
 1051|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1052|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1053|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1054|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1055|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1056|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1057|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1058|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1059|      0|	    cargs[40]);
 1060|      0|	break;
 1061|      0|    case 42:
  ------------------
  |  Branch (1061:5): [True: 0, False: 4.77k]
  ------------------
 1062|      0|	retval = ((FUNS42)fun)(
 1063|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1064|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1065|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1066|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1067|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1068|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1069|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1070|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1071|      0|	    cargs[40], cargs[41]);
 1072|      0|	break;
 1073|      0|    case 43:
  ------------------
  |  Branch (1073:5): [True: 0, False: 4.77k]
  ------------------
 1074|      0|	retval = ((FUNS43)fun)(
 1075|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1076|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1077|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1078|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1079|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1080|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1081|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1082|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1083|      0|	    cargs[40], cargs[41], cargs[42]);
 1084|      0|	break;
 1085|      0|    case 44:
  ------------------
  |  Branch (1085:5): [True: 0, False: 4.77k]
  ------------------
 1086|      0|	retval = ((FUNS44)fun)(
 1087|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1088|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1089|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1090|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1091|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1092|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1093|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1094|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1095|      0|	    cargs[40], cargs[41], cargs[42], cargs[43]);
 1096|      0|	break;
 1097|      0|    case 45:
  ------------------
  |  Branch (1097:5): [True: 0, False: 4.77k]
  ------------------
 1098|      0|	retval = ((FUNS45)fun)(
 1099|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1100|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1101|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1102|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1103|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1104|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1105|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1106|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1107|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44]);
 1108|      0|	break;
 1109|      0|    case 46:
  ------------------
  |  Branch (1109:5): [True: 0, False: 4.77k]
  ------------------
 1110|      0|	retval = ((FUNS46)fun)(
 1111|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1112|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1113|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1114|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1115|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1116|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1117|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1118|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1119|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1120|      0|	    cargs[45]);
 1121|      0|	break;
 1122|      0|    case 47:
  ------------------
  |  Branch (1122:5): [True: 0, False: 4.77k]
  ------------------
 1123|      0|	retval = ((FUNS47)fun)(
 1124|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1125|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1126|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1127|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1128|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1129|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1130|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1131|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1132|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1133|      0|	    cargs[45], cargs[46]);
 1134|      0|	break;
 1135|      0|    case 48:
  ------------------
  |  Branch (1135:5): [True: 0, False: 4.77k]
  ------------------
 1136|      0|	retval = ((FUNS48)fun)(
 1137|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1138|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1139|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1140|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1141|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1142|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1143|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1144|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1145|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1146|      0|	    cargs[45], cargs[46], cargs[47]);
 1147|      0|	break;
 1148|      0|    case 49:
  ------------------
  |  Branch (1148:5): [True: 0, False: 4.77k]
  ------------------
 1149|      0|	retval = ((FUNS49)fun)(
 1150|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1151|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1152|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1153|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1154|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1155|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1156|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1157|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1158|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1159|      0|	    cargs[45], cargs[46], cargs[47], cargs[48]);
 1160|      0|	break;
 1161|      0|    case 50:
  ------------------
  |  Branch (1161:5): [True: 0, False: 4.77k]
  ------------------
 1162|      0|	retval = ((FUNS50)fun)(
 1163|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1164|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1165|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1166|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1167|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1168|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1169|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1170|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1171|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1172|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49]);
 1173|      0|	break;
 1174|      0|    case 51:
  ------------------
  |  Branch (1174:5): [True: 0, False: 4.77k]
  ------------------
 1175|      0|	retval = ((FUNS51)fun)(
 1176|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1177|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1178|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1179|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1180|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1181|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1182|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1183|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1184|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1185|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1186|      0|	    cargs[50]);
 1187|      0|	break;
 1188|      0|    case 52:
  ------------------
  |  Branch (1188:5): [True: 0, False: 4.77k]
  ------------------
 1189|      0|	retval = ((FUNS52)fun)(
 1190|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1191|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1192|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1193|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1194|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1195|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1196|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1197|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1198|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1199|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1200|      0|	    cargs[50], cargs[51]);
 1201|      0|	break;
 1202|      0|    case 53:
  ------------------
  |  Branch (1202:5): [True: 0, False: 4.77k]
  ------------------
 1203|      0|	retval = ((FUNS53)fun)(
 1204|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1205|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1206|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1207|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1208|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1209|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1210|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1211|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1212|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1213|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1214|      0|	    cargs[50], cargs[51], cargs[52]);
 1215|      0|	break;
 1216|      0|    case 54:
  ------------------
  |  Branch (1216:5): [True: 0, False: 4.77k]
  ------------------
 1217|      0|	retval = ((FUNS54)fun)(
 1218|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1219|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1220|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1221|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1222|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1223|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1224|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1225|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1226|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1227|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1228|      0|	    cargs[50], cargs[51], cargs[52], cargs[53]);
 1229|      0|	break;
 1230|      0|    case 55:
  ------------------
  |  Branch (1230:5): [True: 0, False: 4.77k]
  ------------------
 1231|      0|	retval = ((FUNS55)fun)(
 1232|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1233|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1234|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1235|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1236|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1237|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1238|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1239|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1240|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1241|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1242|      0|	    cargs[50], cargs[51], cargs[52], cargs[53], cargs[54]);
 1243|      0|	break;
 1244|      0|    case 56:
  ------------------
  |  Branch (1244:5): [True: 0, False: 4.77k]
  ------------------
 1245|      0|	retval = ((FUNS56)fun)(
 1246|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1247|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1248|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1249|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1250|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1251|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1252|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1253|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1254|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1255|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1256|      0|	    cargs[50], cargs[51], cargs[52], cargs[53], cargs[54],
 1257|      0|	    cargs[55]);
 1258|      0|	break;
 1259|      0|    case 57:
  ------------------
  |  Branch (1259:5): [True: 0, False: 4.77k]
  ------------------
 1260|      0|	retval = ((FUNS57)fun)(
 1261|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1262|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1263|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1264|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1265|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1266|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1267|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1268|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1269|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1270|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1271|      0|	    cargs[50], cargs[51], cargs[52], cargs[53], cargs[54],
 1272|      0|	    cargs[55], cargs[56]);
 1273|      0|	break;
 1274|      0|    case 58:
  ------------------
  |  Branch (1274:5): [True: 0, False: 4.77k]
  ------------------
 1275|      0|	retval = ((FUNS58)fun)(
 1276|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1277|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1278|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1279|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1280|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1281|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1282|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1283|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1284|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1285|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1286|      0|	    cargs[50], cargs[51], cargs[52], cargs[53], cargs[54],
 1287|      0|	    cargs[55], cargs[56], cargs[57]);
 1288|      0|	break;
 1289|      0|    case 59:
  ------------------
  |  Branch (1289:5): [True: 0, False: 4.77k]
  ------------------
 1290|      0|	retval = ((FUNS59)fun)(
 1291|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1292|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1293|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1294|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1295|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1296|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1297|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1298|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1299|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1300|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1301|      0|	    cargs[50], cargs[51], cargs[52], cargs[53], cargs[54],
 1302|      0|	    cargs[55], cargs[56], cargs[57], cargs[58]);
 1303|      0|	break;
 1304|      0|    case 60:
  ------------------
  |  Branch (1304:5): [True: 0, False: 4.77k]
  ------------------
 1305|      0|	retval = ((FUNS60)fun)(
 1306|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1307|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1308|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1309|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1310|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1311|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1312|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1313|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1314|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1315|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1316|      0|	    cargs[50], cargs[51], cargs[52], cargs[53], cargs[54],
 1317|      0|	    cargs[55], cargs[56], cargs[57], cargs[58], cargs[59]);
 1318|      0|	break;
 1319|      0|    case 61:
  ------------------
  |  Branch (1319:5): [True: 0, False: 4.77k]
  ------------------
 1320|      0|	retval = ((FUNS61)fun)(
 1321|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1322|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1323|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1324|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1325|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1326|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1327|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1328|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1329|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1330|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1331|      0|	    cargs[50], cargs[51], cargs[52], cargs[53], cargs[54],
 1332|      0|	    cargs[55], cargs[56], cargs[57], cargs[58], cargs[59],
 1333|      0|	    cargs[60]);
 1334|      0|	break;
 1335|      0|    case 62:
  ------------------
  |  Branch (1335:5): [True: 0, False: 4.77k]
  ------------------
 1336|      0|	retval = ((FUNS62)fun)(
 1337|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1338|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1339|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1340|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1341|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1342|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1343|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1344|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1345|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1346|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1347|      0|	    cargs[50], cargs[51], cargs[52], cargs[53], cargs[54],
 1348|      0|	    cargs[55], cargs[56], cargs[57], cargs[58], cargs[59],
 1349|      0|	    cargs[60], cargs[61]);
 1350|      0|	break;
 1351|      0|    case 63:
  ------------------
  |  Branch (1351:5): [True: 0, False: 4.77k]
  ------------------
 1352|      0|	retval = ((FUNS63)fun)(
 1353|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1354|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1355|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1356|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1357|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1358|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1359|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1360|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1361|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1362|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1363|      0|	    cargs[50], cargs[51], cargs[52], cargs[53], cargs[54],
 1364|      0|	    cargs[55], cargs[56], cargs[57], cargs[58], cargs[59],
 1365|      0|	    cargs[60], cargs[61], cargs[62]);
 1366|      0|	break;
 1367|      0|    case 64:
  ------------------
  |  Branch (1367:5): [True: 0, False: 4.77k]
  ------------------
 1368|      0|	retval = ((FUNS64)fun)(
 1369|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1370|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1371|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1372|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1373|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1374|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1375|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1376|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1377|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1378|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1379|      0|	    cargs[50], cargs[51], cargs[52], cargs[53], cargs[54],
 1380|      0|	    cargs[55], cargs[56], cargs[57], cargs[58], cargs[59],
 1381|      0|	    cargs[60], cargs[61], cargs[62], cargs[63]);
 1382|      0|	break;
 1383|      0|    case 65:
  ------------------
  |  Branch (1383:5): [True: 0, False: 4.77k]
  ------------------
 1384|      0|	retval = ((FUNS65)fun)(
 1385|      0|	    cargs[0],  cargs[1],  cargs[2],  cargs[3],  cargs[4],
 1386|      0|	    cargs[5],  cargs[6],  cargs[7],  cargs[8],  cargs[9],
 1387|      0|	    cargs[10], cargs[11], cargs[12], cargs[13], cargs[14],
 1388|      0|	    cargs[15], cargs[16], cargs[17], cargs[18], cargs[19],
 1389|      0|	    cargs[20], cargs[21], cargs[22], cargs[23], cargs[24],
 1390|      0|	    cargs[25], cargs[26], cargs[27], cargs[28], cargs[29],
 1391|      0|	    cargs[30], cargs[31], cargs[32], cargs[33], cargs[34],
 1392|      0|	    cargs[35], cargs[36], cargs[37], cargs[38], cargs[39],
 1393|      0|	    cargs[40], cargs[41], cargs[42], cargs[43], cargs[44],
 1394|      0|	    cargs[45], cargs[46], cargs[47], cargs[48], cargs[49],
 1395|      0|	    cargs[50], cargs[51], cargs[52], cargs[53], cargs[54],
 1396|      0|	    cargs[55], cargs[56], cargs[57], cargs[58], cargs[59],
 1397|      0|	    cargs[60], cargs[61], cargs[62], cargs[63], cargs[64]);
 1398|      0|	break;
 1399|      0|    default:
  ------------------
  |  Branch (1399:5): [True: 0, False: 4.77k]
  ------------------
 1400|      0|	errorcall(call, _("too many arguments, sorry"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("too many arguments, sorry"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1401|  4.77k|    }
 1402|  4.77k|    return check_retval(call, retval);
 1403|  4.77k|}
dotcode.c:checkValidSymbolId:
  109|  9.55k|{
  110|  9.55k|    if (isValidString(op)) return;
  ------------------
  |  |  972|  9.55k|#define isValidString		Rf_isValidString
  ------------------
  |  Branch (110:9): [True: 0, False: 9.55k]
  ------------------
  111|       |
  112|  9.55k|    if(TYPEOF(op) == EXTPTRSXP) {
  ------------------
  |  |  134|  9.55k|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (112:8): [True: 4.77k, False: 4.77k]
  ------------------
  113|  4.77k|	static SEXP native_symbol = NULL;
  114|  4.77k|	static SEXP registered_native_symbol = NULL;
  115|  4.77k|	if (native_symbol == NULL) {
  ------------------
  |  Branch (115:6): [True: 2, False: 4.77k]
  ------------------
  116|      2|	    native_symbol = install("native symbol");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  117|      2|	    registered_native_symbol = install("registered native symbol");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  118|      2|	}
  119|  4.77k|	char *p = NULL;
  120|  4.77k|	if(R_ExternalPtrTag(op) == native_symbol)
  ------------------
  |  Branch (120:5): [True: 0, False: 4.77k]
  ------------------
  121|      0|	   *fun = R_ExternalPtrAddrFn(op);
  122|  4.77k|	else if(R_ExternalPtrTag(op) == registered_native_symbol) {
  ------------------
  |  Branch (122:10): [True: 4.77k, False: 0]
  ------------------
  123|  4.77k|	   R_RegisteredNativeSymbol *tmp;
  124|  4.77k|	   tmp = (R_RegisteredNativeSymbol *) R_ExternalPtrAddr(op);
  125|  4.77k|	   if(tmp) {
  ------------------
  |  Branch (125:8): [True: 4.77k, False: 0]
  ------------------
  126|  4.77k|	      if(symbol->type != R_ANY_SYM && symbol->type != tmp->type)
  ------------------
  |  Branch (126:11): [True: 4.77k, False: 0]
  |  Branch (126:40): [True: 0, False: 4.77k]
  ------------------
  127|      0|		 errorcall(call, _("NULL value passed as symbol address"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		 errorcall(call, _("NULL value passed as symbol address"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  128|       |		/* Check the type of the symbol. */
  129|  4.77k|	      switch(symbol->type) {
  130|      0|	      case R_C_SYM:
  ------------------
  |  Branch (130:8): [True: 0, False: 4.77k]
  ------------------
  131|      0|		  *fun = tmp->symbol.c->fun;
  132|      0|		  p = tmp->symbol.c->name;
  133|      0|		  break;
  134|  4.77k|	      case R_CALL_SYM:
  ------------------
  |  Branch (134:8): [True: 4.77k, False: 4]
  ------------------
  135|  4.77k|		  *fun = tmp->symbol.call->fun;
  136|  4.77k|		  p = tmp->symbol.call->name;
  137|  4.77k|		  break;
  138|      0|	      case R_FORTRAN_SYM:
  ------------------
  |  Branch (138:8): [True: 0, False: 4.77k]
  ------------------
  139|      0|		  *fun = tmp->symbol.fortran->fun;
  140|      0|		  p = tmp->symbol.fortran->name;
  141|      0|		  break;
  142|      4|	      case R_EXTERNAL_SYM:
  ------------------
  |  Branch (142:8): [True: 4, False: 4.77k]
  ------------------
  143|      4|		  *fun = tmp->symbol.external->fun;
  144|      4|		  p = tmp->symbol.external->name;
  145|      4|		  break;
  146|      0|	      default:
  ------------------
  |  Branch (146:8): [True: 0, False: 4.77k]
  ------------------
  147|       |		 /* Something unintended has happened if we get here. */
  148|      0|		  errorcall(call, _("Unimplemented type %d in createRSymbolObject"),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		  errorcall(call, _("Unimplemented type %d in createRSymbolObject"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  149|      0|			    symbol->type);
  150|      0|		  break;
  151|  4.77k|	      }
  152|  4.77k|	      *symbol = *tmp;
  153|  4.77k|	   }
  154|  4.77k|	}
  155|       |	/* This is illegal C */
  156|  4.77k|	if(*fun == NULL)
  ------------------
  |  Branch (156:5): [True: 0, False: 4.77k]
  ------------------
  157|      0|	    errorcall(call, _("NULL value passed as symbol address"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("NULL value passed as symbol address"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  158|       |
  159|       |	/* copy the symbol name. */
  160|  4.77k|	if (p && buf) {
  ------------------
  |  Branch (160:6): [True: 4.77k, False: 0]
  |  Branch (160:11): [True: 4, False: 4.77k]
  ------------------
  161|      4|	    if (strlen(p) >= MaxSymbolBytes)
  ------------------
  |  |   69|      4|#define MaxSymbolBytes 1024
  ------------------
  |  Branch (161:10): [True: 0, False: 4]
  ------------------
  162|      0|		error(_("symbol '%s' is too long"), p);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("symbol '%s' is too long"), p);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  163|      4|	    memcpy(buf, p, strlen(p)+1);
  164|      4|	}
  165|       |
  166|  4.77k|	return;
  167|  4.77k|    }
  168|  4.77k|    else if(isNativeSymbolInfo(op)) {
  ------------------
  |  Branch (168:13): [True: 4.77k, False: 0]
  ------------------
  169|  4.77k|	checkValidSymbolId(VECTOR_ELT(op, 1), call, fun, symbol, buf);
  170|  4.77k|	return;
  171|  4.77k|    }
  172|       |
  173|      0|    errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  174|       |      _("first argument must be a string (of length 1) or native symbol reference"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  175|      0|    return; /* not reached */
  176|  9.55k|}
dotcode.c:isNativeSymbolInfo:
   83|  4.77k|{
   84|       |    /* was: inherits(op, "NativeSymbolInfo")
   85|       |     * inherits() is slow because of string comparisons, so use
   86|       |     * structural check instead. */
   87|  4.77k|    return (TYPEOF(op) == VECSXP &&
  ------------------
  |  |  131|  9.55k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (87:13): [True: 4.77k, False: 0]
  ------------------
   88|  4.77k|	    LENGTH(op) >= 2 &&
  ------------------
  |  Branch (88:6): [True: 4.77k, False: 0]
  ------------------
   89|  4.77k|	    TYPEOF(VECTOR_ELT(op, 1)) == EXTPTRSXP);
  ------------------
  |  |  134|  4.77k|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (89:6): [True: 4.77k, False: 0]
  ------------------
   90|  4.77k|}
dotcode.c:check1arg2:
   43|      4|{
   44|      4|    if (TAG(arg) == R_NilValue) return;
  ------------------
  |  Branch (44:9): [True: 4, False: 0]
  ------------------
   45|      0|    errorcall(call, "the first argument should not be named");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
   46|      0| }
dotcode.c:resolveNativeRoutine:
  201|      4|{
  202|      4|    SEXP op;
  203|      4|    const char *p; char *q;
  204|      4|    DllReference dll;
  205|       |    /* This is used as shorthand for 'all' in R_FindSymbol, but
  206|       |       should never be supplied */
  207|      4|    strcpy(dll.DLLname, "");
  208|      4|    dll.dll = NULL; dll.obj = NULL; dll.type = NOT_DEFINED;
  209|       |
  210|      4|    op = CAR(args);  // value of .NAME =
  211|       |    /* NB, this sets fun, symbol and buf and is not just a check! */
  212|      4|    checkValidSymbolId(op, call, fun, symbol, buf);
  213|       |
  214|       |    /* The following code modifies the argument list */
  215|       |    /* We know this is ok because do_dotCode is entered */
  216|       |    /* with its arguments evaluated. */
  217|       |
  218|      4|    if(symbol->type == R_C_SYM || symbol->type == R_FORTRAN_SYM) {
  ------------------
  |  Branch (218:8): [True: 0, False: 4]
  |  Branch (218:35): [True: 0, False: 4]
  ------------------
  219|       |	/* And that also looks for PACKAGE = */
  220|      0|	args = naokfind(CDR(args), nargs, naok, &dll);
  221|      0|	if(*naok == NA_LOGICAL)
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (221:5): [True: 0, False: 0]
  ------------------
  222|      0|	    errorcall(call, _("invalid '%s' value"), "naok");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("invalid '%s' value"), "naok");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  223|      0|	if(*nargs > MAX_ARGS)
  ------------------
  |  |   72|      0|#define MAX_ARGS 65
  ------------------
  |  Branch (223:5): [True: 0, False: 0]
  ------------------
  224|      0|	    errorcall(call, _("too many arguments in foreign function call"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("too many arguments in foreign function call"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  225|      4|    } else {
  226|       |	/* This has the side effect of setting dll.type if a PACKAGE=
  227|       |	   argument if found, but it will only be used if a string was
  228|       |	   passed in  */
  229|      4|	args = pkgtrim(args, &dll);
  230|      4|    }
  231|       |
  232|       |    /* We were given a symbol (or an address), so we are done. */
  233|      4|    if (*fun) return args;
  ------------------
  |  Branch (233:9): [True: 4, False: 0]
  ------------------
  234|       |
  235|      0|    if (dll.type == FILENAME && !strlen(dll.DLLname))
  ------------------
  |  Branch (235:9): [True: 0, False: 0]
  |  Branch (235:33): [True: 0, False: 0]
  ------------------
  236|      0|	errorcall(call, _("PACKAGE = \"\" is invalid"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("PACKAGE = \"\" is invalid"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  237|       |
  238|       |    // find if we were called from a namespace
  239|      0|    SEXP env2 = ENCLOS(env);
  240|      0|    const char *ns = "";
  241|      0|    if(R_IsNamespaceEnv(env2))
  ------------------
  |  Branch (241:8): [True: 0, False: 0]
  ------------------
  242|      0|	ns = CHAR(STRING_ELT(R_NamespaceEnvSpec(env2), 0));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  243|      0|    else env2 = R_NilValue;
  244|       |
  245|       |#ifdef CHECK_CROSS_USAGE
  246|       |    if (dll.type == FILENAME && strcmp(dll.DLLname, "base")) {
  247|       |	if(strlen(ns) && strcmp(dll.DLLname, ns) &&
  248|       |	   !(streql(dll.DLLname, "BioC_graph") && streql(ns, "graph")))
  249|       |	    warningcall(call,
  250|       |			"using PACKAGE = \"%s\" from namespace '%s'",
  251|       |			dll.DLLname, ns);
  252|       |    }
  253|       |#endif
  254|       |
  255|       |    /* Make up the load symbol */
  256|      0|    if(TYPEOF(op) == STRSXP) {
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (256:8): [True: 0, False: 0]
  ------------------
  257|      0|	const void *vmax = vmaxget();
  258|      0|	p = translateChar(STRING_ELT(op, 0));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  259|      0|	if(strlen(p) >= MaxSymbolBytes)
  ------------------
  |  |   69|      0|#define MaxSymbolBytes 1024
  ------------------
  |  Branch (259:5): [True: 0, False: 0]
  ------------------
  260|      0|	    error(_("symbol '%s' is too long"), p);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("symbol '%s' is too long"), p);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  261|      0|	q = buf;
  262|      0|	while ((*q = *p) != '\0') {
  ------------------
  |  Branch (262:9): [True: 0, False: 0]
  ------------------
  263|      0|	    if(symbol->type == R_FORTRAN_SYM) *q = (char) tolower(*q);
  ------------------
  |  Branch (263:9): [True: 0, False: 0]
  |  Branch (263:52): [True: 0, False: 0]
  |  Branch (263:52): [True: 0, False: 0]
  |  Branch (263:52): [Folded, False: 0]
  ------------------
  264|      0|	    p++;
  265|      0|	    q++;
  266|      0|	}
  267|      0|	vmaxset(vmax);
  268|      0|    }
  269|       |
  270|      0|    if(dll.type != FILENAME && strlen(ns)) {
  ------------------
  |  Branch (270:8): [True: 0, False: 0]
  |  Branch (270:32): [True: 0, False: 0]
  ------------------
  271|       |	/* no PACKAGE= arg, so see if we can identify a DLL
  272|       |	   from the namespace defining the function */
  273|      0|	*fun = R_FindNativeSymbolFromDLL(buf, &dll, symbol, env2);
  274|      0|	if (*fun) return args;
  ------------------
  |  Branch (274:6): [True: 0, False: 0]
  ------------------
  275|      0|	errorcall(call, "\"%s\" not resolved from current namespace (%s)",
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  276|      0|		  buf, ns);
  277|      0|    }
  278|       |
  279|       |    /* NB: the actual conversion to the symbol is done in
  280|       |       R_dlsym in Rdynload.c.  That prepends an underscore (usually),
  281|       |       and may append one or more underscores.
  282|       |    */
  283|       |
  284|      0|    *fun = R_FindSymbol(buf, dll.DLLname, symbol);
  285|      0|    if (*fun) return args;
  ------------------
  |  Branch (285:9): [True: 0, False: 0]
  ------------------
  286|       |
  287|       |    /* so we've failed and bail out */
  288|      0|    if(strlen(dll.DLLname)) {
  ------------------
  |  Branch (288:8): [True: 0, False: 0]
  ------------------
  289|      0|	switch(symbol->type) {
  ------------------
  |  Branch (289:9): [True: 0, False: 0]
  ------------------
  290|      0|	case R_C_SYM:
  ------------------
  |  Branch (290:2): [True: 0, False: 0]
  ------------------
  291|      0|	    errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  292|      0|		      _("\"%s\" not available for %s() for package \"%s\""),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  293|      0|		      buf, ".C", dll.DLLname);
  294|      0|	    break;
  295|      0|	case R_FORTRAN_SYM:
  ------------------
  |  Branch (295:2): [True: 0, False: 0]
  ------------------
  296|      0|	    errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  297|      0|		      _("\"%s\" not available for %s() for package \"%s\""),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  298|      0|		      buf, ".Fortran", dll.DLLname);
  299|      0|	    break;
  300|      0|	case R_CALL_SYM:
  ------------------
  |  Branch (300:2): [True: 0, False: 0]
  ------------------
  301|      0|	    errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  302|      0|		      _("\"%s\" not available for %s() for package \"%s\""),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  303|      0|		      buf, ".Call", dll.DLLname);
  304|      0|	    break;
  305|      0|	case R_EXTERNAL_SYM:
  ------------------
  |  Branch (305:2): [True: 0, False: 0]
  ------------------
  306|      0|	    errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  307|      0|		      _("\"%s\" not available for %s() for package \"%s\""),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  308|      0|		      buf, ".External", dll.DLLname);
  309|      0|	    break;
  310|      0|	case R_ANY_SYM:
  ------------------
  |  Branch (310:2): [True: 0, False: 0]
  ------------------
  311|      0|	    errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  312|      0|		      _("%s symbol name \"%s\" not in DLL for package \"%s\""),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  313|      0|		      "C/Fortran", buf, dll.DLLname);
  314|      0|	    break;
  315|      0|	}
  316|      0|    } else
  317|      0|	errorcall(call, _("%s symbol name \"%s\" not in load table"),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("%s symbol name \"%s\" not in load table"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  318|      0|		  symbol->type == R_FORTRAN_SYM ? "Fortran" : "C", buf);
  ------------------
  |  Branch (318:5): [True: 0, False: 0]
  ------------------
  319|       |
  320|      0|    return args; /* -Wall */
  321|      0|}
dotcode.c:pkgtrim:
  432|      4|{
  433|      4|    SEXP s, ss;
  434|      4|    int pkgused = 0;
  435|       |
  436|      4|    if (PkgSymbol == NULL) PkgSymbol = install("PACKAGE");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  |  Branch (436:9): [True: 2, False: 2]
  ------------------
  437|       |
  438|     36|    for(s = args ; s != R_NilValue;) {
  ------------------
  |  Branch (438:20): [True: 32, False: 4]
  ------------------
  439|     32|	ss = CDR(s);
  440|       |	/* Look for PACKAGE=. We look at the next arg, unless
  441|       |	   this is the last one (which will only happen for one arg),
  442|       |	   and remove it */
  443|     32|	if(ss == R_NilValue && TAG(s) == PkgSymbol) {
  ------------------
  |  Branch (443:5): [True: 4, False: 28]
  |  Branch (443:25): [True: 0, False: 4]
  ------------------
  444|      0|	    if(pkgused++ == 1)
  ------------------
  |  Branch (444:9): [True: 0, False: 0]
  ------------------
  445|      0|		warning(_("'%s' used more than once"), "PACKAGE");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		warning(_("'%s' used more than once"), "PACKAGE");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  446|      0|	    setDLLname(s, dll->DLLname);
  447|      0|	    dll->type = FILENAME;
  448|      0|	    return R_NilValue;
  449|      0|	}
  450|     32|	if(TAG(ss) == PkgSymbol) {
  ------------------
  |  Branch (450:5): [True: 0, False: 32]
  ------------------
  451|      0|	    if(pkgused++ == 1)
  ------------------
  |  Branch (451:9): [True: 0, False: 0]
  ------------------
  452|      0|		warning(_("'%s' used more than once"), "PACKAGE");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		warning(_("'%s' used more than once"), "PACKAGE");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  453|      0|	    setDLLname(ss, dll->DLLname);
  454|      0|	    dll->type = FILENAME;
  455|      0|	    SETCDR(s, CDR(ss));
  456|      0|	}
  457|     32|	s = CDR(s);
  458|     32|    }
  459|      4|    return args;
  460|      4|}
dotcode.c:check_retval:
  523|  4.77k|{
  524|  4.77k|    static int inited = FALSE;
  525|  4.77k|    static int check = FALSE;
  526|       |
  527|  4.77k|    if (! inited) {
  ------------------
  |  Branch (527:9): [True: 2, False: 4.77k]
  ------------------
  528|      2|	inited = true;
  529|      2|	const char *p = getenv("_R_CHECK_DOTCODE_RETVAL_");
  530|      2|	if (p != NULL && StringTrue(p))
  ------------------
  |  |   52|      0|#define StringTrue    Rf_StringTrue
  ------------------
  |  Branch (530:6): [True: 0, False: 2]
  |  Branch (530:19): [True: 0, False: 0]
  ------------------
  531|      0|	    check = true;
  532|      2|    }
  533|       |
  534|  4.77k|    if (check) {
  ------------------
  |  Branch (534:9): [True: 0, False: 4.77k]
  ------------------
  535|      0|	if (val < (SEXP) 16)
  ------------------
  |  Branch (535:6): [True: 0, False: 0]
  ------------------
  536|      0|	    errorcall(call, "WEIRD RETURN VALUE: %p", (void *)val);
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  537|      0|    }
  538|  4.77k|    else if (val == NULL) {
  ------------------
  |  Branch (538:14): [True: 0, False: 4.77k]
  ------------------
  539|      0|	warningcall(call, "converting NULL pointer to R NULL");
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
  540|      0|	val = R_NilValue;
  541|      0|    }
  542|       |
  543|  4.77k|    return val;
  544|  4.77k|}

mkPRIMSXP:
   38|  2.35k|{
   39|  2.35k|    SEXP result;
   40|  2.35k|    SEXPTYPE type = eval ? BUILTINSXP : SPECIALSXP;
  ------------------
  |  |  913|  2.35k|#define eval			Rf_eval
  |  |  ------------------
  |  |  |  Branch (913:16): [True: 2.14k, False: 216]
  |  |  ------------------
  ------------------
                  SEXPTYPE type = eval ? BUILTINSXP : SPECIALSXP;
  ------------------
  |  |  119|  2.14k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
                  SEXPTYPE type = eval ? BUILTINSXP : SPECIALSXP;
  ------------------
  |  |  118|  2.57k|#define SPECIALSXP   7	  /* special forms */
  ------------------
   41|  2.35k|    static SEXP PrimCache = NULL;
   42|  2.35k|    static int FunTabSize = 0;
   43|       |    
   44|  2.35k|    if (PrimCache == NULL) {
  ------------------
  |  Branch (44:9): [True: 2, False: 2.35k]
  ------------------
   45|       |	/* compute the number of entries in R_FunTab */
   46|  1.54k|	while (R_FunTab[FunTabSize].name)
  ------------------
  |  Branch (46:9): [True: 1.54k, False: 2]
  ------------------
   47|  1.54k|	    FunTabSize++;
   48|       |
   49|       |	/* allocate and protect the cache */
   50|      2|	PrimCache = allocVector(VECSXP, FunTabSize);
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
              	PrimCache = allocVector(VECSXP, FunTabSize);
  ------------------
  |  |  131|      2|#define VECSXP	    19	  /* generic vectors */
  ------------------
   51|      2|	R_PreserveObject(PrimCache);
   52|      2|    }
   53|       |
   54|  2.35k|    if (offset < 0 || offset >= FunTabSize)
  ------------------
  |  Branch (54:9): [True: 0, False: 2.35k]
  |  Branch (54:23): [True: 0, False: 2.35k]
  ------------------
   55|      0|	error("offset is out of R_FunTab range");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
   56|       |
   57|  2.35k|    result = VECTOR_ELT(PrimCache, offset);
   58|       |
   59|  2.35k|    if (result == R_NilValue) {
  ------------------
  |  Branch (59:9): [True: 1.54k, False: 816]
  ------------------
   60|  1.54k|	result = allocSExp(type);
  ------------------
  |  |  874|  1.54k|#define allocSExp		Rf_allocSExp
  ------------------
   61|  1.54k|	SET_PRIMOFFSET(result, offset);
   62|  1.54k|	SET_VECTOR_ELT(PrimCache, offset, result);
   63|  1.54k|    }
   64|    816|    else if (TYPEOF(result) != type)
  ------------------
  |  Branch (64:14): [True: 0, False: 816]
  ------------------
   65|      0|	error("requested primitive type is not consistent with cached value");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
   66|       |
   67|  2.35k|    return result;
   68|  2.35k|}
Rf_mkCLOSXP:
   79|  3.09M|{
   80|  3.09M|    SEXP c;
   81|  3.09M|    PROTECT(formals);
  ------------------
  |  |  357|  3.09M|#define PROTECT(s)	Rf_protect(s)
  ------------------
   82|  3.09M|    PROTECT(body);
  ------------------
  |  |  357|  3.09M|#define PROTECT(s)	Rf_protect(s)
  ------------------
   83|  3.09M|    PROTECT(rho);
  ------------------
  |  |  357|  3.09M|#define PROTECT(s)	Rf_protect(s)
  ------------------
   84|  3.09M|    c = allocSExp(CLOSXP);
  ------------------
  |  |  874|  3.09M|#define allocSExp		Rf_allocSExp
  ------------------
                  c = allocSExp(CLOSXP);
  ------------------
  |  |  114|  3.09M|#define CLOSXP	     3	  /* closures */
  ------------------
   85|       |
   86|       |#ifdef not_used_CheckFormals
   87|       |    if(isList(formals))
   88|       |	SET_FORMALS(c, formals);
   89|       |    else
   90|       |	error(_("invalid formal arguments for 'function'"));
   91|       |#else
   92|  3.09M|    SET_FORMALS(c, formals);
   93|  3.09M|#endif
   94|  3.09M|    switch (TYPEOF(body)) {
   95|      0|    case CLOSXP:
  ------------------
  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (95:5): [True: 0, False: 3.09M]
  ------------------
   96|      0|    case BUILTINSXP:
  ------------------
  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (96:5): [True: 0, False: 3.09M]
  ------------------
   97|      0|    case SPECIALSXP:
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (97:5): [True: 0, False: 3.09M]
  ------------------
   98|      0|    case DOTSXP:
  ------------------
  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (98:5): [True: 0, False: 3.09M]
  ------------------
   99|      0|    case ANYSXP:
  ------------------
  |  |  128|      0|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
  |  Branch (99:5): [True: 0, False: 3.09M]
  ------------------
  100|      0|	error(_("invalid body argument for 'function'"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid body argument for 'function'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  101|      0|	break;
  102|  3.09M|    default:
  ------------------
  |  Branch (102:5): [True: 3.09M, False: 0]
  ------------------
  103|  3.09M|	SET_BODY(c, body);
  104|  3.09M|	break;
  105|  3.09M|    }
  106|       |
  107|  3.09M|    if(rho == R_NilValue)
  ------------------
  |  Branch (107:8): [True: 0, False: 3.09M]
  ------------------
  108|      0|	SET_CLOENV(c, R_GlobalEnv);
  109|  3.09M|    else
  110|  3.09M|	SET_CLOENV(c, rho);
  111|  3.09M|    UNPROTECT(3);
  ------------------
  |  |  358|  3.09M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  112|  3.09M|    return c;
  113|  3.09M|}
Rf_mkSYMSXP:
  148|  14.1k|{
  149|  14.1k|    SEXP c;
  150|  14.1k|    int i;
  151|  14.1k|    PROTECT(name);
  ------------------
  |  |  357|  14.1k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  152|  14.1k|    PROTECT(value);
  ------------------
  |  |  357|  14.1k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  153|  14.1k|    i = isDDName(name);
  154|  14.1k|    c = allocSExp(SYMSXP);
  ------------------
  |  |  874|  14.1k|#define allocSExp		Rf_allocSExp
  ------------------
                  c = allocSExp(SYMSXP);
  ------------------
  |  |  112|  14.1k|#define SYMSXP	     1	  /* symbols */
  ------------------
  155|  14.1k|    SET_PRINTNAME(c, name);
  156|  14.1k|    SET_SYMVALUE(c, value);
  157|  14.1k|    SET_DDVAL(c, i);
  158|  14.1k|    UNPROTECT(2);
  ------------------
  |  |  358|  14.1k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  159|  14.1k|    return c;
  160|  14.1k|}
dstruct.c:isDDName:
  130|  14.1k|{
  131|  14.1k|    const char *buf;
  132|  14.1k|    char *endp;
  133|       |
  134|  14.1k|    buf = CHAR(name);
  ------------------
  |  |  203|  14.1k|#define CHAR(x) R_CHAR(x)
  ------------------
  135|  14.1k|    if( !strncmp(buf, "..", 2) && strlen(buf) > 2 ) {
  ------------------
  |  Branch (135:9): [True: 146, False: 13.9k]
  |  Branch (135:35): [True: 146, False: 0]
  ------------------
  136|    146|	buf += 2;
  137|    146|	strtol(buf, &endp, 10); // discard value
  138|    146|	if( *endp != '\0')
  ------------------
  |  Branch (138:6): [True: 16, False: 130]
  ------------------
  139|     16|	    return 0;
  140|    130|	else
  141|    130|	    return 1;
  142|    146|    }
  143|  13.9k|    return 0;
  144|  14.1k|}

Rf_duplicate:
  135|  2.33M|SEXP duplicate(SEXP s){
  136|  2.33M|    SEXP t;
  137|       |
  138|  2.33M|#ifdef R_PROFILING
  139|  2.33M|    duplicate_counter++;
  140|  2.33M|#endif
  141|  2.33M|    t = duplicate1(s, TRUE);
  142|       |#ifdef R_MEMORY_PROFILING
  143|       |    if (RTRACE(s) && !(TYPEOF(s) == CLOSXP || TYPEOF(s) == BUILTINSXP ||
  144|       |		      TYPEOF(s) == SPECIALSXP || TYPEOF(s) == PROMSXP ||
  145|       |		      TYPEOF(s) == ENVSXP)){
  146|       |	    memtrace_report(s,t);
  147|       |	    SET_RTRACE(t,1);
  148|       |    }
  149|       |#endif
  150|  2.33M|    return t;
  151|  2.33M|}
Rf_shallow_duplicate:
  154|  2.70M|{
  155|  2.70M|    SEXP t;
  156|       |
  157|  2.70M|#ifdef R_PROFILING
  158|  2.70M|    duplicate_counter++;
  159|  2.70M|#endif
  160|  2.70M|    t = duplicate1(s, FALSE);
  161|       |#ifdef R_MEMORY_PROFILING
  162|       |    if (RTRACE(s) && !(TYPEOF(s) == CLOSXP || TYPEOF(s) == BUILTINSXP ||
  163|       |		      TYPEOF(s) == SPECIALSXP || TYPEOF(s) == PROMSXP ||
  164|       |		      TYPEOF(s) == ENVSXP)){
  165|       |	    memtrace_report(s,t);
  166|       |	    SET_RTRACE(t,1);
  167|       |    }
  168|       |#endif
  169|  2.70M|    return t;
  170|  2.70M|}
Rf_lazy_duplicate:
  173|  11.5M|SEXP lazy_duplicate(SEXP s) {
  174|  11.5M|    switch (TYPEOF(s)) {
  175|  1.54M|    case NILSXP:
  ------------------
  |  |  111|  1.54M|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (175:5): [True: 1.54M, False: 10.0M]
  ------------------
  176|  3.85M|    case SYMSXP:
  ------------------
  |  |  112|  3.85M|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (176:5): [True: 2.31M, False: 9.26M]
  ------------------
  177|  3.85M|    case ENVSXP:
  ------------------
  |  |  115|  3.85M|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (177:5): [True: 350, False: 11.5M]
  ------------------
  178|  3.85M|    case SPECIALSXP:
  ------------------
  |  |  118|  3.85M|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (178:5): [True: 48, False: 11.5M]
  ------------------
  179|  3.86M|    case BUILTINSXP:
  ------------------
  |  |  119|  3.86M|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (179:5): [True: 300, False: 11.5M]
  ------------------
  180|  3.86M|    case EXTPTRSXP:
  ------------------
  |  |  134|  3.86M|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (180:5): [True: 0, False: 11.5M]
  ------------------
  181|  3.86M|    case BCODESXP:
  ------------------
  |  |  133|  3.86M|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (181:5): [True: 0, False: 11.5M]
  ------------------
  182|  3.86M|    case WEAKREFSXP:
  ------------------
  |  |  135|  3.86M|#define WEAKREFSXP  23    /* weak reference */
  ------------------
  |  Branch (182:5): [True: 0, False: 11.5M]
  ------------------
  183|  3.86M|    case CHARSXP:
  ------------------
  |  |  120|  3.86M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (183:5): [True: 0, False: 11.5M]
  ------------------
  184|  3.86M|    case PROMSXP:
  ------------------
  |  |  116|  3.86M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (184:5): [True: 86, False: 11.5M]
  ------------------
  185|  3.86M|	break;
  186|  1.54M|    case CLOSXP:
  ------------------
  |  |  114|  1.54M|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (186:5): [True: 1.54M, False: 10.0M]
  ------------------
  187|  1.54M|    case LISTSXP:
  ------------------
  |  |  113|  1.54M|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (187:5): [True: 0, False: 11.5M]
  ------------------
  188|  2.70M|    case LANGSXP:
  ------------------
  |  |  117|  2.70M|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (188:5): [True: 1.15M, False: 10.4M]
  ------------------
  189|  2.70M|    case DOTSXP:
  ------------------
  |  |  127|  2.70M|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (189:5): [True: 0, False: 11.5M]
  ------------------
  190|  2.70M|    case EXPRSXP:
  ------------------
  |  |  132|  2.70M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (190:5): [True: 0, False: 11.5M]
  ------------------
  191|  2.70M|    case VECSXP:
  ------------------
  |  |  131|  2.70M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (191:5): [True: 676, False: 11.5M]
  ------------------
  192|  2.70M|    case LGLSXP:
  ------------------
  |  |  121|  2.70M|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (192:5): [True: 348, False: 11.5M]
  ------------------
  193|  2.70M|    case INTSXP:
  ------------------
  |  |  123|  2.70M|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (193:5): [True: 2.38k, False: 11.5M]
  ------------------
  194|  2.70M|    case REALSXP:
  ------------------
  |  |  124|  2.70M|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (194:5): [True: 316, False: 11.5M]
  ------------------
  195|  2.70M|    case CPLXSXP:
  ------------------
  |  |  125|  2.70M|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (195:5): [True: 0, False: 11.5M]
  ------------------
  196|  2.70M|    case RAWSXP:
  ------------------
  |  |  136|  2.70M|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (196:5): [True: 34, False: 11.5M]
  ------------------
  197|  7.72M|    case STRSXP:
  ------------------
  |  |  126|  7.72M|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (197:5): [True: 5.01M, False: 6.56M]
  ------------------
  198|  7.72M|    case OBJSXP:
  ------------------
  |  |  137|  7.72M|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (198:5): [True: 358, False: 11.5M]
  ------------------
  199|  7.72M|	ENSURE_NAMEDMAX(s);
  200|  7.72M|	break;
  201|      0|    default:
  ------------------
  |  Branch (201:5): [True: 0, False: 11.5M]
  ------------------
  202|      0|	UNIMPLEMENTED_TYPE("lazy_duplicate", s);
  203|  11.5M|    }
  204|  11.5M|    return s;
  205|  11.5M|}
R_cycle_detected:
  222|   385k|attribute_hidden Rboolean R_cycle_detected(SEXP s, SEXP child) {
  223|   385k|    if (s == child) {
  ------------------
  |  Branch (223:9): [True: 0, False: 385k]
  ------------------
  224|      0|	switch (TYPEOF(child)) {
  225|      0|	case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (225:2): [True: 0, False: 0]
  ------------------
  226|      0|	case SYMSXP:
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (226:2): [True: 0, False: 0]
  ------------------
  227|      0|	case ENVSXP:
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (227:2): [True: 0, False: 0]
  ------------------
  228|      0|	case SPECIALSXP:
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (228:2): [True: 0, False: 0]
  ------------------
  229|      0|	case BUILTINSXP:
  ------------------
  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (229:2): [True: 0, False: 0]
  ------------------
  230|      0|	case EXTPTRSXP:
  ------------------
  |  |  134|      0|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (230:2): [True: 0, False: 0]
  ------------------
  231|      0|	case BCODESXP:
  ------------------
  |  |  133|      0|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (231:2): [True: 0, False: 0]
  ------------------
  232|      0|	case WEAKREFSXP:
  ------------------
  |  |  135|      0|#define WEAKREFSXP  23    /* weak reference */
  ------------------
  |  Branch (232:2): [True: 0, False: 0]
  ------------------
  233|       |	    /* it's a cycle but one that is OK */
  234|      0|	    return FALSE;
  235|      0|	default:
  ------------------
  |  Branch (235:2): [True: 0, False: 0]
  ------------------
  236|      0|	return TRUE;
  237|      0|	}
  238|      0|    }
  239|   385k|    if (ATTRIB(child) != R_NilValue) {
  ------------------
  |  Branch (239:9): [True: 40, False: 385k]
  ------------------
  240|     40|	if (R_cycle_detected(s, ATTRIB(child)))
  ------------------
  |  Branch (240:6): [True: 0, False: 40]
  ------------------
  241|      0|	    return TRUE;
  242|     40|    }
  243|   385k|    if (isPairList(child)) {
  ------------------
  |  |  961|   385k|#define isPairList		Rf_isPairList
  ------------------
  |  Branch (243:9): [True: 137, False: 385k]
  ------------------
  244|    137|	SEXP el = child;
  245|    464|	while(el != R_NilValue) {
  ------------------
  |  Branch (245:8): [True: 327, False: 137]
  ------------------
  246|    327|	    if (s == el || R_cycle_detected(s, CAR(el)))
  ------------------
  |  Branch (246:10): [True: 0, False: 327]
  |  Branch (246:21): [True: 0, False: 327]
  ------------------
  247|      0|		return TRUE;
  248|    327|	    if (ATTRIB(el) != R_NilValue && R_cycle_detected(s, ATTRIB(el)))
  ------------------
  |  Branch (248:10): [True: 0, False: 327]
  |  Branch (248:38): [True: 0, False: 0]
  ------------------
  249|      0|		return TRUE;
  250|    327|	    el = CDR(el);
  251|    327|	}
  252|   385k|    } else if (isVectorList(child)) {
  ------------------
  |  |  977|   385k|#define isVectorList		Rf_isVectorList
  ------------------
  |  Branch (252:16): [True: 10, False: 385k]
  ------------------
  253|     70|	for(int i = 0 ; i < length(child); i++)
  ------------------
  |  |  987|     70|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (253:18): [True: 60, False: 10]
  ------------------
  254|     60|	    if (R_cycle_detected(s, VECTOR_ELT(child, i)))
  ------------------
  |  Branch (254:10): [True: 0, False: 60]
  ------------------
  255|      0|		return TRUE;
  256|     10|    }
  257|   385k|    return FALSE;
  258|   385k|}
Rf_copyVector:
  387|  1.02k|{
  388|  1.02k|    SEXPTYPE sT = TYPEOF(s), tT = TYPEOF(t);
  389|  1.02k|    if (sT != tT)
  ------------------
  |  Branch (389:9): [True: 0, False: 1.02k]
  ------------------
  390|      0|	error("vector types do not match in copyVector");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  391|  1.02k|    R_xlen_t ns = XLENGTH(s), nt = XLENGTH(t);
  392|  1.02k|    switch (sT) {
  393|     22|    case STRSXP:
  ------------------
  |  |  126|     22|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (393:5): [True: 22, False: 1.00k]
  ------------------
  394|     22|	xcopyStringWithRecycle(s, t, 0, ns, nt);
  395|     22|	break;
  396|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (396:5): [True: 0, False: 1.02k]
  ------------------
  397|      0|	xcopyLogicalWithRecycle(LOGICAL(s), LOGICAL_RO(t), 0, ns, nt);
  398|      0|	break;
  399|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (399:5): [True: 0, False: 1.02k]
  ------------------
  400|      0|	xcopyIntegerWithRecycle(INTEGER(s), INTEGER_RO(t), 0, ns, nt);
  401|      0|	break;
  402|  1.00k|    case REALSXP:
  ------------------
  |  |  124|  1.00k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (402:5): [True: 1.00k, False: 22]
  ------------------
  403|  1.00k|	xcopyRealWithRecycle(REAL(s), REAL_RO(t), 0, ns, nt);
  404|  1.00k|	break;
  405|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (405:5): [True: 0, False: 1.02k]
  ------------------
  406|      0|	xcopyComplexWithRecycle(COMPLEX(s), COMPLEX_RO(t), 0, ns, nt);
  407|      0|	break;
  408|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (408:5): [True: 0, False: 1.02k]
  ------------------
  409|      0|    case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (409:5): [True: 0, False: 1.02k]
  ------------------
  410|      0|	xcopyVectorWithRecycle(s, t, 0, ns, nt);
  411|      0|	break;
  412|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (412:5): [True: 0, False: 1.02k]
  ------------------
  413|      0|	xcopyRawWithRecycle(RAW(s), RAW_RO(t), 0, ns, nt);
  414|      0|	break;
  415|      0|    default:
  ------------------
  |  Branch (415:5): [True: 0, False: 1.02k]
  ------------------
  416|      0|	UNIMPLEMENTED_TYPE("copyVector", s);
  417|  1.02k|    }
  418|  1.02k|}
Rf_copyMatrix:
  458|  1.02k|{
  459|  1.02k|    int nr = nrows(s), nc = ncols(s);
  ------------------
  |  | 1008|  1.02k|#define nrows			Rf_nrows
  ------------------
                  int nr = nrows(s), nc = ncols(s);
  ------------------
  |  | 1005|  1.02k|#define ncols			Rf_ncols
  ------------------
  460|  1.02k|    R_xlen_t nt = XLENGTH(t);
  461|       |
  462|  1.02k|    if (byrow) {
  ------------------
  |  Branch (462:9): [True: 0, False: 1.02k]
  ------------------
  463|      0|	switch (TYPEOF(s)) {
  464|      0|	case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (464:2): [True: 0, False: 0]
  ------------------
  465|      0|	    FILL_MATRIX_BYROW_ITERATE(0, nr, nc, nt)
  ------------------
  |  |   62|      0|    for(R_xlen_t i = 0, sidx = 0; i < drows; i++)			\
  |  |  ------------------
  |  |  |  Branch (62:35): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|        for(R_xlen_t j = 0, didx = dstart + i; j < dcols;		\
  |  |  ------------------
  |  |  |  Branch (63:48): [True: 0, False: 0]
  |  |  ------------------
  |  |   64|      0|            j++, 							\
  |  |   65|      0|            sidx++,							\
  |  |   66|      0|            (sidx >= nsrc) ? sidx -= nsrc : 0,				\
  |  |  ------------------
  |  |  |  Branch (66:13): [True: 0, False: 0]
  |  |  ------------------
  |  |   67|      0|            didx += drows)
  ------------------
  466|      0|		SET_STRING_ELT(s, didx, STRING_ELT(t, sidx));
  467|      0|	    break;
  468|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (468:2): [True: 0, False: 0]
  ------------------
  469|      0|	    FILL_MATRIX_BYROW_ITERATE(0, nr, nc, nt)
  ------------------
  |  |   62|      0|    for(R_xlen_t i = 0, sidx = 0; i < drows; i++)			\
  |  |  ------------------
  |  |  |  Branch (62:35): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|        for(R_xlen_t j = 0, didx = dstart + i; j < dcols;		\
  |  |  ------------------
  |  |  |  Branch (63:48): [True: 0, False: 0]
  |  |  ------------------
  |  |   64|      0|            j++, 							\
  |  |   65|      0|            sidx++,							\
  |  |   66|      0|            (sidx >= nsrc) ? sidx -= nsrc : 0,				\
  |  |  ------------------
  |  |  |  Branch (66:13): [True: 0, False: 0]
  |  |  ------------------
  |  |   67|      0|            didx += drows)
  ------------------
  470|      0|		LOGICAL(s)[didx] = LOGICAL(t)[sidx];
  471|      0|	    break;
  472|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (472:2): [True: 0, False: 0]
  ------------------
  473|      0|	    FILL_MATRIX_BYROW_ITERATE(0, nr, nc, nt)
  ------------------
  |  |   62|      0|    for(R_xlen_t i = 0, sidx = 0; i < drows; i++)			\
  |  |  ------------------
  |  |  |  Branch (62:35): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|        for(R_xlen_t j = 0, didx = dstart + i; j < dcols;		\
  |  |  ------------------
  |  |  |  Branch (63:48): [True: 0, False: 0]
  |  |  ------------------
  |  |   64|      0|            j++, 							\
  |  |   65|      0|            sidx++,							\
  |  |   66|      0|            (sidx >= nsrc) ? sidx -= nsrc : 0,				\
  |  |  ------------------
  |  |  |  Branch (66:13): [True: 0, False: 0]
  |  |  ------------------
  |  |   67|      0|            didx += drows)
  ------------------
  474|      0|		INTEGER(s)[didx] = INTEGER(t)[sidx];
  475|      0|	    break;
  476|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (476:2): [True: 0, False: 0]
  ------------------
  477|      0|	    FILL_MATRIX_BYROW_ITERATE(0, nr, nc, nt)
  ------------------
  |  |   62|      0|    for(R_xlen_t i = 0, sidx = 0; i < drows; i++)			\
  |  |  ------------------
  |  |  |  Branch (62:35): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|        for(R_xlen_t j = 0, didx = dstart + i; j < dcols;		\
  |  |  ------------------
  |  |  |  Branch (63:48): [True: 0, False: 0]
  |  |  ------------------
  |  |   64|      0|            j++, 							\
  |  |   65|      0|            sidx++,							\
  |  |   66|      0|            (sidx >= nsrc) ? sidx -= nsrc : 0,				\
  |  |  ------------------
  |  |  |  Branch (66:13): [True: 0, False: 0]
  |  |  ------------------
  |  |   67|      0|            didx += drows)
  ------------------
  478|      0|		REAL(s)[didx] = REAL(t)[sidx];
  479|      0|	    break;
  480|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (480:2): [True: 0, False: 0]
  ------------------
  481|      0|	    FILL_MATRIX_BYROW_ITERATE(0, nr, nc, nt)
  ------------------
  |  |   62|      0|    for(R_xlen_t i = 0, sidx = 0; i < drows; i++)			\
  |  |  ------------------
  |  |  |  Branch (62:35): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|        for(R_xlen_t j = 0, didx = dstart + i; j < dcols;		\
  |  |  ------------------
  |  |  |  Branch (63:48): [True: 0, False: 0]
  |  |  ------------------
  |  |   64|      0|            j++, 							\
  |  |   65|      0|            sidx++,							\
  |  |   66|      0|            (sidx >= nsrc) ? sidx -= nsrc : 0,				\
  |  |  ------------------
  |  |  |  Branch (66:13): [True: 0, False: 0]
  |  |  ------------------
  |  |   67|      0|            didx += drows)
  ------------------
  482|      0|		COMPLEX(s)[didx] = COMPLEX(t)[sidx];
  483|      0|	    break;
  484|      0|	case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (484:2): [True: 0, False: 0]
  ------------------
  485|      0|	case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (485:2): [True: 0, False: 0]
  ------------------
  486|      0|	    FILL_MATRIX_BYROW_ITERATE(0, nr, nc, nt)
  ------------------
  |  |   62|      0|    for(R_xlen_t i = 0, sidx = 0; i < drows; i++)			\
  |  |  ------------------
  |  |  |  Branch (62:35): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|        for(R_xlen_t j = 0, didx = dstart + i; j < dcols;		\
  |  |  ------------------
  |  |  |  Branch (63:48): [True: 0, False: 0]
  |  |  ------------------
  |  |   64|      0|            j++, 							\
  |  |   65|      0|            sidx++,							\
  |  |   66|      0|            (sidx >= nsrc) ? sidx -= nsrc : 0,				\
  |  |  ------------------
  |  |  |  Branch (66:13): [True: 0, False: 0]
  |  |  ------------------
  |  |   67|      0|            didx += drows)
  ------------------
  487|      0|		SET_VECTOR_ELT(s, didx, VECTOR_ELT_LD(t, sidx));
  488|      0|	    break;
  489|      0|	case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (489:2): [True: 0, False: 0]
  ------------------
  490|      0|	    FILL_MATRIX_BYROW_ITERATE(0, nr, nc, nt)
  ------------------
  |  |   62|      0|    for(R_xlen_t i = 0, sidx = 0; i < drows; i++)			\
  |  |  ------------------
  |  |  |  Branch (62:35): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|        for(R_xlen_t j = 0, didx = dstart + i; j < dcols;		\
  |  |  ------------------
  |  |  |  Branch (63:48): [True: 0, False: 0]
  |  |  ------------------
  |  |   64|      0|            j++, 							\
  |  |   65|      0|            sidx++,							\
  |  |   66|      0|            (sidx >= nsrc) ? sidx -= nsrc : 0,				\
  |  |  ------------------
  |  |  |  Branch (66:13): [True: 0, False: 0]
  |  |  ------------------
  |  |   67|      0|            didx += drows)
  ------------------
  491|      0|		RAW(s)[didx] = RAW(t)[sidx];
  492|      0|	    break;
  493|      0|	default:
  ------------------
  |  Branch (493:2): [True: 0, False: 0]
  ------------------
  494|      0|	    UNIMPLEMENTED_TYPE("copyMatrix", s);
  495|      0|	}
  496|      0|    }
  497|  1.02k|    else
  498|  1.02k|	copyVector(s, t);
  ------------------
  |  |  902|  1.02k|#define copyVector		Rf_copyVector
  ------------------
  499|  1.02k|}
xcopyRealWithRecycle:
  503|  1.00k|xcopy##TNAME##WithRecycle(VALTYPE *dst, const VALTYPE *src, R_xlen_t dstart, R_xlen_t n, R_xlen_t nsrc) { \
  504|  1.00k|							\
  505|  1.00k|    if (nsrc >= n) { /* no recycle needed */		\
  ------------------
  |  Branch (505:9): [True: 1.00k, False: 0]
  ------------------
  506|   476k|	for(R_xlen_t i = 0; i < n; i++)		\
  ------------------
  |  Branch (506:22): [True: 475k, False: 1.00k]
  ------------------
  507|   475k|	    dst[dstart + i] = src[i];			\
  508|  1.00k|	return;					\
  509|  1.00k|    }							\
  510|  1.00k|    if (nsrc == 1) {					\
  ------------------
  |  Branch (510:9): [True: 0, False: 0]
  ------------------
  511|      0|	VALTYPE val = src[0];				\
  512|      0|	for(R_xlen_t i = 0; i < n; i++)			\
  ------------------
  |  Branch (512:22): [True: 0, False: 0]
  ------------------
  513|      0|	    dst[dstart + i] = val;			\
  514|      0|	return;						\
  515|      0|    }							\
  516|      0|							\
  517|      0|    /* recycle needed */					\
  518|      0|    R_xlen_t sidx = 0;					\
  519|      0|    for(R_xlen_t i = 0; i < n; i++, sidx++) {		\
  ------------------
  |  Branch (519:25): [True: 0, False: 0]
  ------------------
  520|      0|	if (sidx == nsrc) sidx = 0;			\
  ------------------
  |  Branch (520:6): [True: 0, False: 0]
  ------------------
  521|      0|	dst[dstart + i] = src[sidx];			\
  522|      0|    }							\
  523|      0|}
xcopyStringWithRecycle:
  533|     46|xcopy##TNAME##WithRecycle(SEXP dst, SEXP src, R_xlen_t dstart, R_xlen_t n, R_xlen_t nsrc) { \
  534|     46|							\
  535|     46|    if (nsrc >= n) { /* no recycle needed */		\
  ------------------
  |  Branch (535:9): [True: 46, False: 0]
  ------------------
  536|  6.62k|	for(R_xlen_t i = 0; i < n; i++)		\
  ------------------
  |  Branch (536:22): [True: 6.58k, False: 46]
  ------------------
  537|  6.58k|	    SETELT(dst, dstart + i, GETELT(src, i));	\
  538|     46|	return;					\
  539|     46|    }							\
  540|     46|    if (nsrc == 1) {					\
  ------------------
  |  Branch (540:9): [True: 0, False: 0]
  ------------------
  541|      0|	SEXP val = GETELT(src, 0);			\
  542|      0|	for(R_xlen_t i = 0; i < n; i++)			\
  ------------------
  |  Branch (542:22): [True: 0, False: 0]
  ------------------
  543|      0|	    SETELT(dst, dstart + i, val);		\
  544|      0|	return;						\
  545|      0|    }							\
  546|      0|							\
  547|      0|    /* recycle needed */					\
  548|      0|    R_xlen_t sidx = 0;					\
  549|      0|    for(R_xlen_t i = 0; i < n; i++, sidx++) {		\
  ------------------
  |  Branch (549:25): [True: 0, False: 0]
  ------------------
  550|      0|	if (sidx == nsrc) sidx = 0;			\
  ------------------
  |  Branch (550:6): [True: 0, False: 0]
  ------------------
  551|      0|	SETELT(dst, dstart + i, GETELT(src, sidx));	\
  552|      0|    }							\
  553|      0|}
xfillStringMatrixWithRecycle:
  576|     16|    R_xlen_t cols, R_xlen_t nsrc) {				\
  577|     16|								\
  578|  1.31k|    FILL_MATRIX_ITERATE(dstart, drows, srows, cols, nsrc)	\
  ------------------
  |  |   38|  1.33k|    for(R_xlen_t i = 0, sidx = 0; i < srows; i++, sidx = i)		\
  |  |  ------------------
  |  |  |  Branch (38:35): [True: 1.31k, False: 16]
  |  |  ------------------
  |  |   39|  6.58k|        for(R_xlen_t j = 0, didx = dstart + i; j < cols;		\
  |  |  ------------------
  |  |  |  Branch (39:48): [True: 5.26k, False: 1.31k]
  |  |  ------------------
  |  |   40|  5.26k|            j++, 							\
  |  |   41|  5.26k|            sidx += srows,						\
  |  |   42|  5.26k|            (sidx >= nsrc) ? sidx -= nsrc : 0,				\
  |  |  ------------------
  |  |  |  Branch (42:13): [True: 1.31k, False: 3.94k]
  |  |  ------------------
  |  |   43|  5.26k|            didx += drows)
  ------------------
  579|  5.26k|	SETELT(dst, didx, GETELT(src, sidx));			\
  580|     16|}
R_shallow_duplicate_attr:
  609|  1.15M|SEXP R_shallow_duplicate_attr(SEXP x) { return duplicate_attr(x, FALSE); }
duplicate.c:duplicate1:
  280|  9.72M|{
  281|  9.72M|    SEXP t;
  282|  9.72M|    R_xlen_t i, n;
  283|       |
  284|  9.72M|    if (ALTREP(s)) {
  ------------------
  |  Branch (284:9): [True: 0, False: 9.72M]
  ------------------
  285|      0|	PROTECT(s); /* the methods should protect, but ... */
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  286|      0|	SEXP ans = ALTREP_DUPLICATE_EX(s, deep);
  287|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  288|      0|	if (ans != NULL)
  ------------------
  |  Branch (288:6): [True: 0, False: 0]
  ------------------
  289|      0|	    return ans;
  290|      0|    }
  291|       |
  292|  9.72M|    switch (TYPEOF(s)) {
  293|  1.03k|    case NILSXP:
  ------------------
  |  |  111|  1.03k|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (293:5): [True: 1.03k, False: 9.72M]
  ------------------
  294|  3.13M|    case SYMSXP:
  ------------------
  |  |  112|  3.13M|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (294:5): [True: 3.13M, False: 6.58M]
  ------------------
  295|  3.14M|    case ENVSXP:
  ------------------
  |  |  115|  3.14M|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (295:5): [True: 6.76k, False: 9.71M]
  ------------------
  296|  3.14M|    case SPECIALSXP:
  ------------------
  |  |  118|  3.14M|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (296:5): [True: 0, False: 9.72M]
  ------------------
  297|  3.14M|    case BUILTINSXP:
  ------------------
  |  |  119|  3.14M|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (297:5): [True: 0, False: 9.72M]
  ------------------
  298|  3.14M|    case EXTPTRSXP:
  ------------------
  |  |  134|  3.14M|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (298:5): [True: 1.56k, False: 9.72M]
  ------------------
  299|  3.14M|    case BCODESXP:
  ------------------
  |  |  133|  3.14M|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (299:5): [True: 0, False: 9.72M]
  ------------------
  300|  3.14M|    case WEAKREFSXP:
  ------------------
  |  |  135|  3.14M|#define WEAKREFSXP  23    /* weak reference */
  ------------------
  |  Branch (300:5): [True: 0, False: 9.72M]
  ------------------
  301|  3.14M|	return s;
  302|  1.95k|    case CLOSXP:
  ------------------
  |  |  114|  1.95k|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (302:5): [True: 1.95k, False: 9.72M]
  ------------------
  303|  1.95k|	PROTECT(s);
  ------------------
  |  |  357|  1.95k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  304|  1.95k|	PROTECT(t = allocSExp(CLOSXP));
  ------------------
  |  |  357|  1.95k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  305|  1.95k|	SET_FORMALS(t, FORMALS(s));
  306|  1.95k|	SET_BODY(t, BODY(s));
  307|  1.95k|	SET_CLOENV(t, CLOENV(s));
  308|  1.95k|	DUPLICATE_ATTRIB(t, s, deep);
  ------------------
  |  |   91|  1.95k|#define DUPLICATE_ATTRIB(to, from, deep) do { \
  |  |   92|  1.95k|  SEXP __a__ = ATTRIB(from); \
  |  |   93|  1.95k|  if (__a__ != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (93:7): [True: 0, False: 1.95k]
  |  |  ------------------
  |  |   94|      0|      SET_ATTRIB(to, duplicate1(__a__, deep)); \
  |  |   95|      0|    SET_OBJECT(to, OBJECT(from)); \
  |  |   96|      0|    IS_S4_OBJECT(from) ? SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);  \
  |  |  ------------------
  |  |  |  Branch (96:5): [True: 0, False: 0]
  |  |  ------------------
  |  |   97|      0|  } \
  |  |   98|  1.95k|} while (0)
  |  |  ------------------
  |  |  |  Branch (98:10): [Folded, False: 1.95k]
  |  |  ------------------
  ------------------
  309|  1.95k|	if (NOJIT(s)) SET_NOJIT(t);
  ------------------
  |  Branch (309:6): [True: 906, False: 1.04k]
  ------------------
  310|  1.95k|	if (MAYBEJIT(s)) SET_MAYBEJIT(t);
  ------------------
  |  Branch (310:6): [True: 2, False: 1.95k]
  ------------------
  311|  1.95k|	UNPROTECT(2);
  ------------------
  |  |  358|  1.95k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  312|  1.95k|	break;
  313|  1.15M|    case LISTSXP:
  ------------------
  |  |  113|  1.15M|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (313:5): [True: 1.15M, False: 8.56M]
  ------------------
  314|  1.15M|	PROTECT(s);
  ------------------
  |  |  357|  1.15M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  315|  1.15M|	t = duplicate_list(s, deep);
  316|  1.15M|	UNPROTECT(1);
  ------------------
  |  |  358|  1.15M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  317|  1.15M|	break;
  318|  2.71M|    case LANGSXP:
  ------------------
  |  |  117|  2.71M|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (318:5): [True: 2.71M, False: 7.00M]
  ------------------
  319|  2.71M|	PROTECT(s);
  ------------------
  |  |  357|  2.71M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  320|  2.71M|	PROTECT(t = duplicate_list(s, deep));
  ------------------
  |  |  357|  2.71M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  321|  2.71M|	SET_TYPEOF(t, LANGSXP);
  ------------------
  |  |  117|  2.71M|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  322|  2.71M|	DUPLICATE_ATTRIB(t, s, deep);
  ------------------
  |  |   91|  2.71M|#define DUPLICATE_ATTRIB(to, from, deep) do { \
  |  |   92|  2.71M|  SEXP __a__ = ATTRIB(from); \
  |  |   93|  2.71M|  if (__a__ != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (93:7): [True: 0, False: 2.71M]
  |  |  ------------------
  |  |   94|      0|      SET_ATTRIB(to, duplicate1(__a__, deep)); \
  |  |   95|      0|    SET_OBJECT(to, OBJECT(from)); \
  |  |   96|      0|    IS_S4_OBJECT(from) ? SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);  \
  |  |  ------------------
  |  |  |  Branch (96:5): [True: 0, False: 0]
  |  |  ------------------
  |  |   97|      0|  } \
  |  |   98|  2.71M|} while (0)
  |  |  ------------------
  |  |  |  Branch (98:10): [Folded, False: 2.71M]
  |  |  ------------------
  ------------------
  323|  2.71M|	UNPROTECT(2);
  ------------------
  |  |  358|  2.71M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  324|  2.71M|	break;
  325|      0|    case DOTSXP:
  ------------------
  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (325:5): [True: 0, False: 9.72M]
  ------------------
  326|      0|	PROTECT(s);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  327|      0|	PROTECT(t = duplicate_list(s, deep));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  328|      0|	SET_TYPEOF(t, DOTSXP);
  ------------------
  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  329|      0|	DUPLICATE_ATTRIB(t, s, deep);
  ------------------
  |  |   91|      0|#define DUPLICATE_ATTRIB(to, from, deep) do { \
  |  |   92|      0|  SEXP __a__ = ATTRIB(from); \
  |  |   93|      0|  if (__a__ != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (93:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   94|      0|      SET_ATTRIB(to, duplicate1(__a__, deep)); \
  |  |   95|      0|    SET_OBJECT(to, OBJECT(from)); \
  |  |   96|      0|    IS_S4_OBJECT(from) ? SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);  \
  |  |  ------------------
  |  |  |  Branch (96:5): [True: 0, False: 0]
  |  |  ------------------
  |  |   97|      0|  } \
  |  |   98|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (98:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  330|      0|	UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  331|      0|	break;
  332|      0|    case CHARSXP:
  ------------------
  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (332:5): [True: 0, False: 9.72M]
  ------------------
  333|      0|	return s;
  334|      0|	break;
  335|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (335:5): [True: 0, False: 9.72M]
  ------------------
  336|  1.15M|    case VECSXP:
  ------------------
  |  |  131|  1.15M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (336:5): [True: 1.15M, False: 8.56M]
  ------------------
  337|  1.15M|	n = XLENGTH(s);
  338|  1.15M|	PROTECT(s);
  ------------------
  |  |  357|  1.15M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  339|  1.15M|	PROTECT(t = allocVector(TYPEOF(s), n));
  ------------------
  |  |  357|  1.15M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  340|  6.55M|	for(i = 0 ; i < n ; i++)
  ------------------
  |  Branch (340:14): [True: 5.39M, False: 1.15M]
  ------------------
  341|  5.39M|	    SET_VECTOR_ELT(t, i, duplicate_child(VECTOR_ELT(s, i), deep));
  342|  1.15M|	DUPLICATE_ATTRIB(t, s, deep);
  ------------------
  |  |   91|  1.15M|#define DUPLICATE_ATTRIB(to, from, deep) do { \
  |  |   92|  1.15M|  SEXP __a__ = ATTRIB(from); \
  |  |   93|  1.15M|  if (__a__ != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (93:7): [True: 1.15M, False: 10]
  |  |  ------------------
  |  |   94|  1.15M|      SET_ATTRIB(to, duplicate1(__a__, deep)); \
  |  |   95|  1.15M|    SET_OBJECT(to, OBJECT(from)); \
  |  |   96|  1.15M|    IS_S4_OBJECT(from) ? SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);  \
  |  |  ------------------
  |  |  |  Branch (96:5): [True: 0, False: 1.15M]
  |  |  ------------------
  |  |   97|  1.15M|  } \
  |  |   98|  1.15M|} while (0)
  |  |  ------------------
  |  |  |  Branch (98:10): [Folded, False: 1.15M]
  |  |  ------------------
  ------------------
  343|  1.15M|	COPY_TRUELENGTH(t, s);
  ------------------
  |  |   43|  1.15M|#define COPY_TRUELENGTH(to, from) do {			\
  |  |   44|  1.15M|	if (! GROWABLE_BIT_SET(from))			\
  |  |  ------------------
  |  |  |  Branch (44:6): [True: 1.15M, False: 0]
  |  |  ------------------
  |  |   45|  1.15M|	    SET_TRUELENGTH(to, XTRUELENGTH(from));	\
  |  |   46|  1.15M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (46:14): [Folded, False: 1.15M]
  |  |  ------------------
  ------------------
  344|  1.15M|	UNPROTECT(2);
  ------------------
  |  |  358|  1.15M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  345|  1.15M|	break;
  346|    734|    case LGLSXP: DUPLICATE_ATOMIC_VECTOR(int, LOGICAL, LOGICAL_RO, t, s, deep); break;
  ------------------
  |  |  121|    734|#define LGLSXP	    10	  /* logical vectors */
  ------------------
                  case LGLSXP: DUPLICATE_ATOMIC_VECTOR(int, LOGICAL, LOGICAL_RO, t, s, deep); break;
  ------------------
  |  |   75|    734|#define DUPLICATE_ATOMIC_VECTOR(type, fun, fun_ro, to, from, deep) do {	\
  |  |   76|    734|  R_xlen_t __n__ = XLENGTH(from); \
  |  |   77|    734|  PROTECT(from); \
  |  |  ------------------
  |  |  |  |  357|    734|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |   78|    734|  PROTECT(to = allocVector(TYPEOF(from), __n__)); \
  |  |  ------------------
  |  |  |  |  357|    734|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |   79|    734|  if (__n__ == 1) fun(to)[0] = fun_ro(from)[0]; \
  |  |  ------------------
  |  |  |  Branch (79:7): [True: 648, False: 86]
  |  |  ------------------
  |  |   80|    734|  else if (__n__) memcpy(fun(to), fun_ro(from), __n__ * sizeof(type)); \
  |  |  ------------------
  |  |  |  Branch (80:12): [True: 64, False: 22]
  |  |  ------------------
  |  |   81|    734|  DUPLICATE_ATTRIB(to, from, deep); \
  |  |  ------------------
  |  |  |  |   91|    734|#define DUPLICATE_ATTRIB(to, from, deep) do { \
  |  |  |  |   92|    734|  SEXP __a__ = ATTRIB(from); \
  |  |  |  |   93|    734|  if (__a__ != R_NilValue) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (93:7): [True: 504, False: 230]
  |  |  |  |  ------------------
  |  |  |  |   94|    504|      SET_ATTRIB(to, duplicate1(__a__, deep)); \
  |  |  |  |   95|    504|    SET_OBJECT(to, OBJECT(from)); \
  |  |  |  |   96|    504|    IS_S4_OBJECT(from) ? SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);  \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (96:5): [True: 0, False: 504]
  |  |  |  |  ------------------
  |  |  |  |   97|    504|  } \
  |  |  |  |   98|    734|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (98:10): [Folded, False: 734]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|    734|  COPY_TRUELENGTH(to, from); \
  |  |  ------------------
  |  |  |  |   43|    734|#define COPY_TRUELENGTH(to, from) do {			\
  |  |  |  |   44|    734|	if (! GROWABLE_BIT_SET(from))			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (44:6): [True: 734, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   45|    734|	    SET_TRUELENGTH(to, XTRUELENGTH(from));	\
  |  |  |  |   46|    734|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:14): [Folded, False: 734]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   83|    734|  UNPROTECT(2); \
  |  |  ------------------
  |  |  |  |  358|    734|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |   84|    734|} while (0)
  |  |  ------------------
  |  |  |  Branch (84:10): [Folded, False: 734]
  |  |  ------------------
  ------------------
  |  Branch (346:5): [True: 734, False: 9.72M]
  ------------------
  347|    156|    case INTSXP: DUPLICATE_ATOMIC_VECTOR(int, INTEGER, INTEGER_RO, t, s, deep); break;
  ------------------
  |  |  123|    156|#define INTSXP	    13	  /* integer vectors */
  ------------------
                  case INTSXP: DUPLICATE_ATOMIC_VECTOR(int, INTEGER, INTEGER_RO, t, s, deep); break;
  ------------------
  |  |   75|    156|#define DUPLICATE_ATOMIC_VECTOR(type, fun, fun_ro, to, from, deep) do {	\
  |  |   76|    156|  R_xlen_t __n__ = XLENGTH(from); \
  |  |   77|    156|  PROTECT(from); \
  |  |  ------------------
  |  |  |  |  357|    156|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |   78|    156|  PROTECT(to = allocVector(TYPEOF(from), __n__)); \
  |  |  ------------------
  |  |  |  |  357|    156|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |   79|    156|  if (__n__ == 1) fun(to)[0] = fun_ro(from)[0]; \
  |  |  ------------------
  |  |  |  Branch (79:7): [True: 84, False: 72]
  |  |  ------------------
  |  |   80|    156|  else if (__n__) memcpy(fun(to), fun_ro(from), __n__ * sizeof(type)); \
  |  |  ------------------
  |  |  |  Branch (80:12): [True: 72, False: 0]
  |  |  ------------------
  |  |   81|    156|  DUPLICATE_ATTRIB(to, from, deep); \
  |  |  ------------------
  |  |  |  |   91|    156|#define DUPLICATE_ATTRIB(to, from, deep) do { \
  |  |  |  |   92|    156|  SEXP __a__ = ATTRIB(from); \
  |  |  |  |   93|    156|  if (__a__ != R_NilValue) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (93:7): [True: 0, False: 156]
  |  |  |  |  ------------------
  |  |  |  |   94|      0|      SET_ATTRIB(to, duplicate1(__a__, deep)); \
  |  |  |  |   95|      0|    SET_OBJECT(to, OBJECT(from)); \
  |  |  |  |   96|      0|    IS_S4_OBJECT(from) ? SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);  \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (96:5): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   97|      0|  } \
  |  |  |  |   98|    156|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (98:10): [Folded, False: 156]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|    156|  COPY_TRUELENGTH(to, from); \
  |  |  ------------------
  |  |  |  |   43|    156|#define COPY_TRUELENGTH(to, from) do {			\
  |  |  |  |   44|    156|	if (! GROWABLE_BIT_SET(from))			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (44:6): [True: 156, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   45|    156|	    SET_TRUELENGTH(to, XTRUELENGTH(from));	\
  |  |  |  |   46|    156|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:14): [Folded, False: 156]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   83|    156|  UNPROTECT(2); \
  |  |  ------------------
  |  |  |  |  358|    156|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |   84|    156|} while (0)
  |  |  ------------------
  |  |  |  Branch (84:10): [Folded, False: 156]
  |  |  ------------------
  ------------------
  |  Branch (347:5): [True: 156, False: 9.72M]
  ------------------
  348|    105|    case REALSXP: DUPLICATE_ATOMIC_VECTOR(double, REAL, REAL_RO, t, s, deep); break;
  ------------------
  |  |  124|    105|#define REALSXP	    14	  /* real variables */
  ------------------
                  case REALSXP: DUPLICATE_ATOMIC_VECTOR(double, REAL, REAL_RO, t, s, deep); break;
  ------------------
  |  |   75|    105|#define DUPLICATE_ATOMIC_VECTOR(type, fun, fun_ro, to, from, deep) do {	\
  |  |   76|    105|  R_xlen_t __n__ = XLENGTH(from); \
  |  |   77|    105|  PROTECT(from); \
  |  |  ------------------
  |  |  |  |  357|    105|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |   78|    105|  PROTECT(to = allocVector(TYPEOF(from), __n__)); \
  |  |  ------------------
  |  |  |  |  357|    105|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |   79|    105|  if (__n__ == 1) fun(to)[0] = fun_ro(from)[0]; \
  |  |  ------------------
  |  |  |  Branch (79:7): [True: 9, False: 96]
  |  |  ------------------
  |  |   80|    105|  else if (__n__) memcpy(fun(to), fun_ro(from), __n__ * sizeof(type)); \
  |  |  ------------------
  |  |  |  Branch (80:12): [True: 0, False: 96]
  |  |  ------------------
  |  |   81|    105|  DUPLICATE_ATTRIB(to, from, deep); \
  |  |  ------------------
  |  |  |  |   91|    105|#define DUPLICATE_ATTRIB(to, from, deep) do { \
  |  |  |  |   92|    105|  SEXP __a__ = ATTRIB(from); \
  |  |  |  |   93|    105|  if (__a__ != R_NilValue) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (93:7): [True: 0, False: 105]
  |  |  |  |  ------------------
  |  |  |  |   94|      0|      SET_ATTRIB(to, duplicate1(__a__, deep)); \
  |  |  |  |   95|      0|    SET_OBJECT(to, OBJECT(from)); \
  |  |  |  |   96|      0|    IS_S4_OBJECT(from) ? SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);  \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (96:5): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   97|      0|  } \
  |  |  |  |   98|    105|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (98:10): [Folded, False: 105]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|    105|  COPY_TRUELENGTH(to, from); \
  |  |  ------------------
  |  |  |  |   43|    105|#define COPY_TRUELENGTH(to, from) do {			\
  |  |  |  |   44|    105|	if (! GROWABLE_BIT_SET(from))			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (44:6): [True: 105, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   45|    105|	    SET_TRUELENGTH(to, XTRUELENGTH(from));	\
  |  |  |  |   46|    105|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:14): [Folded, False: 105]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   83|    105|  UNPROTECT(2); \
  |  |  ------------------
  |  |  |  |  358|    105|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |   84|    105|} while (0)
  |  |  ------------------
  |  |  |  Branch (84:10): [Folded, False: 105]
  |  |  ------------------
  ------------------
  |  Branch (348:5): [True: 105, False: 9.72M]
  ------------------
  349|      0|    case CPLXSXP: DUPLICATE_ATOMIC_VECTOR(Rcomplex, COMPLEX, COMPLEX_RO, t, s, deep); break;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
                  case CPLXSXP: DUPLICATE_ATOMIC_VECTOR(Rcomplex, COMPLEX, COMPLEX_RO, t, s, deep); break;
  ------------------
  |  |   75|      0|#define DUPLICATE_ATOMIC_VECTOR(type, fun, fun_ro, to, from, deep) do {	\
  |  |   76|      0|  R_xlen_t __n__ = XLENGTH(from); \
  |  |   77|      0|  PROTECT(from); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |   78|      0|  PROTECT(to = allocVector(TYPEOF(from), __n__)); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |   79|      0|  if (__n__ == 1) fun(to)[0] = fun_ro(from)[0]; \
  |  |  ------------------
  |  |  |  Branch (79:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   80|      0|  else if (__n__) memcpy(fun(to), fun_ro(from), __n__ * sizeof(type)); \
  |  |  ------------------
  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  ------------------
  |  |   81|      0|  DUPLICATE_ATTRIB(to, from, deep); \
  |  |  ------------------
  |  |  |  |   91|      0|#define DUPLICATE_ATTRIB(to, from, deep) do { \
  |  |  |  |   92|      0|  SEXP __a__ = ATTRIB(from); \
  |  |  |  |   93|      0|  if (__a__ != R_NilValue) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (93:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   94|      0|      SET_ATTRIB(to, duplicate1(__a__, deep)); \
  |  |  |  |   95|      0|    SET_OBJECT(to, OBJECT(from)); \
  |  |  |  |   96|      0|    IS_S4_OBJECT(from) ? SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);  \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (96:5): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   97|      0|  } \
  |  |  |  |   98|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (98:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|      0|  COPY_TRUELENGTH(to, from); \
  |  |  ------------------
  |  |  |  |   43|      0|#define COPY_TRUELENGTH(to, from) do {			\
  |  |  |  |   44|      0|	if (! GROWABLE_BIT_SET(from))			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (44:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   45|      0|	    SET_TRUELENGTH(to, XTRUELENGTH(from));	\
  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   83|      0|  UNPROTECT(2); \
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |   84|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (84:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (349:5): [True: 0, False: 9.72M]
  ------------------
  350|      0|    case RAWSXP: DUPLICATE_ATOMIC_VECTOR(Rbyte, RAW, RAW_RO, t, s, deep); break;
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
                  case RAWSXP: DUPLICATE_ATOMIC_VECTOR(Rbyte, RAW, RAW_RO, t, s, deep); break;
  ------------------
  |  |   75|      0|#define DUPLICATE_ATOMIC_VECTOR(type, fun, fun_ro, to, from, deep) do {	\
  |  |   76|      0|  R_xlen_t __n__ = XLENGTH(from); \
  |  |   77|      0|  PROTECT(from); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |   78|      0|  PROTECT(to = allocVector(TYPEOF(from), __n__)); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |   79|      0|  if (__n__ == 1) fun(to)[0] = fun_ro(from)[0]; \
  |  |  ------------------
  |  |  |  Branch (79:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   80|      0|  else if (__n__) memcpy(fun(to), fun_ro(from), __n__ * sizeof(type)); \
  |  |  ------------------
  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  ------------------
  |  |   81|      0|  DUPLICATE_ATTRIB(to, from, deep); \
  |  |  ------------------
  |  |  |  |   91|      0|#define DUPLICATE_ATTRIB(to, from, deep) do { \
  |  |  |  |   92|      0|  SEXP __a__ = ATTRIB(from); \
  |  |  |  |   93|      0|  if (__a__ != R_NilValue) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (93:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   94|      0|      SET_ATTRIB(to, duplicate1(__a__, deep)); \
  |  |  |  |   95|      0|    SET_OBJECT(to, OBJECT(from)); \
  |  |  |  |   96|      0|    IS_S4_OBJECT(from) ? SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);  \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (96:5): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   97|      0|  } \
  |  |  |  |   98|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (98:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|      0|  COPY_TRUELENGTH(to, from); \
  |  |  ------------------
  |  |  |  |   43|      0|#define COPY_TRUELENGTH(to, from) do {			\
  |  |  |  |   44|      0|	if (! GROWABLE_BIT_SET(from))			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (44:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   45|      0|	    SET_TRUELENGTH(to, XTRUELENGTH(from));	\
  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   83|      0|  UNPROTECT(2); \
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |   84|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (84:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (350:5): [True: 0, False: 9.72M]
  ------------------
  351|  1.54M|    case STRSXP:
  ------------------
  |  |  126|  1.54M|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (351:5): [True: 1.54M, False: 8.17M]
  ------------------
  352|       |	/* Direct copying and bypassing the write barrier would be OK
  353|       |	   since t was just allocated and so it cannot be older than
  354|       |	   any of the elements in s. But it does not increment the
  355|       |	   reference counts, so use a loop with SET_STRING_ELT. LT */
  356|       |	//DUPLICATE_ATOMIC_VECTOR(SEXP, STRING_PTR, STRING_PTR_RO, t, s, deep);
  357|  1.54M|	n = XLENGTH(s);
  358|  1.54M|	PROTECT(s);
  ------------------
  |  |  357|  1.54M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  359|  1.54M|	PROTECT(t = allocVector(TYPEOF(s), n));
  ------------------
  |  |  357|  1.54M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  360|  6.21M|	for(i = 0 ; i < n ; i++)
  ------------------
  |  Branch (360:14): [True: 4.66M, False: 1.54M]
  ------------------
  361|  4.66M|	    SET_STRING_ELT(t, i, STRING_ELT(s, i));
  362|  1.54M|	DUPLICATE_ATTRIB(t, s, deep);
  ------------------
  |  |   91|  1.54M|#define DUPLICATE_ATTRIB(to, from, deep) do { \
  |  |   92|  1.54M|  SEXP __a__ = ATTRIB(from); \
  |  |   93|  1.54M|  if (__a__ != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (93:7): [True: 292, False: 1.54M]
  |  |  ------------------
  |  |   94|    292|      SET_ATTRIB(to, duplicate1(__a__, deep)); \
  |  |   95|    292|    SET_OBJECT(to, OBJECT(from)); \
  |  |   96|    292|    IS_S4_OBJECT(from) ? SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);  \
  |  |  ------------------
  |  |  |  Branch (96:5): [True: 0, False: 292]
  |  |  ------------------
  |  |   97|    292|  } \
  |  |   98|  1.54M|} while (0)
  |  |  ------------------
  |  |  |  Branch (98:10): [Folded, False: 1.54M]
  |  |  ------------------
  ------------------
  363|  1.54M|	COPY_TRUELENGTH(t, s);
  ------------------
  |  |   43|  1.54M|#define COPY_TRUELENGTH(to, from) do {			\
  |  |   44|  1.54M|	if (! GROWABLE_BIT_SET(from))			\
  |  |  ------------------
  |  |  |  Branch (44:6): [True: 1.54M, False: 0]
  |  |  ------------------
  |  |   45|  1.54M|	    SET_TRUELENGTH(to, XTRUELENGTH(from));	\
  |  |   46|  1.54M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (46:14): [Folded, False: 1.54M]
  |  |  ------------------
  ------------------
  364|  1.54M|	UNPROTECT(2);
  ------------------
  |  |  358|  1.54M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  365|  1.54M|	break;
  366|      0|    case PROMSXP:
  ------------------
  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (366:5): [True: 0, False: 9.72M]
  ------------------
  367|      0|	return s;
  368|      0|	break;
  369|      0|    case OBJSXP:
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (369:5): [True: 0, False: 9.72M]
  ------------------
  370|      0|	PROTECT(s);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  371|      0|	PROTECT(t = R_allocObject());
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  372|      0|	DUPLICATE_ATTRIB(t, s, deep);
  ------------------
  |  |   91|      0|#define DUPLICATE_ATTRIB(to, from, deep) do { \
  |  |   92|      0|  SEXP __a__ = ATTRIB(from); \
  |  |   93|      0|  if (__a__ != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (93:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   94|      0|      SET_ATTRIB(to, duplicate1(__a__, deep)); \
  |  |   95|      0|    SET_OBJECT(to, OBJECT(from)); \
  |  |   96|      0|    IS_S4_OBJECT(from) ? SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);  \
  |  |  ------------------
  |  |  |  Branch (96:5): [True: 0, False: 0]
  |  |  ------------------
  |  |   97|      0|  } \
  |  |   98|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (98:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  373|      0|	UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  374|      0|	break;
  375|      0|    default:
  ------------------
  |  Branch (375:5): [True: 0, False: 9.72M]
  ------------------
  376|      0|	UNIMPLEMENTED_TYPE("duplicate", s);
  377|      0|	t = s;/* for -Wall */
  378|  9.72M|    }
  379|  6.57M|    if(TYPEOF(t) == TYPEOF(s) ) { /* surely it only makes sense in this case*/
  ------------------
  |  Branch (379:8): [True: 6.57M, False: 0]
  ------------------
  380|  6.57M|	SET_OBJECT(t, OBJECT(s));
  381|  6.57M|	(IS_S4_OBJECT(s) ? SET_S4_OBJECT(t) : UNSET_S4_OBJECT(t));
  ------------------
  |  Branch (381:3): [True: 0, False: 6.57M]
  ------------------
  382|  6.57M|    }
  383|  6.57M|    return t;
  384|  9.72M|}
duplicate.c:duplicate_list:
  261|  3.87M|{
  262|  3.87M|    SEXP sp, vp, val;
  263|  3.87M|    PROTECT(s);
  ------------------
  |  |  357|  3.87M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  264|       |
  265|  3.87M|    val = R_NilValue;
  266|  12.0M|    for (sp = s; sp != R_NilValue; sp = CDR(sp))
  ------------------
  |  Branch (266:18): [True: 8.15M, False: 3.87M]
  ------------------
  267|  8.15M|	val = CONS(R_NilValue, val);
  ------------------
  |  |  309|  8.15M|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  268|       |
  269|  3.87M|    PROTECT(val);
  ------------------
  |  |  357|  3.87M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  270|  12.0M|    for (sp = s, vp = val; sp != R_NilValue; sp = CDR(sp), vp = CDR(vp)) {
  ------------------
  |  Branch (270:28): [True: 8.15M, False: 3.87M]
  ------------------
  271|  8.15M|	SETCAR(vp, duplicate_child(CAR(sp), deep));
  272|  8.15M|	COPY_TAG(vp, sp);
  ------------------
  |  |  100|  8.15M|#define COPY_TAG(to, from) do { \
  |  |  101|  8.15M|  SEXP __tag__ = TAG(from); \
  |  |  102|  8.15M|  if (__tag__ != R_NilValue) SET_TAG(to, __tag__); \
  |  |  ------------------
  |  |  |  Branch (102:7): [True: 2.31M, False: 5.84M]
  |  |  ------------------
  |  |  103|  8.15M|} while (0)
  |  |  ------------------
  |  |  |  Branch (103:10): [Folded, False: 8.15M]
  |  |  ------------------
  ------------------
  273|  8.15M|	DUPLICATE_ATTRIB(vp, sp, deep);
  ------------------
  |  |   91|  8.15M|#define DUPLICATE_ATTRIB(to, from, deep) do { \
  |  |   92|  8.15M|  SEXP __a__ = ATTRIB(from); \
  |  |   93|  8.15M|  if (__a__ != R_NilValue) { \
  |  |  ------------------
  |  |  |  Branch (93:7): [True: 0, False: 8.15M]
  |  |  ------------------
  |  |   94|      0|      SET_ATTRIB(to, duplicate1(__a__, deep)); \
  |  |   95|      0|    SET_OBJECT(to, OBJECT(from)); \
  |  |   96|      0|    IS_S4_OBJECT(from) ? SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);  \
  |  |  ------------------
  |  |  |  Branch (96:5): [True: 0, False: 0]
  |  |  ------------------
  |  |   97|      0|  } \
  |  |   98|  8.15M|} while (0)
  |  |  ------------------
  |  |  |  Branch (98:10): [Folded, False: 8.15M]
  |  |  ------------------
  ------------------
  274|  8.15M|    }
  275|  3.87M|    UNPROTECT(2);
  ------------------
  |  |  358|  3.87M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  276|  3.87M|    return val;
  277|  3.87M|}
duplicate.c:duplicate_child:
  207|  13.5M|static SEXP duplicate_child(SEXP s, Rboolean deep) {
  208|  13.5M|    if (deep)
  ------------------
  |  Branch (208:9): [True: 3.52M, False: 10.0M]
  ------------------
  209|  3.52M|	return duplicate1(s, TRUE);
  210|  10.0M|    else
  211|  10.0M|	return lazy_duplicate(s);
  ------------------
  |  |  985|  10.0M|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
  212|  13.5M|}
duplicate.c:duplicate_attr:
  592|  1.15M|{
  593|  1.15M|    if (isVector(x) && XLENGTH(x) >= WRAP_THRESHOLD) {
  ------------------
  |  |  974|  1.15M|#define isVector		Rf_isVector
  ------------------
                  if (isVector(x) && XLENGTH(x) >= WRAP_THRESHOLD) {
  ------------------
  |  |  590|  1.15M|#define WRAP_THRESHOLD 64
  ------------------
  |  Branch (593:9): [True: 1.15M, False: 16]
  |  Branch (593:24): [True: 8, False: 1.15M]
  ------------------
  594|      8|	SEXP val = R_tryWrap(x);
  595|      8|	if (val != x) {
  ------------------
  |  Branch (595:6): [True: 8, False: 0]
  ------------------
  596|      8|	    if (deep) {
  ------------------
  |  Branch (596:10): [True: 0, False: 8]
  ------------------
  597|      0|		PROTECT(val);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  598|       |		/* the spine has been duplicated; we could just do the values */
  599|      0|		SET_ATTRIB(val, duplicate(ATTRIB(val)));
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
  600|      0|		UNPROTECT(1); /* val */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  601|      0|	    }
  602|      8|	    return val;
  603|      8|	}
  604|      8|    }
  605|  1.15M|    return deep ? duplicate(x) : shallow_duplicate(x);
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
                  return deep ? duplicate(x) : shallow_duplicate(x);
  ------------------
  |  | 1030|  1.15M|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
  |  Branch (605:12): [True: 0, False: 1.15M]
  ------------------
  606|  1.15M|}

Rf_InitEd:
   73|      2|{
   74|       |#ifdef Win32
   75|       |    DefaultFileName = R_tmpnam2("Redit", R_TempDir, ".R");
   76|       |#else
   77|       |    DefaultFileName = R_tmpnam2(NULL, R_TempDir, ".R");
   78|      2|#endif
   79|      2|}

GEregisterSystem:
  158|      2|void GEregisterSystem(GEcallback cb, int *systemRegisterIndex) {
  159|      2|    int i, devNum;
  160|      2|    pGEDevDesc gdd;
  161|      2|    if (numGraphicsSystems + 1 == MAX_GRAPHICS_SYSTEMS)
  ------------------
  |  |  123|      2|#define MAX_GRAPHICS_SYSTEMS 24
  ------------------
  |  Branch (161:9): [True: 0, False: 2]
  ------------------
  162|      0|	error(_("too many graphics systems registered"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("too many graphics systems registered"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  163|       |    /* Set the system register index so that, if there are existing
  164|       |     * devices, it will know where to put the system-specific
  165|       |     * information in those devices
  166|       |     * If a graphics system has been unregistered, there might
  167|       |     * be "holes" in the list of graphics systems, so start
  168|       |     * from zero and look for the first NULL
  169|       |     */
  170|      2|    *systemRegisterIndex = 0;
  171|      2|    while (registeredSystems[*systemRegisterIndex] != NULL) {
  ------------------
  |  Branch (171:12): [True: 0, False: 2]
  ------------------
  172|      0|        (*systemRegisterIndex)++;
  173|      0|    }
  174|       |    /* Run through the existing devices and add the new information
  175|       |     * to any GEDevDesc's
  176|       |     */
  177|      2|    i = 1;
  178|      2|    if (!NoDevices()) {
  ------------------
  |  |  900|      2|#define NoDevices		Rf_NoDevices
  ------------------
  |  Branch (178:9): [True: 0, False: 2]
  ------------------
  179|      0|	devNum = curDevice();
  ------------------
  |  |  895|      0|#define curDevice		Rf_curDevice
  ------------------
  180|      0|	while (i++ < NumDevices()) {
  ------------------
  |  |  901|      0|#define NumDevices		Rf_NumDevices
  ------------------
  |  Branch (180:9): [True: 0, False: 0]
  ------------------
  181|      0|	    gdd = GEgetDevice(devNum);
  182|      0|	    registerOne(gdd, *systemRegisterIndex, cb);
  183|      0|	    devNum = nextDevice(devNum);
  ------------------
  |  |  899|      0|#define nextDevice		Rf_nextDevice
  ------------------
  184|      0|	}
  185|      0|    }
  186|       |    /* Store the information for adding to any new devices
  187|       |     */
  188|      2|    registeredSystems[*systemRegisterIndex] =
  189|      2|	(GESystemDesc*) calloc(1, sizeof(GESystemDesc));
  190|      2|    if (registeredSystems[*systemRegisterIndex] == NULL)
  ------------------
  |  Branch (190:9): [True: 0, False: 2]
  ------------------
  191|      0|	error(_("unable to allocate memory (in GEregister)"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("unable to allocate memory (in GEregister)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  192|      2|    registeredSystems[*systemRegisterIndex]->callback = cb;
  193|      2|    numGraphicsSystems += 1;
  194|      2|}
GEonExit:
 3296|  1.90k|{
 3297|       |  /*
 3298|       |   * Run through all devices and turn graphics recording back on
 3299|       |   * in case an error occurred in the middle of a do_recordGraphics
 3300|       |   * call.
 3301|       |   * Awkward cos device code still in graphics.c
 3302|       |   * Can be cleaned up when device code moved here.
 3303|       |   */
 3304|  1.90k|    int i, devNum;
 3305|  1.90k|    pGEDevDesc gd;
 3306|  1.90k|    pDevDesc dd;
 3307|  1.90k|    i = 1;
 3308|  1.90k|    if (!NoDevices()) {
  ------------------
  |  |  900|  1.90k|#define NoDevices		Rf_NoDevices
  ------------------
  |  Branch (3308:9): [True: 0, False: 1.90k]
  ------------------
 3309|      0|	devNum = curDevice();
  ------------------
  |  |  895|      0|#define curDevice		Rf_curDevice
  ------------------
 3310|      0|	while (i++ < NumDevices()) {
  ------------------
  |  |  901|      0|#define NumDevices		Rf_NumDevices
  ------------------
  |  Branch (3310:9): [True: 0, False: 0]
  ------------------
 3311|      0|	    gd = GEgetDevice(devNum);
 3312|       |#ifdef R_GE_DEBUG
 3313|       |            if (getenv("R_GE_DEBUG_record")) {
 3314|       |                printf("GEonExit: record = TRUE\n");
 3315|       |            }
 3316|       |#endif
 3317|      0|	    gd->recordGraphics = TRUE;
 3318|      0|	    dd = gd->dev;
 3319|      0|	    if (dd->onExit) dd->onExit(dd);
  ------------------
  |  Branch (3319:10): [True: 0, False: 0]
  ------------------
 3320|      0|	    devNum = nextDevice(devNum);
  ------------------
  |  |  899|      0|#define nextDevice		Rf_nextDevice
  ------------------
 3321|      0|	}
 3322|      0|    }
 3323|  1.90k|}

R_envHasNoSpecialSymbols:
  180|  3.91M|{
  181|  3.91M|    SEXP frame;
  182|       |
  183|  3.91M|    if (HASHTAB(env) != R_NilValue)
  ------------------
  |  Branch (183:9): [True: 0, False: 3.91M]
  ------------------
  184|      0|	return FALSE;
  185|       |
  186|  12.1M|    for (frame = FRAME(env); frame != R_NilValue; frame = CDR(frame))
  ------------------
  |  Branch (186:30): [True: 8.23M, False: 3.91M]
  ------------------
  187|  8.23M|	if (IS_SPECIAL_SYMBOL(TAG(frame)))
  ------------------
  |  Branch (187:6): [True: 0, False: 8.23M]
  ------------------
  188|      0|	    return FALSE;
  189|       |
  190|  3.91M|    return TRUE;
  191|  3.91M|}
R_Newhashpjw:
  230|  3.61M|{
  231|  3.61M|    char *p;
  232|  3.61M|    unsigned h = 0, g;
  233|  40.6M|    for (p = (char *) s; *p; p++) {
  ------------------
  |  Branch (233:26): [True: 37.0M, False: 3.61M]
  ------------------
  234|  37.0M|	h = (h << 4) + (*p);
  235|  37.0M|	if ((g = h & 0xf0000000) != 0) {
  ------------------
  |  Branch (235:6): [True: 16.1M, False: 20.8M]
  ------------------
  236|  16.1M|	    h = h ^ (g >> 24);
  237|  16.1M|	    h = h ^ g;
  238|  16.1M|	}
  239|  37.0M|    }
  240|  3.61M|    return h;
  241|  3.61M|}
R_NewHashedEnv:
  374|    789|{
  375|    789|    SEXP s;
  376|       |
  377|    789|    PROTECT(enclos);
  ------------------
  |  |  357|    789|#define PROTECT(s)	Rf_protect(s)
  ------------------
  378|    789|    PROTECT(s = NewEnvironment(R_NilValue, R_NilValue, enclos));
  ------------------
  |  |  357|    789|#define PROTECT(s)	Rf_protect(s)
  ------------------
  379|    789|    SET_HASHTAB(s, R_NewHashTable(size));
  380|    789|    UNPROTECT(2);
  ------------------
  |  |  358|    789|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  381|    789|    return s;
  382|    789|}
Rf_InitBaseEnv:
  667|      2|{
  668|      2|    R_EmptyEnv = NewEnvironment(R_NilValue, R_NilValue, R_NilValue);
  ------------------
  |  | 1961|      2|# define NewEnvironment		Rf_NewEnvironment
  ------------------
  669|      2|    R_BaseEnv = NewEnvironment(R_NilValue, R_NilValue, R_EmptyEnv);
  ------------------
  |  | 1961|      2|# define NewEnvironment		Rf_NewEnvironment
  ------------------
  670|      2|}
Rf_InitGlobalEnv:
  673|      2|{
  674|      2|    R_NamespaceSymbol = install(".__NAMESPACE__.");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  675|       |
  676|      2|    R_GlobalEnv = R_NewHashedEnv(R_BaseEnv, 0);
  677|      2|    R_MethodsNamespace = R_GlobalEnv; // so it is initialized.
  678|       |#ifdef NEW_CODE /* Not used */
  679|       |    HASHTAB(R_GlobalEnv) = R_NewHashTable(100);
  680|       |#endif
  681|      2|#ifdef USE_GLOBAL_CACHE
  682|      2|    MARK_AS_GLOBAL_FRAME(R_GlobalEnv);
  ------------------
  |  |  655|      2|  SET_ENVFLAGS(e, ENVFLAGS(e) | GLOBAL_FRAME_MASK)
  |  |  ------------------
  |  |  |  |  652|      2|#define GLOBAL_FRAME_MASK (1<<15)
  |  |  ------------------
  ------------------
  683|      2|    R_GlobalCache = R_NewHashTable(INITIAL_CACHE_SIZE);
  ------------------
  |  |  659|      2|#define INITIAL_CACHE_SIZE 1000
  ------------------
  684|      2|    R_GlobalCachePreserve = CONS(R_GlobalCache, R_NilValue);
  ------------------
  |  |  309|      2|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  685|      2|    R_PreserveObject(R_GlobalCachePreserve);
  686|      2|#endif
  687|      2|    R_BaseNamespace = NewEnvironment(R_NilValue, R_NilValue, R_GlobalEnv);
  ------------------
  |  | 1961|      2|# define NewEnvironment		Rf_NewEnvironment
  ------------------
  688|      2|    R_PreserveObject(R_BaseNamespace);
  689|      2|    SET_SYMVALUE(install(".BaseNamespaceEnv"), R_BaseNamespace);
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  690|      2|    R_BaseNamespaceName = ScalarString(mkChar("base"));
  ------------------
  |  | 1025|      2|#define ScalarString		Rf_ScalarString
  ------------------
                  R_BaseNamespaceName = ScalarString(mkChar("base"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  691|      2|    R_PreserveObject(R_BaseNamespaceName);
  692|      2|    R_NamespaceRegistry = R_NewHashedEnv(R_NilValue, 0);
  693|      2|    R_PreserveObject(R_NamespaceRegistry);
  694|      2|    defineVar(R_BaseSymbol, R_BaseNamespace, R_NamespaceRegistry);
  ------------------
  |  |  905|      2|#define defineVar		Rf_defineVar
  ------------------
  695|       |    /**** needed to properly initialize the base namespace */
  696|      2|}
Rf_unbindVar:
  978|     32|{
  979|     32|    int hashcode;
  980|     32|    int found;
  981|     32|    SEXP c;
  982|       |
  983|     32|    if (rho == R_BaseNamespace)
  ------------------
  |  Branch (983:9): [True: 0, False: 32]
  ------------------
  984|      0|	error(_("cannot unbind in the base namespace"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot unbind in the base namespace"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  985|     32|    if (rho == R_BaseEnv)
  ------------------
  |  Branch (985:9): [True: 0, False: 32]
  ------------------
  986|      0|	error(_("unbind in the base environment is unimplemented"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("unbind in the base environment is unimplemented"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  987|     32|    if (FRAME_IS_LOCKED(rho))
  ------------------
  |  |  107|     32|#define FRAME_IS_LOCKED(e) (ENVFLAGS(e) & FRAME_LOCK_MASK)
  |  |  ------------------
  |  |  |  |  106|     32|#define FRAME_LOCK_MASK (1<<14)
  |  |  ------------------
  |  |  |  Branch (107:28): [True: 0, False: 32]
  |  |  ------------------
  ------------------
  988|      0|	error(_("cannot remove bindings from a locked environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot remove bindings from a locked environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  989|     32|    if (HASHTAB(rho) == R_NilValue) {
  ------------------
  |  Branch (989:9): [True: 32, False: 0]
  ------------------
  990|     32|	SEXP list;
  991|     32|	list = RemoveFromList(symbol, FRAME(rho), &found);
  992|     32|	if (found) {
  ------------------
  |  Branch (992:6): [True: 32, False: 0]
  ------------------
  993|     32|	    if (rho == R_GlobalEnv) R_DirtyImage = 1;
  ------------------
  |  Branch (993:10): [True: 0, False: 32]
  ------------------
  994|     32|	    SET_FRAME(rho, list);
  995|     32|#ifdef USE_GLOBAL_CACHE
  996|     32|	    if (IS_GLOBAL_FRAME(rho))
  ------------------
  |  |  653|     32|#define IS_GLOBAL_FRAME(e) (ENVFLAGS(e) & GLOBAL_FRAME_MASK)
  |  |  ------------------
  |  |  |  |  652|     32|#define GLOBAL_FRAME_MASK (1<<15)
  |  |  ------------------
  |  |  |  Branch (653:28): [True: 0, False: 32]
  |  |  ------------------
  ------------------
  997|      0|		R_FlushGlobalCache(symbol);
  998|     32|#endif
  999|     32|	}
 1000|     32|    }
 1001|      0|    else {
 1002|       |	/* This branch is used e.g. via sys.source, utils::data */
 1003|      0|	c = PRINTNAME(symbol);
 1004|      0|	if( !HASHASH(c) ) {
  ------------------
  |  Branch (1004:6): [True: 0, False: 0]
  ------------------
 1005|      0|	    SET_HASHVALUE(c, R_Newhashpjw(CHAR(c)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1006|      0|	    SET_HASHASH(c, 1);
 1007|      0|	}
 1008|      0|	hashcode = HASHVALUE(c) % HASHSIZE(HASHTAB(rho));
  ------------------
  |  |  205|      0|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
 1009|      0|	R_HashDelete(hashcode, symbol, rho, &found);
 1010|      0|#ifdef USE_GLOBAL_CACHE
 1011|      0|	if (found && IS_GLOBAL_FRAME(rho))
  ------------------
  |  |  653|      0|#define IS_GLOBAL_FRAME(e) (ENVFLAGS(e) & GLOBAL_FRAME_MASK)
  |  |  ------------------
  |  |  |  |  652|      0|#define GLOBAL_FRAME_MASK (1<<15)
  |  |  ------------------
  |  |  |  Branch (653:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1011:6): [True: 0, False: 0]
  ------------------
 1012|      0|	     R_FlushGlobalCache(symbol);
 1013|      0|#endif
 1014|      0|    }
 1015|     32|}
R_findVarLocInFrame:
 1094|  17.2M|{
 1095|  17.2M|    SEXP binding = findVarLocInFrame(rho, symbol, NULL);
 1096|  17.2M|    R_varloc_t val;
 1097|  17.2M|    val.cell = binding == R_NilValue ? NULL : binding;
  ------------------
  |  Branch (1097:16): [True: 69.3k, False: 17.1M]
  ------------------
 1098|  17.2M|    return val;
 1099|  17.2M|}
R_GetVarLocValue:
 1103|  45.6k|{
 1104|  45.6k|    SEXP cell = vl.cell;
 1105|  45.6k|    if (cell == NULL || cell == R_UnboundValue)
  ------------------
  |  Branch (1105:9): [True: 0, False: 45.6k]
  |  Branch (1105:25): [True: 0, False: 45.6k]
  ------------------
 1106|      0|	return R_UnboundValue;
 1107|  45.6k|    else if (TYPEOF(cell) == SYMSXP)
  ------------------
  |  |  112|  45.6k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1107:14): [True: 4.73k, False: 40.9k]
  ------------------
 1108|  4.73k|	return SYMBOL_BINDING_VALUE(cell);
  ------------------
  |  |  123|  4.73k|#define SYMBOL_BINDING_VALUE(s) ((IS_ACTIVE_BINDING(s) ? getActiveValue(SYMVALUE(s)) : SYMVALUE(s)))
  |  |  ------------------
  |  |  |  Branch (123:35): [True: 4, False: 4.72k]
  |  |  ------------------
  ------------------
 1109|  40.9k|    else return BINDING_VALUE(cell);
 1110|  45.6k|}
R_SetVarLocValue:
 1126|     32|{
 1127|       |    SET_BINDING_VALUE(vl.cell, value);
  ------------------
  |  |  126|     32|#define SET_BINDING_VALUE(b,val) do { \
  |  |  127|     32|  SEXP __b__ = (b); \
  |  |  128|     32|  SEXP __val__ = (val); \
  |  |  129|     32|  if (BINDING_IS_LOCKED(__b__)) \
  |  |  ------------------
  |  |  |  Branch (129:7): [True: 0, False: 32]
  |  |  ------------------
  |  |  130|     32|    error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |                   error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  131|      0|	  CHAR(PRINTNAME(TAG(__b__)))); \
  |  |  ------------------
  |  |  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  |  |  132|     32|  if (IS_ACTIVE_BINDING(__b__)) { \
  |  |  ------------------
  |  |  |  Branch (132:7): [True: 0, False: 32]
  |  |  ------------------
  |  |  133|      0|    PROTECT(__val__); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  134|      0|    setActiveValue(CAR(__b__), __val__); \
  |  |  135|      0|    UNPROTECT(1); \
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |  136|      0|   } else \
  |  |  137|     32|    SET_BNDCELL(__b__, __val__); \
  |  |  138|     32|} while (0)
  |  |  ------------------
  |  |  |  Branch (138:10): [Folded, False: 32]
  |  |  ------------------
  ------------------
 1128|     32|}
Rf_findVarInFrame3:
 1148|  33.8M|{
 1149|  33.8M|    int hashcode;
 1150|  33.8M|    SEXP frame, c;
 1151|       |
 1152|  33.8M|    if (TYPEOF(rho) == NILSXP)
  ------------------
  |  |  111|  33.8M|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1152:9): [True: 0, False: 33.8M]
  ------------------
 1153|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1154|       |
 1155|  33.8M|    if (rho == R_BaseNamespace || rho == R_BaseEnv)
  ------------------
  |  Branch (1155:9): [True: 8.16M, False: 25.7M]
  |  Branch (1155:35): [True: 2.34M, False: 23.3M]
  ------------------
 1156|  10.5M|	return SYMBOL_BINDING_VALUE(symbol);
  ------------------
  |  |  123|  10.5M|#define SYMBOL_BINDING_VALUE(s) ((IS_ACTIVE_BINDING(s) ? getActiveValue(SYMVALUE(s)) : SYMVALUE(s)))
  |  |  ------------------
  |  |  |  Branch (123:35): [True: 8, False: 10.5M]
  |  |  ------------------
  ------------------
 1157|       |
 1158|  23.3M|    if (rho == R_EmptyEnv)
  ------------------
  |  Branch (1158:9): [True: 0, False: 23.3M]
  ------------------
 1159|      0|	return R_UnboundValue;
 1160|       |
 1161|  23.3M|    if(IS_USER_DATABASE(rho)) {
  ------------------
  |  |  102|  23.3M|#define IS_USER_DATABASE(rho)  (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  ------------------
  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  ------------------
  |  |  |  Branch (102:33): [True: 0, False: 23.3M]
  |  |  |  Branch (102:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1162|       |	/* Use the objects function pointer for this symbol. */
 1163|      0|	R_ObjectTable *table;
 1164|      0|	SEXP val = R_UnboundValue;
 1165|      0|	table = (R_ObjectTable *) R_ExternalPtrAddr(HASHTAB(rho));
 1166|      0|	if(table->active) {
  ------------------
  |  Branch (1166:5): [True: 0, False: 0]
  ------------------
 1167|      0|	    if(doGet)
  ------------------
  |  Branch (1167:9): [True: 0, False: 0]
  ------------------
 1168|      0|		val = table->get(CHAR(PRINTNAME(symbol)), NULL, table);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1169|      0|	    else {
 1170|      0|		if(table->exists(CHAR(PRINTNAME(symbol)), NULL, table))
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1170:6): [True: 0, False: 0]
  ------------------
 1171|      0|		    val = table->get(CHAR(PRINTNAME(symbol)), NULL, table);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1172|      0|		else
 1173|      0|		    val = R_UnboundValue;
 1174|      0|	    }
 1175|      0|	    MARK_NOT_MUTABLE(val); /* to keep complex assignment code sane */
 1176|      0|	}
 1177|      0|	return(val);
 1178|  23.3M|    } else if (HASHTAB(rho) == R_NilValue) {
  ------------------
  |  Branch (1178:16): [True: 19.8M, False: 3.53M]
  ------------------
 1179|  19.8M|	frame = FRAME(rho);
 1180|   105M|	while (frame != R_NilValue) {
  ------------------
  |  Branch (1180:9): [True: 91.1M, False: 14.4M]
  ------------------
 1181|  91.1M|	    if (TAG(frame) == symbol)
  ------------------
  |  Branch (1181:10): [True: 5.43M, False: 85.7M]
  ------------------
 1182|  5.43M|		return BINDING_VALUE(frame);
 1183|  85.7M|	    frame = CDR(frame);
 1184|  85.7M|	}
 1185|  19.8M|    }
 1186|  3.53M|    else {
 1187|  3.53M|	c = PRINTNAME(symbol);
 1188|  3.53M|	if( !HASHASH(c) ) {
  ------------------
  |  Branch (1188:6): [True: 0, False: 3.53M]
  ------------------
 1189|      0|	    SET_HASHVALUE(c, R_Newhashpjw(CHAR(c)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1190|      0|	    SET_HASHASH(c, 1);
 1191|      0|	}
 1192|  3.53M|	hashcode = HASHVALUE(c) % HASHSIZE(HASHTAB(rho));
  ------------------
  |  |  205|  3.53M|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
 1193|       |	/* Will return 'R_UnboundValue' if not found */
 1194|  3.53M|	return(R_HashGet(hashcode, symbol, HASHTAB(rho)));
 1195|  3.53M|    }
 1196|  14.4M|    return R_UnboundValue;
 1197|  23.3M|}
R_existsVarInFrame:
 1202|  3.88M|{
 1203|  3.88M|    int hashcode;
 1204|  3.88M|    SEXP frame, c;
 1205|       |
 1206|  3.88M|    if (TYPEOF(rho) == NILSXP)
  ------------------
  |  |  111|  3.88M|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1206:9): [True: 0, False: 3.88M]
  ------------------
 1207|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1208|       |
 1209|  3.88M|    if (rho == R_BaseNamespace || rho == R_BaseEnv)
  ------------------
  |  Branch (1209:9): [True: 2, False: 3.88M]
  |  Branch (1209:35): [True: 95, False: 3.88M]
  ------------------
 1210|     97|	return SYMBOL_HAS_BINDING(symbol);
  ------------------
  |  |  124|     97|#define SYMBOL_HAS_BINDING(s) (IS_ACTIVE_BINDING(s) || (SYMVALUE(s) != R_UnboundValue))
  |  |  ------------------
  |  |  |  Branch (124:32): [True: 0, False: 97]
  |  |  |  Branch (124:56): [True: 88, False: 9]
  |  |  ------------------
  ------------------
 1211|       |
 1212|  3.88M|    if (rho == R_EmptyEnv)
  ------------------
  |  Branch (1212:9): [True: 0, False: 3.88M]
  ------------------
 1213|      0|	return FALSE;
 1214|       |
 1215|  3.88M|    if(IS_USER_DATABASE(rho)) {
  ------------------
  |  |  102|  3.88M|#define IS_USER_DATABASE(rho)  (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  ------------------
  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  ------------------
  |  |  |  Branch (102:33): [True: 0, False: 3.88M]
  |  |  |  Branch (102:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1216|       |	/* Use the objects function pointer for this symbol. */
 1217|      0|	R_ObjectTable *table;
 1218|      0|	Rboolean val = FALSE;
 1219|      0|	table = (R_ObjectTable *) R_ExternalPtrAddr(HASHTAB(rho));
 1220|      0|	if(table->active) {
  ------------------
  |  Branch (1220:5): [True: 0, False: 0]
  ------------------
 1221|      0|	    if(table->exists(CHAR(PRINTNAME(symbol)), NULL, table))
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1221:9): [True: 0, False: 0]
  ------------------
 1222|      0|		val = TRUE;
 1223|      0|	    else
 1224|      0|		val = FALSE;
 1225|      0|	}
 1226|      0|	return(val);
 1227|  3.88M|    } else if (HASHTAB(rho) == R_NilValue) {
  ------------------
  |  Branch (1227:16): [True: 3.88M, False: 2.32k]
  ------------------
 1228|  3.88M|	frame = FRAME(rho);
 1229|  25.0M|	while (frame != R_NilValue) {
  ------------------
  |  Branch (1229:9): [True: 21.1M, False: 3.88M]
  ------------------
 1230|  21.1M|	    if (TAG(frame) == symbol)
  ------------------
  |  Branch (1230:10): [True: 0, False: 21.1M]
  ------------------
 1231|      0|		return TRUE;
 1232|  21.1M|	    frame = CDR(frame);
 1233|  21.1M|	}
 1234|  3.88M|    }
 1235|  2.32k|    else {
 1236|  2.32k|	c = PRINTNAME(symbol);
 1237|  2.32k|	if( !HASHASH(c) ) {
  ------------------
  |  Branch (1237:6): [True: 0, False: 2.32k]
  ------------------
 1238|      0|	    SET_HASHVALUE(c, R_Newhashpjw(CHAR(c)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1239|      0|	    SET_HASHASH(c, 1);
 1240|      0|	}
 1241|  2.32k|	hashcode = HASHVALUE(c) % HASHSIZE(HASHTAB(rho));
  ------------------
  |  |  205|  2.32k|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
 1242|  2.32k|	return R_HashExists(hashcode, symbol, HASHTAB(rho));
 1243|  2.32k|    }
 1244|  3.88M|    return FALSE;
 1245|  3.88M|}
R_findVarInFrame:
 1248|  33.8M|{
 1249|  33.8M|    return findVarInFrame3(rho, symbol, TRUE);
  ------------------
  |  |  920|  33.8M|#define findVarInFrame3		Rf_findVarInFrame3
  ------------------
 1250|  33.8M|}
Rf_findVarInFrame:
 1253|  1.90k|{
 1254|  1.90k|    return R_findVarInFrame(rho, symbol);
 1255|  1.90k|}
Rf_readS3VarsFromFrame:
 1271|     16|    SEXP *dotGenericCallEnv, SEXP *dotGenericDefEnv) {
 1272|       |
 1273|     16|    if (TYPEOF(rho) == NILSXP ||
  ------------------
  |  |  111|     32|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1273:9): [True: 0, False: 16]
  ------------------
 1274|     16|	rho == R_BaseNamespace || rho == R_BaseEnv || rho == R_EmptyEnv ||
  ------------------
  |  Branch (1274:2): [True: 0, False: 16]
  |  Branch (1274:28): [True: 0, False: 16]
  |  Branch (1274:48): [True: 0, False: 16]
  ------------------
 1275|     16|	IS_USER_DATABASE(rho) || HASHTAB(rho) != R_NilValue) goto slowpath;
  ------------------
  |  |  102|     32|#define IS_USER_DATABASE(rho)  (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  ------------------
  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  ------------------
  |  |  |  Branch (102:33): [True: 0, False: 16]
  |  |  |  Branch (102:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1275:27): [True: 0, False: 16]
  ------------------
 1276|       |
 1277|     16|    SEXP frame = FRAME(rho);
 1278|       |
 1279|       |    /*
 1280|       |    This code speculates there is a specific order of S3 meta-variables.  It
 1281|       |    holds in most (perhaps all non-fabricated) cases.  If at any time this
 1282|       |    ceased to hold, this code will fall back to the slowpath, which may be
 1283|       |    slow but still correct.
 1284|       |    */
 1285|       |
 1286|     16|    for(;TAG(frame) != R_dot_Generic; frame = CDR(frame))
  ------------------
  |  Branch (1286:10): [True: 0, False: 16]
  ------------------
 1287|      0|	if (frame == R_NilValue) goto slowpath;
  ------------------
  |  Branch (1287:6): [True: 0, False: 0]
  ------------------
 1288|     16|    *dotGeneric = BINDING_VALUE(frame);
 1289|     16|    frame = CDR(frame);
 1290|       |
 1291|     16|    if (TAG(frame) != R_dot_Class) goto slowpath;
  ------------------
  |  Branch (1291:9): [True: 0, False: 16]
  ------------------
 1292|     16|    *dotClass = BINDING_VALUE(frame);
 1293|     16|    frame = CDR(frame);
 1294|       |
 1295|     16|    if (TAG(frame) != R_dot_Method) goto slowpath;
  ------------------
  |  Branch (1295:9): [True: 0, False: 16]
  ------------------
 1296|     16|    *dotMethod = BINDING_VALUE(frame);
 1297|     16|    frame = CDR(frame);
 1298|       |
 1299|     16|    if (TAG(frame) != R_dot_Group) goto slowpath;
  ------------------
  |  Branch (1299:9): [True: 0, False: 16]
  ------------------
 1300|     16|    *dotGroup = BINDING_VALUE(frame);
 1301|     16|    frame = CDR(frame);
 1302|       |
 1303|     16|    if (TAG(frame) != R_dot_GenericCallEnv) goto slowpath;
  ------------------
  |  Branch (1303:9): [True: 0, False: 16]
  ------------------
 1304|     16|    *dotGenericCallEnv = BINDING_VALUE(frame);
 1305|     16|    frame = CDR(frame);
 1306|       |
 1307|     16|    if (TAG(frame) != R_dot_GenericDefEnv) goto slowpath;
  ------------------
  |  Branch (1307:9): [True: 0, False: 16]
  ------------------
 1308|     16|    *dotGenericDefEnv = BINDING_VALUE(frame);
 1309|       |
 1310|     16|    return;
 1311|       |
 1312|      0|slowpath:
 1313|       |    /* fall back to the slow but general implementation */
 1314|       |
 1315|      0|    *dotGeneric = R_findVarInFrame(rho, R_dot_Generic);
 1316|      0|    *dotClass = R_findVarInFrame(rho, R_dot_Class);
 1317|      0|    *dotMethod = R_findVarInFrame(rho, R_dot_Method);
 1318|      0|    *dotGroup = R_findVarInFrame(rho, R_dot_Group);
 1319|      0|    *dotGenericCallEnv = R_findVarInFrame(rho, R_dot_GenericCallEnv);
 1320|      0|    *dotGenericDefEnv = R_findVarInFrame(rho, R_dot_GenericDefEnv);
 1321|      0|}
R_findVar:
 1373|  2.72M|{
 1374|  2.72M|    SEXP vl;
 1375|       |
 1376|  2.72M|    if (TYPEOF(rho) == NILSXP)
  ------------------
  |  |  111|  2.72M|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1376:9): [True: 0, False: 2.72M]
  ------------------
 1377|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1378|       |
 1379|  2.72M|    if (!isEnvironment(rho))
  ------------------
  |  |  944|  2.72M|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (1379:9): [True: 0, False: 2.72M]
  ------------------
 1380|      0|	error(_("argument to '%s' is not an environment"), "findVar");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("argument to '%s' is not an environment"), "findVar");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1381|       |
 1382|  2.72M|#ifdef USE_GLOBAL_CACHE
 1383|       |    /* This first loop handles local frames, if there are any.  It
 1384|       |       will also handle all frames if rho is a global frame other than
 1385|       |       R_GlobalEnv */
 1386|  2.72M|    while (rho != R_GlobalEnv && rho != R_EmptyEnv) {
  ------------------
  |  Branch (1386:12): [True: 2.72M, False: 4]
  |  Branch (1386:34): [True: 2.72M, False: 0]
  ------------------
 1387|  2.72M|	vl = R_findVarInFrame(rho, symbol);
 1388|  2.72M|	if (vl != R_UnboundValue) return (vl);
  ------------------
  |  Branch (1388:6): [True: 2.72M, False: 1.10k]
  ------------------
 1389|  1.10k|	rho = ENCLOS(rho);
 1390|  1.10k|    }
 1391|      4|    if (rho == R_GlobalEnv)
  ------------------
  |  Branch (1391:9): [True: 4, False: 0]
  ------------------
 1392|      4|	return findGlobalVar(symbol);
 1393|      0|    else
 1394|      0|	return R_UnboundValue;
 1395|       |#else
 1396|       |    while (rho != R_EmptyEnv) {
 1397|       |	vl = R_findVarInFrame(rho, symbol);
 1398|       |	if (vl != R_UnboundValue) return (vl);
 1399|       |	rho = ENCLOS(rho);
 1400|       |    }
 1401|       |    return R_UnboundValue;
 1402|       |#endif
 1403|      4|}
Rf_findVar:
 1406|      4|{
 1407|      4|    return R_findVar(symbol, rho);
 1408|      4|}
R_findVarLoc:
 1444|  44.7k|{
 1445|  44.7k|    SEXP binding = findVarLoc(symbol, rho);
 1446|  44.7k|    R_varloc_t val;
 1447|  44.7k|    val.cell = binding == R_NilValue ? NULL : binding;
  ------------------
  |  Branch (1447:16): [True: 0, False: 44.7k]
  ------------------
 1448|  44.7k|    return val;
 1449|  44.7k|}
R_findDotsEnv:
 1582|  1.94k|{
 1583|  1.94k|    while (env != R_EmptyEnv) {
  ------------------
  |  Branch (1583:12): [True: 1.94k, False: 0]
  ------------------
 1584|  1.94k|	SEXP vl = R_findVarInFrame(env, R_DotsSymbol);
 1585|  1.94k|	if (vl != R_UnboundValue &&
  ------------------
  |  Branch (1585:6): [True: 1.94k, False: 0]
  ------------------
 1586|  1.94k|	    (vl == R_MissingArg || TYPEOF(vl) == DOTSXP))
  ------------------
  |  |  127|  1.93k|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (1586:7): [True: 10, False: 1.93k]
  |  Branch (1586:29): [True: 1.93k, False: 0]
  ------------------
 1587|  1.94k|	    return env;
 1588|      0|	env = ENCLOS(env);
 1589|      0|    }
 1590|      0|    return R_EmptyEnv;
 1591|  1.94k|}
R_DotsElt:
 1648|    952|{
 1649|    952|    SEXP val = ddfindInFrame(i, env);
 1650|    952|    if (TYPEOF(val) == PROMSXP || val == R_MissingArg)
  ------------------
  |  |  116|  1.90k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (1650:9): [True: 952, False: 0]
  |  Branch (1650:35): [True: 0, False: 0]
  ------------------
 1651|    952|	return eval(val, env);
  ------------------
  |  |  913|    952|#define eval			Rf_eval
  ------------------
 1652|      0|    else
 1653|      0|	return val;
 1654|    952|}
do_dotsElt:
 1657|    952|{
 1658|    952|    checkArity(op, args);
  ------------------
  |  | 1788|    952|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1659|    952|    check1arg(args, call, "n");
  ------------------
  |  | 1867|    952|# define check1arg		Rf_check1arg
  ------------------
 1660|       |
 1661|    952|    SEXP si = CAR(args);
 1662|    952|    if (! isNumeric(si) || XLENGTH(si) != 1)
  ------------------
  |  |  957|    952|#define isNumeric		Rf_isNumeric
  ------------------
  |  Branch (1662:9): [True: 0, False: 952]
  |  Branch (1662:28): [True: 0, False: 952]
  ------------------
 1663|      0|	errorcall(call, _("indexing '...' with an invalid index"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("indexing '...' with an invalid index"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1664|    952|    int i = asInteger(si);
  ------------------
  |  |  885|    952|#define asInteger		Rf_asInteger
  ------------------
 1665|    952|    return R_DotsElt(i, R_findDotsEnv(env));
 1666|    952|}
R_DotsLength:
 1669|    952|{
 1670|    952|    SEXP vl = R_findVarInFrame(env, R_DotsSymbol);
 1671|    952|    if (vl == R_UnboundValue)
  ------------------
  |  Branch (1671:9): [True: 0, False: 952]
  ------------------
 1672|      0|	error(_("incorrect context: the current call has no '...' to look in"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("incorrect context: the current call has no '...' to look in"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1673|    952|    return length_DOTS(vl);
  ------------------
  |  | 1578|    952|#define length_DOTS(_v_) (TYPEOF(_v_) == DOTSXP ? length(_v_) : 0)
  |  |  ------------------
  |  |  |  |  127|    952|#define DOTSXP	    17	  /* dot-dot-dot object */
  |  |  ------------------
  |  |               #define length_DOTS(_v_) (TYPEOF(_v_) == DOTSXP ? length(_v_) : 0)
  |  |  ------------------
  |  |  |  |  987|    952|#define length(x)		Rf_length(x)
  |  |  ------------------
  |  |  |  Branch (1578:27): [True: 952, False: 0]
  |  |  ------------------
  ------------------
 1674|    952|}
do_dotsLength:
 1677|    952|{
 1678|    952|    checkArity(op, args);
  ------------------
  |  | 1788|    952|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1679|    952|    return ScalarInteger(R_DotsLength(R_findDotsEnv(env)));
  ------------------
  |  | 1022|    952|#define ScalarInteger		Rf_ScalarInteger
  ------------------
 1680|    952|}
R_DotsNames:
 1683|     40|{
 1684|     40|    SEXP vl = R_findVarInFrame(env, R_DotsSymbol);
 1685|     40|    PROTECT(vl);
  ------------------
  |  |  357|     40|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1686|     40|    if (vl == R_UnboundValue)
  ------------------
  |  Branch (1686:9): [True: 0, False: 40]
  ------------------
 1687|      0|	error(_("incorrect context: the current call has no '...' to look in"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("incorrect context: the current call has no '...' to look in"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1688|     40|    SEXP out = R_NilValue;
 1689|     40|    int n = length_DOTS(vl);
  ------------------
  |  | 1578|     40|#define length_DOTS(_v_) (TYPEOF(_v_) == DOTSXP ? length(_v_) : 0)
  |  |  ------------------
  |  |  |  |  127|     40|#define DOTSXP	    17	  /* dot-dot-dot object */
  |  |  ------------------
  |  |               #define length_DOTS(_v_) (TYPEOF(_v_) == DOTSXP ? length(_v_) : 0)
  |  |  ------------------
  |  |  |  |  987|     30|#define length(x)		Rf_length(x)
  |  |  ------------------
  |  |  |  Branch (1578:27): [True: 30, False: 10]
  |  |  ------------------
  ------------------
 1690|     70|    for(int i = 0; i < n; i++) {
  ------------------
  |  Branch (1690:20): [True: 30, False: 40]
  ------------------
 1691|     30|	if(TAG(vl) != R_NilValue) {
  ------------------
  |  Branch (1691:5): [True: 30, False: 0]
  ------------------
 1692|     30|	    if(out == R_NilValue) {
  ------------------
  |  Branch (1692:9): [True: 30, False: 0]
  ------------------
 1693|       |		// this fills 'out' with ""
 1694|     30|		PROTECT(out = allocVector(STRSXP, n));
  ------------------
  |  |  357|     30|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1695|     30|	    }
 1696|     30|	    SET_STRING_ELT(out, i, PRINTNAME(TAG(vl)));
 1697|     30|	}
 1698|     30|        vl = CDR(vl);
 1699|     30|    }
 1700|     40|    if(out != R_NilValue)
  ------------------
  |  Branch (1700:8): [True: 30, False: 10]
  ------------------
 1701|     30|        UNPROTECT(1); // out
  ------------------
  |  |  358|     30|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1702|     40|    UNPROTECT(1); // vl
  ------------------
  |  |  358|     40|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1703|     40|    return out;
 1704|     40|}
do_dotsNames:
 1707|     40|{
 1708|     40|    checkArity(op, args);
  ------------------
  |  | 1788|     40|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1709|     40|    return R_DotsNames(R_findDotsEnv(env));
 1710|     40|}
Rf_findFun3:
 1882|  7.02M|{
 1883|  7.02M|    SEXP vl;
 1884|       |
 1885|       |    /* If the symbol is marked as special, skip to the first
 1886|       |       environment that might contain such a symbol. */
 1887|  7.02M|    if (IS_SPECIAL_SYMBOL(symbol)) {
  ------------------
  |  Branch (1887:9): [True: 781k, False: 6.24M]
  ------------------
 1888|  1.56M|	while (rho != R_EmptyEnv && NO_SPECIAL_SYMBOLS(rho))
  ------------------
  |  Branch (1888:9): [True: 1.56M, False: 0]
  |  Branch (1888:30): [True: 782k, False: 781k]
  ------------------
 1889|   782k|	    rho = ENCLOS(rho);
 1890|   781k|    }
 1891|       |
 1892|  13.6M|    while (rho != R_EmptyEnv) {
  ------------------
  |  Branch (1892:12): [True: 13.6M, False: 1.90k]
  ------------------
 1893|       |	/* This is not really right.  Any variable can mask a function */
 1894|  13.6M|#ifdef USE_GLOBAL_CACHE
 1895|  13.6M|	if (rho == R_GlobalEnv)
  ------------------
  |  Branch (1895:6): [True: 2, False: 13.6M]
  ------------------
 1896|      2|#ifdef FAST_BASE_CACHE_LOOKUP
 1897|      2|	    if (BASE_SYM_CACHED(symbol))
  ------------------
  |  Branch (1897:10): [True: 0, False: 2]
  ------------------
 1898|      0|		vl = SYMBOL_BINDING_VALUE(symbol);
  ------------------
  |  |  123|      0|#define SYMBOL_BINDING_VALUE(s) ((IS_ACTIVE_BINDING(s) ? getActiveValue(SYMVALUE(s)) : SYMVALUE(s)))
  |  |  ------------------
  |  |  |  Branch (123:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1899|      2|	    else
 1900|      2|		vl = findGlobalVar(symbol);
 1901|       |#else
 1902|       |	    vl = findGlobalVar(symbol);
 1903|       |#endif
 1904|  13.6M|	else
 1905|  13.6M|	    vl = R_findVarInFrame(rho, symbol);
 1906|       |#else
 1907|       |	vl = R_findVarInFrame(rho, symbol);
 1908|       |#endif
 1909|  13.6M|	if (vl != R_UnboundValue) {
  ------------------
  |  Branch (1909:6): [True: 7.02M, False: 6.64M]
  ------------------
 1910|  7.02M|	    if (TYPEOF(vl) == PROMSXP) {
  ------------------
  |  |  116|  7.02M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (1910:10): [True: 2.35M, False: 4.66M]
  ------------------
 1911|  2.35M|		if (PROMISE_IS_EVALUATED(vl))
  ------------------
  |  Branch (1911:7): [True: 2.35M, False: 495]
  ------------------
 1912|  2.35M|		    vl = PRVALUE(vl);
 1913|    495|		else {
 1914|    495|		    PROTECT(vl);
  ------------------
  |  |  357|    495|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1915|    495|		    vl = eval(vl, rho);
  ------------------
  |  |  913|    495|#define eval			Rf_eval
  ------------------
 1916|    495|		    UNPROTECT(1);
  ------------------
  |  |  358|    495|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1917|    495|		}
 1918|  2.35M|	    }
 1919|  7.02M|	    if (TYPEOF(vl) == CLOSXP || TYPEOF(vl) == BUILTINSXP ||
  ------------------
  |  |  114|  14.0M|#define CLOSXP	     3	  /* closures */
  ------------------
              	    if (TYPEOF(vl) == CLOSXP || TYPEOF(vl) == BUILTINSXP ||
  ------------------
  |  |  119|  10.1M|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (1919:10): [True: 3.90M, False: 3.11M]
  |  Branch (1919:34): [True: 2.32M, False: 782k]
  ------------------
 1920|   782k|		TYPEOF(vl) == SPECIALSXP)
  ------------------
  |  |  118|   782k|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (1920:3): [True: 782k, False: 14]
  ------------------
 1921|  7.02M|		return (vl);
 1922|     14|	    if (vl == R_MissingArg)
  ------------------
  |  Branch (1922:10): [True: 0, False: 14]
  ------------------
 1923|      0|	        R_MissingArgError(symbol, call, "getMissingError");
 1924|       |
 1925|     14|	}
 1926|  6.64M|	rho = ENCLOS(rho);
 1927|  6.64M|    }
 1928|  1.90k|    R_FunctionNotFoundError(symbol, call);
 1929|       |    /* NOT REACHED */
 1930|  1.90k|    return R_UnboundValue;
 1931|  7.02M|}
Rf_findFun:
 1934|  5.84M|{
 1935|  5.84M|    return findFun3(symbol, rho, R_CurrentExpression);
  ------------------
  |  |  916|  5.84M|#define findFun3		Rf_findFun3
  ------------------
 1936|  5.84M|}
Rf_defineVar:
 1947|  9.71M|{
 1948|  9.71M|    int hashcode;
 1949|  9.71M|    SEXP frame, c;
 1950|       |
 1951|  9.71M|    if (value == R_UnboundValue)
  ------------------
  |  Branch (1951:9): [True: 0, False: 9.71M]
  ------------------
 1952|      0|	error("attempt to bind a variable to R_UnboundValue");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 1953|       |    /* R_DirtyImage should only be set if assigning to R_GlobalEnv. */
 1954|  9.71M|    if (rho == R_GlobalEnv) R_DirtyImage = 1;
  ------------------
  |  Branch (1954:9): [True: 2, False: 9.71M]
  ------------------
 1955|       |
 1956|  9.71M|    if (rho == R_EmptyEnv)
  ------------------
  |  Branch (1956:9): [True: 0, False: 9.71M]
  ------------------
 1957|      0|	error(_("cannot assign values in the empty environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot assign values in the empty environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1958|       |
 1959|  9.71M|    if(IS_USER_DATABASE(rho)) {
  ------------------
  |  |  102|  9.71M|#define IS_USER_DATABASE(rho)  (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  ------------------
  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  ------------------
  |  |  |  Branch (102:33): [True: 0, False: 9.71M]
  |  |  |  Branch (102:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1960|      0|	R_ObjectTable *table;
 1961|      0|	table = (R_ObjectTable *) R_ExternalPtrAddr(HASHTAB(rho));
 1962|      0|	if(table->assign == NULL)
  ------------------
  |  Branch (1962:5): [True: 0, False: 0]
  ------------------
 1963|      0|	    error(_("cannot assign variables to this database"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("cannot assign variables to this database"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1964|      0|	PROTECT(value);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1965|      0|	table->assign(CHAR(PRINTNAME(symbol)), value, table);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1966|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1967|      0|#ifdef USE_GLOBAL_CACHE
 1968|      0|	if (IS_GLOBAL_FRAME(rho)) R_FlushGlobalCache(symbol);
  ------------------
  |  |  653|      0|#define IS_GLOBAL_FRAME(e) (ENVFLAGS(e) & GLOBAL_FRAME_MASK)
  |  |  ------------------
  |  |  |  |  652|      0|#define GLOBAL_FRAME_MASK (1<<15)
  |  |  ------------------
  |  |  |  Branch (653:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1969|      0|#endif
 1970|      0|	return;
 1971|      0|    }
 1972|       |
 1973|  9.71M|    if (rho == R_BaseNamespace || rho == R_BaseEnv) {
  ------------------
  |  Branch (1973:9): [True: 58, False: 9.71M]
  |  Branch (1973:35): [True: 2.37k, False: 9.70M]
  ------------------
 1974|  2.43k|	gsetVar(symbol, value, rho);
  ------------------
  |  |  932|  2.43k|#define gsetVar			Rf_gsetVar
  ------------------
 1975|  9.70M|    } else {
 1976|  9.70M|#ifdef USE_GLOBAL_CACHE
 1977|  9.70M|	if (IS_GLOBAL_FRAME(rho)) R_FlushGlobalCache(symbol);
  ------------------
  |  |  653|  9.70M|#define IS_GLOBAL_FRAME(e) (ENVFLAGS(e) & GLOBAL_FRAME_MASK)
  |  |  ------------------
  |  |  |  |  652|  9.70M|#define GLOBAL_FRAME_MASK (1<<15)
  |  |  ------------------
  |  |  |  Branch (653:28): [True: 2.80k, False: 9.70M]
  |  |  ------------------
  ------------------
 1978|  9.70M|#endif
 1979|       |
 1980|  9.70M|	if (IS_SPECIAL_SYMBOL(symbol))
  ------------------
  |  Branch (1980:6): [True: 145, False: 9.70M]
  ------------------
 1981|    145|	    UNSET_NO_SPECIAL_SYMBOLS(rho);
 1982|       |
 1983|  9.70M|	if (HASHTAB(rho) == R_NilValue) {
  ------------------
  |  Branch (1983:6): [True: 9.68M, False: 20.2k]
  ------------------
 1984|       |	    /* First check for an existing binding */
 1985|  9.68M|	    frame = FRAME(rho);
 1986|  45.7M|	    while (frame != R_NilValue) {
  ------------------
  |  Branch (1986:13): [True: 36.4M, False: 9.29M]
  ------------------
 1987|  36.4M|		if (TAG(frame) == symbol) {
  ------------------
  |  Branch (1987:7): [True: 390k, False: 36.0M]
  ------------------
 1988|   390k|		    SET_BINDING_VALUE(frame, value);
  ------------------
  |  |  126|   390k|#define SET_BINDING_VALUE(b,val) do { \
  |  |  127|   390k|  SEXP __b__ = (b); \
  |  |  128|   390k|  SEXP __val__ = (val); \
  |  |  129|   390k|  if (BINDING_IS_LOCKED(__b__)) \
  |  |  ------------------
  |  |  |  Branch (129:7): [True: 0, False: 390k]
  |  |  ------------------
  |  |  130|   390k|    error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |                   error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  131|      0|	  CHAR(PRINTNAME(TAG(__b__)))); \
  |  |  ------------------
  |  |  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  |  |  132|   390k|  if (IS_ACTIVE_BINDING(__b__)) { \
  |  |  ------------------
  |  |  |  Branch (132:7): [True: 0, False: 390k]
  |  |  ------------------
  |  |  133|      0|    PROTECT(__val__); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  134|      0|    setActiveValue(CAR(__b__), __val__); \
  |  |  135|      0|    UNPROTECT(1); \
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |  136|      0|   } else \
  |  |  137|   390k|    SET_BNDCELL(__b__, __val__); \
  |  |  138|   390k|} while (0)
  |  |  ------------------
  |  |  |  Branch (138:10): [Folded, False: 390k]
  |  |  ------------------
  ------------------
 1989|   390k|		    SET_MISSING(frame, 0);	/* Over-ride */
 1990|   390k|		    return;
 1991|   390k|		}
 1992|  36.0M|		frame = CDR(frame);
 1993|  36.0M|	    }
 1994|  9.29M|	    if (FRAME_IS_LOCKED(rho))
  ------------------
  |  |  107|  9.29M|#define FRAME_IS_LOCKED(e) (ENVFLAGS(e) & FRAME_LOCK_MASK)
  |  |  ------------------
  |  |  |  |  106|  9.29M|#define FRAME_LOCK_MASK (1<<14)
  |  |  ------------------
  |  |  |  Branch (107:28): [True: 0, False: 9.29M]
  |  |  ------------------
  ------------------
 1995|      0|		error(_("cannot add bindings to a locked environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("cannot add bindings to a locked environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1996|  9.29M|	    SET_FRAME(rho, CONS(value, FRAME(rho)));
  ------------------
  |  |  309|  9.29M|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 1997|  9.29M|	    SET_TAG(FRAME(rho), symbol);
 1998|  9.29M|	}
 1999|  20.2k|	else {
 2000|  20.2k|	    c = PRINTNAME(symbol);
 2001|  20.2k|	    if( !HASHASH(c) ) {
  ------------------
  |  Branch (2001:10): [True: 0, False: 20.2k]
  ------------------
 2002|      0|		SET_HASHVALUE(c, R_Newhashpjw(CHAR(c)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 2003|      0|		SET_HASHASH(c, 1);
 2004|      0|	    }
 2005|  20.2k|	    hashcode = HASHVALUE(c) % HASHSIZE(HASHTAB(rho));
  ------------------
  |  |  205|  20.2k|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
 2006|  20.2k|	    R_HashSet(hashcode, symbol, HASHTAB(rho), value,
 2007|  20.2k|		      (Rboolean) FRAME_IS_LOCKED(rho));
  ------------------
  |  |  107|  20.2k|#define FRAME_IS_LOCKED(e) (ENVFLAGS(e) & FRAME_LOCK_MASK)
  |  |  ------------------
  |  |  |  |  106|  20.2k|#define FRAME_LOCK_MASK (1<<14)
  |  |  ------------------
  ------------------
 2008|  20.2k|	    if (R_HashSizeCheck(HASHTAB(rho)))
  ------------------
  |  Branch (2008:10): [True: 601, False: 19.6k]
  ------------------
 2009|    601|		SET_HASHTAB(rho, R_HashResize(HASHTAB(rho)));
 2010|  20.2k|	}
 2011|  9.70M|    }
 2012|  9.71M|}
Rf_addMissingVarsToNewEnv:
 2030|    433|{
 2031|    433|    if (addVars == R_NilValue) return;
  ------------------
  |  Branch (2031:9): [True: 0, False: 433]
  ------------------
 2032|       |
 2033|       |    /* temporary sanity check */
 2034|    433|    if (TYPEOF(addVars) == ENVSXP)
  ------------------
  |  |  115|    433|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (2034:9): [True: 0, False: 433]
  ------------------
 2035|      0|	error("additional variables should now be passed as a list, "
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 2036|      0|	      "not in an environment");
 2037|       |
 2038|       |    /* append variables from env after addVars */
 2039|    433|    SEXP aprev = addVars;
 2040|    433|    SEXP a = CDR(addVars);
 2041|  2.59k|    while (a != R_NilValue) {
  ------------------
  |  Branch (2041:12): [True: 2.16k, False: 433]
  ------------------
 2042|  2.16k|	aprev = a;
 2043|  2.16k|	a = CDR(a);
 2044|  2.16k|    }
 2045|    433|    SETCDR(aprev, FRAME(env));
 2046|    433|    SET_FRAME(env, addVars);
 2047|       |
 2048|       |    /* remove duplicates - a variable listed later has precedence over a
 2049|       |       variable listed sooner */
 2050|    433|    SEXP end;
 2051|  3.87k|    for(end = CDR(addVars); end != R_NilValue; end = CDR(end)) {
  ------------------
  |  Branch (2051:29): [True: 3.44k, False: 433]
  ------------------
 2052|  3.44k|	SEXP endTag = TAG(end);
 2053|  3.44k|	SEXP sprev = R_NilValue;
 2054|  3.44k|	SEXP s;
 2055|  19.1k|	for(s = addVars; s != end; s = CDR(s)) {
  ------------------
  |  Branch (2055:19): [True: 15.7k, False: 3.44k]
  ------------------
 2056|  15.7k|	    if (TAG(s) == endTag) {
  ------------------
  |  Branch (2056:10): [True: 0, False: 15.7k]
  ------------------
 2057|       |		/* remove variable s from the list, because it is overridden by "end" */
 2058|      0|		if (sprev == R_NilValue) {
  ------------------
  |  Branch (2058:7): [True: 0, False: 0]
  ------------------
 2059|      0|		    addVars = CDR(s);
 2060|      0|		    SET_FRAME(env, addVars);
 2061|      0|		} else
 2062|      0|		    SETCDR(sprev, CDR(s));
 2063|      0|	    } else
 2064|  15.7k|		sprev = s;
 2065|  15.7k|	}
 2066|  3.44k|    }
 2067|    433|}
Rf_setVar:
 2152|  2.25k|{
 2153|  2.25k|    SEXP vl;
 2154|  3.67k|    while (rho != R_EmptyEnv) {
  ------------------
  |  Branch (2154:12): [True: 3.67k, False: 0]
  ------------------
 2155|  3.67k|	vl = setVarInFrame(rho, symbol, value);
 2156|  3.67k|	if (vl != R_NilValue) return;
  ------------------
  |  Branch (2156:6): [True: 2.25k, False: 1.41k]
  ------------------
 2157|  1.41k|	rho = ENCLOS(rho);
 2158|  1.41k|    }
 2159|      0|    defineVar(symbol, value, R_GlobalEnv);
  ------------------
  |  |  905|      0|#define defineVar		Rf_defineVar
  ------------------
 2160|      0|}
Rf_gsetVar:
 2174|  2.44k|{
 2175|  2.44k|    if (FRAME_IS_LOCKED(rho)) {
  ------------------
  |  |  107|  2.44k|#define FRAME_IS_LOCKED(e) (ENVFLAGS(e) & FRAME_LOCK_MASK)
  |  |  ------------------
  |  |  |  |  106|  2.44k|#define FRAME_LOCK_MASK (1<<14)
  |  |  ------------------
  |  |  |  Branch (107:28): [True: 0, False: 2.44k]
  |  |  ------------------
  ------------------
 2176|      0|	if(SYMVALUE(symbol) == R_UnboundValue)
  ------------------
  |  Branch (2176:5): [True: 0, False: 0]
  ------------------
 2177|      0|	    error(_("cannot add binding of '%s' to the base environment"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("cannot add binding of '%s' to the base environment"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2178|      0|		  CHAR(PRINTNAME(symbol)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 2179|      0|    }
 2180|  2.44k|#ifdef USE_GLOBAL_CACHE
 2181|  2.44k|    R_FlushGlobalCache(symbol);
 2182|  2.44k|#endif
 2183|       |    SET_SYMBOL_BINDING_VALUE(symbol, value);
  ------------------
  |  |  140|  2.44k|#define SET_SYMBOL_BINDING_VALUE(sym, val) do { \
  |  |  141|  2.44k|  SEXP __sym__ = (sym); \
  |  |  142|  2.44k|  SEXP __val__ = (val); \
  |  |  143|  2.44k|  if (BINDING_IS_LOCKED(__sym__)) \
  |  |  ------------------
  |  |  |  Branch (143:7): [True: 0, False: 2.44k]
  |  |  ------------------
  |  |  144|  2.44k|    error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |                   error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|	  CHAR(PRINTNAME(__sym__))); \
  |  |  ------------------
  |  |  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  |  |  146|  2.44k|  if (IS_ACTIVE_BINDING(__sym__)) { \
  |  |  ------------------
  |  |  |  Branch (146:7): [True: 6, False: 2.43k]
  |  |  ------------------
  |  |  147|      6|    PROTECT(__val__); \
  |  |  ------------------
  |  |  |  |  357|      6|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  148|      6|    setActiveValue(SYMVALUE(__sym__), __val__); \
  |  |  149|      6|    UNPROTECT(1); \
  |  |  ------------------
  |  |  |  |  358|      6|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |  150|      6|  } else \
  |  |  151|  2.44k|    SET_SYMVALUE(__sym__, __val__); \
  |  |  152|  2.44k|} while (0)
  |  |  ------------------
  |  |  |  Branch (152:10): [Folded, False: 2.44k]
  |  |  ------------------
  ------------------
 2184|  2.44k|}
do_assign:
 2197|    112|{
 2198|    112|    SEXP name=R_NilValue, val, aenv;
 2199|    112|    int ginherits = 0;
 2200|    112|    checkArity(op, args);
  ------------------
  |  | 1788|    112|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2201|       |
 2202|    112|    if (!isString(CAR(args)) || length(CAR(args)) == 0)
  ------------------
  |  |  966|    112|#define isString		Rf_isString
  ------------------
                  if (!isString(CAR(args)) || length(CAR(args)) == 0)
  ------------------
  |  |  987|    112|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (2202:9): [True: 0, False: 112]
  |  Branch (2202:33): [True: 0, False: 112]
  ------------------
 2203|      0|	error(_("invalid first argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid first argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2204|    112|    else {
 2205|    112|	if (length(CAR(args)) > 1)
  ------------------
  |  |  987|    112|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (2205:6): [True: 0, False: 112]
  ------------------
 2206|      0|	    warning(_("only the first element is used as variable name"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("only the first element is used as variable name"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2207|    112|	name = installTrChar(STRING_ELT(CAR(args), 0));
  ------------------
  |  |  937|    112|#define installTrChar		Rf_installTrChar
  ------------------
 2208|    112|    }
 2209|    112|    PROTECT(val = CADR(args));
  ------------------
  |  |  357|    112|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2210|    112|    aenv = CADDR(args);
 2211|    112|    if (TYPEOF(aenv) == NILSXP)
  ------------------
  |  |  111|    112|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (2211:9): [True: 0, False: 112]
  ------------------
 2212|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2213|    112|    if (TYPEOF(aenv) != ENVSXP &&
  ------------------
  |  |  115|    224|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (2213:9): [True: 0, False: 112]
  ------------------
 2214|      0|	TYPEOF((aenv = simple_as_environment(aenv))) != ENVSXP)
  ------------------
  |  | 2187|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (2187:37): [True: 0, False: 0]
  |  |  |  Branch (2187:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	TYPEOF((aenv = simple_as_environment(aenv))) != ENVSXP)
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (2214:2): [True: 0, False: 0]
  ------------------
 2215|      0|	error(_("invalid '%s' argument"), "envir");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "envir");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2216|    112|    ginherits = asLogical(CADDDR(args));
  ------------------
  |  |  886|    112|#define asLogical		Rf_asLogical
  ------------------
 2217|    112|    if (ginherits == NA_LOGICAL)
  ------------------
  |  |   55|    112|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (2217:9): [True: 0, False: 112]
  ------------------
 2218|      0|	error(_("invalid '%s' argument"), "inherits");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "inherits");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2219|    112|    if (ginherits)
  ------------------
  |  Branch (2219:9): [True: 0, False: 112]
  ------------------
 2220|      0|	setVar(name, val, aenv);
  ------------------
  |  | 1029|      0|#define setVar			Rf_setVar
  ------------------
 2221|    112|    else
 2222|    112|	defineVar(name, val, aenv);
  ------------------
  |  |  905|    112|#define defineVar		Rf_defineVar
  ------------------
 2223|    112|    UNPROTECT(1);
  ------------------
  |  |  358|    112|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2224|    112|    return val;
 2225|    112|}
do_list2env:
 2232|    607|{
 2233|    607|    SEXP x, xnms, envir;
 2234|    607|    int n;
 2235|    607|    checkArity(op, args);
  ------------------
  |  | 1788|    607|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2236|       |
 2237|    607|    if (TYPEOF(CAR(args)) != VECSXP)
  ------------------
  |  |  131|    607|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2237:9): [True: 0, False: 607]
  ------------------
 2238|      0|	error(_("first argument must be a named list"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("first argument must be a named list"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2239|    607|    x = CAR(args);
 2240|    607|    n = LENGTH(x);
 2241|    607|    xnms = getAttrib(x, R_NamesSymbol);
  ------------------
  |  |  924|    607|#define getAttrib		Rf_getAttrib
  ------------------
 2242|    607|    PROTECT(xnms);
  ------------------
  |  |  357|    607|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2243|    607|    if (n && (TYPEOF(xnms) != STRSXP || LENGTH(xnms) != n))
  ------------------
  |  |  126|  1.10k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2243:9): [True: 551, False: 56]
  |  Branch (2243:15): [True: 0, False: 551]
  |  Branch (2243:41): [True: 0, False: 551]
  ------------------
 2244|      0|	error(_("names(x) must be a character vector of the same length as x"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("names(x) must be a character vector of the same length as x"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2245|    607|    envir = CADR(args);
 2246|    607|    if (TYPEOF(envir) != ENVSXP)
  ------------------
  |  |  115|    607|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (2246:9): [True: 0, False: 607]
  ------------------
 2247|      0|	error(_("'envir' argument must be an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'envir' argument must be an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2248|       |
 2249|  7.62k|    for(int i = 0; i < n; i++) {
  ------------------
  |  Branch (2249:20): [True: 7.02k, False: 607]
  ------------------
 2250|  7.02k|	SEXP name = installTrChar(STRING_ELT(xnms, i));
  ------------------
  |  |  937|  7.02k|#define installTrChar		Rf_installTrChar
  ------------------
 2251|  7.02k|	defineVar(name, lazy_duplicate(VECTOR_ELT(x, i)), envir);
  ------------------
  |  |  905|  7.02k|#define defineVar		Rf_defineVar
  ------------------
              	defineVar(name, lazy_duplicate(VECTOR_ELT(x, i)), envir);
  ------------------
  |  |  985|  7.02k|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
 2252|  7.02k|    }
 2253|    607|    UNPROTECT(1); /* xnms */
  ------------------
  |  |  358|    607|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2254|       |
 2255|    607|    return envir;
 2256|    607|}
R_removeVarFromFrame:
 2358|      2|{
 2359|      2|    int hashcode = -1;
 2360|       |
 2361|      2|    if (TYPEOF(env) == NILSXP)
  ------------------
  |  |  111|      2|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (2361:9): [True: 0, False: 2]
  ------------------
 2362|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2363|       |
 2364|      2|    if (!isEnvironment(env))
  ------------------
  |  |  944|      2|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (2364:9): [True: 0, False: 2]
  ------------------
 2365|      0|	error(_("argument to '%s' is not an environment"), "R_removeVarFromFrame");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("argument to '%s' is not an environment"), "R_removeVarFromFrame");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2366|       |
 2367|      2|    if (TYPEOF(name) != SYMSXP)
  ------------------
  |  |  112|      2|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (2367:9): [True: 0, False: 2]
  ------------------
 2368|      0|	error(_("not a symbol"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not a symbol"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2369|       |
 2370|      2|    if (IS_HASHED(env)) {
  ------------------
  |  |  212|      2|#define IS_HASHED(x)	     (HASHTAB(x) != R_NilValue)
  |  |  ------------------
  |  |  |  Branch (212:27): [True: 2, False: 0]
  |  |  ------------------
  ------------------
 2371|      2|	if( !HASHASH(PRINTNAME(name)))
  ------------------
  |  Branch (2371:6): [True: 0, False: 2]
  ------------------
 2372|      0|	    hashcode = R_Newhashpjw(CHAR(PRINTNAME(name)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 2373|      2|	else
 2374|      2|	    hashcode = HASHVALUE(PRINTNAME(name));
 2375|      2|    }
 2376|      2|    RemoveVariable(name, hashcode, env);
 2377|      2|}
do_get:
 2411|  3.82k|{
 2412|  3.82k|    SEXP rval, genv, t1 = R_NilValue;
 2413|  3.82k|    int ginherits = 0, where;
 2414|  3.82k|    checkArity(op, args);
  ------------------
  |  | 1788|  3.82k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2415|       |
 2416|       |    /* The first arg is the object name */
 2417|       |    /* It must be present and a non-empty string */
 2418|       |
 2419|  3.82k|    if (TYPEOF(CAR(args)) == SYMSXP)
  ------------------
  |  |  112|  3.82k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (2419:9): [True: 0, False: 3.82k]
  ------------------
 2420|      0|	t1 = CAR(args);
 2421|  3.82k|    else if (isValidStringF(CAR(args))) {
  ------------------
  |  |  973|  3.82k|#define isValidStringF		Rf_isValidStringF
  ------------------
  |  Branch (2421:14): [True: 3.82k, False: 0]
  ------------------
 2422|  3.82k|	if (XLENGTH(CAR(args)) > 1)
  ------------------
  |  Branch (2422:6): [True: 0, False: 3.82k]
  ------------------
 2423|      0|	    error(_("first argument has length > 1"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("first argument has length > 1"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2424|  3.82k|	t1 = installTrChar(STRING_ELT(CAR(args), 0));
  ------------------
  |  |  937|  3.82k|#define installTrChar		Rf_installTrChar
  ------------------
 2425|  3.82k|    }
 2426|      0|    else
 2427|      0|	error(_("invalid first argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid first argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2428|       |
 2429|       |    /* envir :	originally, the "where=" argument */
 2430|       |
 2431|  3.82k|    if (TYPEOF(CADR(args)) == ENVSXP)
  ------------------
  |  |  115|  3.82k|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (2431:9): [True: 3.82k, False: 0]
  ------------------
 2432|  3.82k|	genv = CADR(args);
 2433|      0|    else if (TYPEOF(CADR(args)) == REALSXP || TYPEOF(CADR(args)) == INTSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
                  else if (TYPEOF(CADR(args)) == REALSXP || TYPEOF(CADR(args)) == INTSXP) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2433:14): [True: 0, False: 0]
  |  Branch (2433:47): [True: 0, False: 0]
  ------------------
 2434|      0|	where = asInteger(CADR(args));
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
 2435|      0|	genv = R_sysframe(where, R_GlobalContext);
 2436|      0|    }
 2437|      0|    else if (TYPEOF(CADR(args)) == NILSXP) {
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (2437:14): [True: 0, False: 0]
  ------------------
 2438|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2439|      0|	genv = R_NilValue;  /* -Wall */
 2440|      0|    }
 2441|      0|    else if(TYPEOF((genv = simple_as_environment(CADR(args)))) != ENVSXP) {
  ------------------
  |  | 2187|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (2187:37): [True: 0, False: 0]
  |  |  |  Branch (2187:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  else if(TYPEOF((genv = simple_as_environment(CADR(args)))) != ENVSXP) {
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (2441:13): [True: 0, False: 0]
  ------------------
 2442|      0|	error(_("invalid '%s' argument"), "envir");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "envir");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2443|      0|	genv = R_NilValue;  /* -Wall */
 2444|      0|    }
 2445|       |
 2446|       |    /* mode :  The mode of the object being sought */
 2447|       |
 2448|       |    /* as from R 1.2.0, this is the *mode*, not the *typeof* aka
 2449|       |       storage.mode.
 2450|       |    */
 2451|       |
 2452|  3.82k|    SEXPTYPE gmode;
 2453|  3.82k|    Rboolean wants_S4 = FALSE;
 2454|  3.82k|    if (isString(CADDR(args)))
  ------------------
  |  |  966|  3.82k|#define isString		Rf_isString
  ------------------
  |  Branch (2454:9): [True: 3.82k, False: 0]
  ------------------
 2455|  3.82k|	gmode = str2mode(CHAR(STRING_ELT(CADDR(args), 0)), &wants_S4);
  ------------------
  |  |  203|  3.82k|#define CHAR(x) R_CHAR(x)
  ------------------
 2456|      0|    else {
 2457|      0|	error(_("invalid '%s' argument"), "mode");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "mode");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2458|      0|	gmode = FUNSXP;/* -Wall */
  ------------------
  |  |  144|      0|#define FUNSXP      99    /* Closure or Builtin or Special */
  ------------------
 2459|      0|    }
 2460|       |
 2461|  3.82k|    ginherits = asLogical(CADDDR(args));
  ------------------
  |  |  886|  3.82k|#define asLogical		Rf_asLogical
  ------------------
 2462|  3.82k|    if (ginherits == NA_LOGICAL)
  ------------------
  |  |   55|  3.82k|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (2462:9): [True: 0, False: 3.82k]
  ------------------
 2463|      0|	error(_("invalid '%s' argument"), "inherits");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "inherits");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2464|       |
 2465|       |    /* Search for the object */
 2466|  3.82k|    rval = findVar1mode(t1, genv, gmode, wants_S4, ginherits,
 2467|  3.82k|			(Rboolean) PRIMVAL(op));
  ------------------
  |  | 1347|  3.82k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
 2468|  3.82k|    if (rval == R_MissingArg) { // signal a *classed* error:
  ------------------
  |  Branch (2468:9): [True: 0, False: 3.82k]
  ------------------
 2469|      0|	R_MissingArgError(t1, call, "getMissingError");
 2470|      0|    }
 2471|       |
 2472|  3.82k|    switch (PRIMVAL(op) ) {
  ------------------
  |  | 1347|  3.82k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (1347:20): [True: 3.82k, False: 0]
  |  |  ------------------
  ------------------
 2473|  2.33k|    case 0: // exists(.) :
  ------------------
  |  Branch (2473:5): [True: 2.33k, False: 1.49k]
  ------------------
 2474|  2.33k|	return ScalarLogical(rval != R_UnboundValue);
  ------------------
  |  | 1023|  2.33k|#define ScalarLogical		Rf_ScalarLogical
  ------------------
 2475|      0|	break;
 2476|       |
 2477|    957|    case 1: // have get(.)
  ------------------
  |  Branch (2477:5): [True: 957, False: 2.86k]
  ------------------
 2478|    957|	if (rval == R_UnboundValue) {
  ------------------
  |  Branch (2478:6): [True: 0, False: 957]
  ------------------
 2479|      0|	    if (gmode == ANYSXP)
  ------------------
  |  |  128|      0|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
  |  Branch (2479:10): [True: 0, False: 0]
  ------------------
 2480|      0|		R_ObjectNotFoundError(t1, R_CurrentExpression, NULL);
 2481|      0|	    else
 2482|      0|		R_ObjectNotFoundError(t1, R_CurrentExpression,
 2483|      0|				      CHAR(STRING_ELT(CADDR(args), 0))); /* ASCII */
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 2484|      0|	}
 2485|       |
 2486|    957|#     define GET_VALUE(rval) do {				\
 2487|       |	    /* We need to evaluate if it is a promise */	\
 2488|    957|	    if (TYPEOF(rval) == PROMSXP) {			\
 2489|    957|		PROTECT(rval);					\
 2490|    957|		rval = eval(rval, genv);			\
 2491|    957|		UNPROTECT(1);					\
 2492|    957|	    }							\
 2493|    957|	    ENSURE_NAMED(rval);					\
 2494|    957|	} while (0)
 2495|       |
 2496|    957|	GET_VALUE(rval);
  ------------------
  |  | 2486|    957|#     define GET_VALUE(rval) do {				\
  |  | 2487|    957|	    /* We need to evaluate if it is a promise */	\
  |  | 2488|    957|	    if (TYPEOF(rval) == PROMSXP) {			\
  |  |  ------------------
  |  |  |  |  116|    957|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (2488:10): [True: 846, False: 111]
  |  |  ------------------
  |  | 2489|    846|		PROTECT(rval);					\
  |  |  ------------------
  |  |  |  |  357|    846|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  | 2490|    846|		rval = eval(rval, genv);			\
  |  |  ------------------
  |  |  |  |  913|    846|#define eval			Rf_eval
  |  |  ------------------
  |  | 2491|    846|		UNPROTECT(1);					\
  |  |  ------------------
  |  |  |  |  358|    846|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  | 2492|    846|	    }							\
  |  | 2493|    957|	    ENSURE_NAMED(rval);					\
  |  | 2494|    957|	} while (0)
  |  |  ------------------
  |  |  |  Branch (2494:11): [Folded, False: 957]
  |  |  ------------------
  ------------------
 2497|    957|	break;
 2498|       |
 2499|    534|    case 2: // get0(.)
  ------------------
  |  Branch (2499:5): [True: 534, False: 3.29k]
  ------------------
 2500|    534|	if (rval == R_UnboundValue)
  ------------------
  |  Branch (2500:6): [True: 388, False: 146]
  ------------------
 2501|    388|	    return CAD4R(args);// i.e.  value_if_not_exists
 2502|    146|	GET_VALUE(rval);
  ------------------
  |  | 2486|    146|#     define GET_VALUE(rval) do {				\
  |  | 2487|    146|	    /* We need to evaluate if it is a promise */	\
  |  | 2488|    146|	    if (TYPEOF(rval) == PROMSXP) {			\
  |  |  ------------------
  |  |  |  |  116|    146|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (2488:10): [True: 60, False: 86]
  |  |  ------------------
  |  | 2489|     60|		PROTECT(rval);					\
  |  |  ------------------
  |  |  |  |  357|     60|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  | 2490|     60|		rval = eval(rval, genv);			\
  |  |  ------------------
  |  |  |  |  913|     60|#define eval			Rf_eval
  |  |  ------------------
  |  | 2491|     60|		UNPROTECT(1);					\
  |  |  ------------------
  |  |  |  |  358|     60|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  | 2492|     60|	    }							\
  |  | 2493|    146|	    ENSURE_NAMED(rval);					\
  |  | 2494|    146|	} while (0)
  |  |  ------------------
  |  |  |  Branch (2494:11): [Folded, False: 146]
  |  |  ------------------
  ------------------
 2503|    146|	break;
 2504|  3.82k|    }
 2505|  1.10k|    return rval;
 2506|  3.82k|}
do_mget:
 2548|     20|{
 2549|     20|    SEXP ans, env, x, mode, ifnotfound;
 2550|     20|    int ginherits = 0, nvals, nmode, nifnfnd;
 2551|       |
 2552|     20|    checkArity(op, args);
  ------------------
  |  | 1788|     20|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2553|       |
 2554|     20|    x = CAR(args);
 2555|       |
 2556|     20|    nvals = length(x);
  ------------------
  |  |  987|     20|#define length(x)		Rf_length(x)
  ------------------
 2557|       |
 2558|       |    /* The first arg is the object name */
 2559|       |    /* It must be present and a string */
 2560|     20|    if (!isString(x) )
  ------------------
  |  |  966|     20|#define isString		Rf_isString
  ------------------
  |  Branch (2560:9): [True: 0, False: 20]
  ------------------
 2561|      0|	error(_("invalid first argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid first argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2562|  3.08k|    for(int i = 0; i < nvals; i++)
  ------------------
  |  Branch (2562:20): [True: 3.06k, False: 20]
  ------------------
 2563|  3.06k|	if( isNull(STRING_ELT(x, i)) || !CHAR(STRING_ELT(x, 0))[0] )
  ------------------
  |  |  956|  3.06k|#define isNull			Rf_isNull
  ------------------
              	if( isNull(STRING_ELT(x, i)) || !CHAR(STRING_ELT(x, 0))[0] )
  ------------------
  |  |  203|  3.06k|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (2563:6): [True: 0, False: 3.06k]
  |  Branch (2563:34): [True: 0, False: 3.06k]
  ------------------
 2564|      0|	    error(_("invalid name in position %d"), i+1);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid name in position %d"), i+1);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2565|       |
 2566|     20|    env = CADR(args);
 2567|     20|    if (ISNULL(env)) {
  ------------------
  |  |  176|     20|#define ISNULL(x) ((x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (176:19): [True: 0, False: 20]
  |  |  ------------------
  ------------------
 2568|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2569|     20|    } else if( !isEnvironment(env) )
  ------------------
  |  |  944|     20|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (2569:16): [True: 0, False: 20]
  ------------------
 2570|      0|	error(_("second argument must be an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("second argument must be an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2571|       |
 2572|     20|    mode = CADDR(args);
 2573|     20|    nmode = length(mode);
  ------------------
  |  |  987|     20|#define length(x)		Rf_length(x)
  ------------------
 2574|     20|    if( !isString(mode) )
  ------------------
  |  |  966|     20|#define isString		Rf_isString
  ------------------
  |  Branch (2574:9): [True: 0, False: 20]
  ------------------
 2575|      0|	error(_("invalid '%s' argument"), "mode");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "mode");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2576|       |
 2577|     20|    if( nmode != nvals && nmode != 1 )
  ------------------
  |  Branch (2577:9): [True: 20, False: 0]
  |  Branch (2577:27): [True: 0, False: 20]
  ------------------
 2578|      0|	error(_("wrong length for '%s' argument"), "mode");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("wrong length for '%s' argument"), "mode");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2579|       |
 2580|     20|    PROTECT(ifnotfound = coerceVector(CADDDR(args), VECSXP));
  ------------------
  |  |  357|     20|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2581|     20|    nifnfnd = length(ifnotfound);
  ------------------
  |  |  987|     20|#define length(x)		Rf_length(x)
  ------------------
 2582|     20|    if( !isVector(ifnotfound) )
  ------------------
  |  |  974|     20|#define isVector		Rf_isVector
  ------------------
  |  Branch (2582:9): [True: 0, False: 20]
  ------------------
 2583|      0|	error(_("invalid '%s' argument"), "ifnotfound");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "ifnotfound");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2584|       |
 2585|     20|    if( nifnfnd != nvals && nifnfnd != 1 )
  ------------------
  |  Branch (2585:9): [True: 20, False: 0]
  |  Branch (2585:29): [True: 0, False: 20]
  ------------------
 2586|      0|	error(_("wrong length for '%s' argument"), "ifnotfound");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("wrong length for '%s' argument"), "ifnotfound");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2587|       |
 2588|     20|    ginherits = asLogical(CAD4R(args));
  ------------------
  |  |  886|     20|#define asLogical		Rf_asLogical
  ------------------
 2589|     20|    if (ginherits == NA_LOGICAL)
  ------------------
  |  |   55|     20|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (2589:9): [True: 0, False: 20]
  ------------------
 2590|      0|	error(_("invalid '%s' argument"), "inherits");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "inherits");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2591|       |
 2592|     20|    PROTECT(ans = allocVector(VECSXP, nvals));
  ------------------
  |  |  357|     20|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2593|       |
 2594|  3.08k|    for(int i = 0; i < nvals; i++) {
  ------------------
  |  Branch (2594:20): [True: 3.06k, False: 20]
  ------------------
 2595|  3.06k|	Rboolean wants_S4 = FALSE;
 2596|  3.06k|	const char *modestr = CHAR(STRING_ELT(CADDR(args), i % nmode));
  ------------------
  |  |  203|  3.06k|#define CHAR(x) R_CHAR(x)
  ------------------
 2597|  3.06k|	SEXPTYPE gmode = str2mode(modestr, &wants_S4);
 2598|  3.06k|	SEXP nf = VECTOR_ELT(ifnotfound, i % nifnfnd);
 2599|  3.06k|	SEXP ans_i = gfind(translateChar(STRING_ELT(x, i % nvals)), env,
  ------------------
  |  | 1037|  3.06k|#define translateChar		Rf_translateChar
  ------------------
 2600|  3.06k|			   gmode, wants_S4, nf, ginherits, rho);
 2601|  3.06k|	SET_VECTOR_ELT(ans, i, lazy_duplicate(ans_i));
  ------------------
  |  |  985|  3.06k|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
 2602|  3.06k|    }
 2603|       |
 2604|     20|    setAttrib(ans, R_NamesSymbol, lazy_duplicate(x));
  ------------------
  |  | 1027|     20|#define setAttrib		Rf_setAttrib
  ------------------
                  setAttrib(ans, R_NamesSymbol, lazy_duplicate(x));
  ------------------
  |  |  985|     20|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
 2605|     20|    UNPROTECT(2);
  ------------------
  |  |  358|     20|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2606|     20|    return(ans);
 2607|     20|}
R_isMissing:
 2668|  2.43k|{
 2669|  2.43k|    int ddv=0;
 2670|  2.43k|    SEXP vl, s;
 2671|       |
 2672|  2.43k|    if (symbol == R_MissingArg) /* Yes, this can happen */
  ------------------
  |  Branch (2672:9): [True: 0, False: 2.43k]
  ------------------
 2673|      0|	return TRUE;
 2674|       |
 2675|       |    /* check for infinite recursion */
 2676|  2.43k|    R_CheckStack();
 2677|       |
 2678|  2.43k|    if (DDVAL(symbol)) {
  ------------------
  |  Branch (2678:9): [True: 0, False: 2.43k]
  ------------------
 2679|      0|	s = R_DotsSymbol;
 2680|      0|	ddv = ddVal(symbol);
 2681|      0|    }
 2682|  2.43k|    else
 2683|  2.43k|	s = symbol;
 2684|       |
 2685|  2.43k|    if (rho == R_BaseEnv || rho == R_BaseNamespace)
  ------------------
  |  Branch (2685:9): [True: 0, False: 2.43k]
  |  Branch (2685:29): [True: 0, False: 2.43k]
  ------------------
 2686|      0|	return FALSE;  /* is this really the right thing to do? LT */
 2687|       |
 2688|  2.43k|    vl = findVarLocInFrame(rho, s, NULL);
 2689|  2.43k|    if (vl != R_NilValue) {
  ------------------
  |  Branch (2689:9): [True: 2.43k, False: 0]
  ------------------
 2690|  2.43k|	if (DDVAL(symbol)) {
  ------------------
  |  Branch (2690:6): [True: 0, False: 2.43k]
  ------------------
 2691|      0|	    if (length(CAR(vl)) < ddv || CAR(vl) == R_MissingArg)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (2691:10): [True: 0, False: 0]
  |  Branch (2691:35): [True: 0, False: 0]
  ------------------
 2692|      0|		return TRUE;
 2693|       |	    /* defineVar(symbol, value, R_GlobalEnv); */
 2694|      0|	    else
 2695|      0|		vl = nthcdr(CAR(vl), ddv-1);
  ------------------
  |  | 1009|      0|#define nthcdr			Rf_nthcdr
  ------------------
 2696|      0|	}
 2697|  2.43k|	if (MISSING(vl) == 1 ||
  ------------------
  |  Branch (2697:6): [True: 52, False: 2.38k]
  ------------------
 2698|  2.38k|	    (BNDCELL_TAG(vl) == 0 && CAR(vl) == R_MissingArg))
  ------------------
  |  Branch (2698:7): [True: 2.37k, False: 12]
  |  Branch (2698:31): [True: 0, False: 2.37k]
  ------------------
 2699|     52|	    return TRUE;
 2700|  2.38k|	if (IS_ACTIVE_BINDING(vl))
  ------------------
  |  Branch (2700:6): [True: 0, False: 2.38k]
  ------------------
 2701|      0|	    return FALSE;
 2702|  2.38k|	if (BNDCELL_TAG(vl))
  ------------------
  |  Branch (2702:6): [True: 12, False: 2.37k]
  ------------------
 2703|     12|	    return FALSE;
 2704|  2.37k|	SETCAR(vl, findRootPromise(CAR(vl)));
 2705|  2.37k|	if (TYPEOF(CAR(vl)) == PROMSXP &&
  ------------------
  |  |  116|  4.74k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2705:6): [True: 1.10k, False: 1.26k]
  ------------------
 2706|  1.10k|	    ! PROMISE_IS_EVALUATED(CAR(vl)) &&
  ------------------
  |  Branch (2706:6): [True: 1.05k, False: 53]
  ------------------
 2707|  1.05k|	    TYPEOF(PREXPR(CAR(vl))) == SYMSXP) {
  ------------------
  |  |  720|  1.05k|#define PREXPR(e) R_PromiseExpr(e)
  ------------------
              	    TYPEOF(PREXPR(CAR(vl))) == SYMSXP) {
  ------------------
  |  |  112|  1.05k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (2707:6): [True: 34, False: 1.01k]
  ------------------
 2708|       |	    /* This code uses the PRSEEN value to detect cycles.  If a
 2709|       |	       cycle occurs then a missing argument was encountered,
 2710|       |	       so the return value is TRUE.  It would be a little
 2711|       |	       safer to use the promise stack to ensure unsetting of
 2712|       |	       the bits in the event of a longjump, but doing so would
 2713|       |	       require distinguishing between evaluating promises and
 2714|       |	       checking for missingness.  Because of the test above
 2715|       |	       for an active binding a longjmp should only happen if
 2716|       |	       the stack check fails.  LT */
 2717|     34|	    if (PRSEEN(CAR(vl)) == 1)
  ------------------
  |  Branch (2717:10): [True: 0, False: 34]
  ------------------
 2718|      0|		return TRUE;
 2719|     34|	    else {
 2720|     34|		int oldseen = PRSEEN(CAR(vl));
 2721|     34|		SET_PRSEEN(CAR(vl), 1);
 2722|     34|		PROTECT(vl);
  ------------------
  |  |  357|     34|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2723|     34|		Rboolean val = R_isMissing(PREXPR(CAR(vl)), PRENV(CAR(vl)));
  ------------------
  |  |  720|     34|#define PREXPR(e) R_PromiseExpr(e)
  ------------------
 2724|     34|		UNPROTECT(1); /* vl */
  ------------------
  |  |  358|     34|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2725|       |		/* The oldseen value will usually be 0, but might be 2
 2726|       |		   from an interrupted evaluation. LT */
 2727|     34|		SET_PRSEEN(CAR(vl), oldseen);
 2728|     34|		return val;
 2729|     34|	    }
 2730|     34|	}
 2731|  2.33k|	else
 2732|  2.33k|	    return FALSE;
 2733|  2.37k|    }
 2734|      0|    return FALSE;
 2735|  2.43k|}
R_missing:
 2740|  6.40k|{
 2741|  6.40k|    int ddv = 0;
 2742|  6.40k|    SEXP s = var;
 2743|  6.40k|    if (DDVAL(var)) {
  ------------------
  |  Branch (2743:9): [True: 0, False: 6.40k]
  ------------------
 2744|      0|	ddv = ddVal(var);
 2745|      0|	var = R_DotsSymbol;
 2746|      0|    }
 2747|       |
 2748|  6.40k|    SEXP t = findVarLocInFrame(rho, var, NULL);
 2749|  6.40k|    if (t != R_NilValue) {
  ------------------
  |  Branch (2749:9): [True: 6.40k, False: 0]
  ------------------
 2750|  6.40k|	if (DDVAL(s)) {
  ------------------
  |  Branch (2750:6): [True: 0, False: 6.40k]
  ------------------
 2751|      0|	    if (length(CAR(t)) < ddv  || CAR(t) == R_MissingArg) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (2751:10): [True: 0, False: 0]
  |  Branch (2751:35): [True: 0, False: 0]
  ------------------
 2752|      0|		return TRUE;
 2753|      0|	    }
 2754|      0|	    else
 2755|      0|		t = nthcdr(CAR(t), ddv-1);
  ------------------
  |  | 1009|      0|#define nthcdr			Rf_nthcdr
  ------------------
 2756|      0|	}
 2757|  6.40k|	if (BNDCELL_TAG(t)) return FALSE;
  ------------------
  |  Branch (2757:6): [True: 0, False: 6.40k]
  ------------------
 2758|  6.40k|	if (MISSING(t) || CAR(t) == R_MissingArg) {
  ------------------
  |  Branch (2758:6): [True: 3.99k, False: 2.41k]
  |  Branch (2758:20): [True: 2, False: 2.41k]
  ------------------
 2759|  3.99k|	    return TRUE;
 2760|  3.99k|	}
 2761|  6.40k|    }
 2762|      0|    else  /* it wasn't an argument to the function */
 2763|      0|	error(_("'missing(%s)' did not find an argument"), CHAR(PRINTNAME(var)));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'missing(%s)' did not find an argument"), CHAR(PRINTNAME(var)));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              	error(_("'missing(%s)' did not find an argument"), CHAR(PRINTNAME(var)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 2764|       |
 2765|  2.41k|    t = CAR(t);
 2766|  2.41k|    if (TYPEOF(t) != PROMSXP) {
  ------------------
  |  |  116|  2.41k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2766:9): [True: 2.17k, False: 238]
  ------------------
 2767|  2.17k|	return FALSE;
 2768|  2.17k|    }
 2769|       |    // deal with promise :
 2770|    238|    t = findRootPromise(t);
 2771|    238|    if (!isSymbol(PREXPR(t)))
  ------------------
  |  |  953|    238|#define isSymbol		Rf_isSymbol
  ------------------
                  if (!isSymbol(PREXPR(t)))
  ------------------
  |  |  720|    238|#define PREXPR(e) R_PromiseExpr(e)
  ------------------
  |  Branch (2771:9): [True: 77, False: 161]
  ------------------
 2772|     77|	return FALSE;
 2773|    161|    else {
 2774|    161|	return R_isMissing(PREXPR(t), PRENV(t));
  ------------------
  |  |  720|    161|#define PREXPR(e) R_PromiseExpr(e)
  ------------------
 2775|    161|    }
 2776|    238|}
do_missing:
 2780|  6.39k|{
 2781|  6.39k|    checkArity(op, args);
  ------------------
  |  | 1788|  6.39k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2782|  6.39k|    check1arg(args, call, "x");
  ------------------
  |  | 1867|  6.39k|# define check1arg		Rf_check1arg
  ------------------
 2783|  6.39k|    SEXP sym = CAR(args);
 2784|  6.39k|    if( isString(sym) && length(sym)==1 )
  ------------------
  |  |  966|  6.39k|#define isString		Rf_isString
  ------------------
                  if( isString(sym) && length(sym)==1 )
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (2784:9): [True: 0, False: 6.39k]
  |  Branch (2784:26): [True: 0, False: 0]
  ------------------
 2785|      0|	sym = installTrChar(STRING_ELT(CAR(args), 0));
  ------------------
  |  |  937|      0|#define installTrChar		Rf_installTrChar
  ------------------
 2786|  6.39k|    if (!isSymbol(sym))
  ------------------
  |  |  953|  6.39k|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (2786:9): [True: 0, False: 6.39k]
  ------------------
 2787|      0|	errorcall(call, _("invalid use of 'missing'"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid use of 'missing'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2788|       |
 2789|  6.39k|    SEXP rval = PROTECT(allocVector(LGLSXP, 1));
  ------------------
  |  |  357|  6.39k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2790|  6.39k|    LOGICAL(rval)[0] = R_missing(sym, rho);
 2791|  6.39k|    UNPROTECT(1);
  ------------------
  |  |  358|  6.39k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2792|  6.39k|    return rval;
 2793|  6.39k|}
do_globalenv:
 2805|      4|{
 2806|      4|    checkArity(op, args);
  ------------------
  |  | 1788|      4|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2807|      4|    return R_GlobalEnv;
 2808|      4|}
do_baseenv:
 2820|    856|{
 2821|    856|    checkArity(op, args);
  ------------------
  |  | 1788|    856|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2822|    856|    return R_BaseEnv;
 2823|    856|}
do_emptyenv:
 2835|     53|{
 2836|     53|    checkArity(op, args);
  ------------------
  |  | 1788|     53|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2837|     53|    return R_EmptyEnv;
 2838|     53|}
do_attach:
 2860|     14|{
 2861|     14|    SEXP name, s, t, x;
 2862|     14|    int pos, hsize;
 2863|     14|    Rboolean isSpecial;
 2864|       |
 2865|     14|    checkArity(op, args);
  ------------------
  |  | 1788|     14|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2866|       |
 2867|     14|    pos = asInteger(CADR(args));
  ------------------
  |  |  885|     14|#define asInteger		Rf_asInteger
  ------------------
 2868|     14|    if (pos == NA_INTEGER)
  ------------------
  |  |   56|     14|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (2868:9): [True: 0, False: 14]
  ------------------
 2869|      0|	error(_("'pos' must be an integer"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'pos' must be an integer"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2870|       |
 2871|     14|    name = CADDR(args);
 2872|     14|    if (!isValidStringF(name))
  ------------------
  |  |  973|     14|#define isValidStringF		Rf_isValidStringF
  ------------------
  |  Branch (2872:9): [True: 0, False: 14]
  ------------------
 2873|      0|	error(_("invalid '%s' argument"), "name");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "name");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2874|       |
 2875|     14|    isSpecial = IS_USER_DATABASE(CAR(args));
  ------------------
  |  |  102|     14|#define IS_USER_DATABASE(rho)  (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  ------------------
  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  ------------------
  |  |  |  Branch (102:33): [True: 0, False: 14]
  |  |  |  Branch (102:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2876|       |
 2877|     14|    if(!isSpecial) {
  ------------------
  |  Branch (2877:8): [True: 14, False: 0]
  ------------------
 2878|     14|	if (isNewList(CAR(args))) {
  ------------------
  |  |  955|     14|#define isNewList		Rf_isNewList
  ------------------
  |  Branch (2878:6): [True: 14, False: 0]
  ------------------
 2879|     14|	    SETCAR(args, VectorToPairList(CAR(args)));
  ------------------
  |  | 1046|     14|#define VectorToPairList	Rf_VectorToPairList
  ------------------
 2880|       |
 2881|     14|	    for (x = CAR(args); x != R_NilValue; x = CDR(x))
  ------------------
  |  Branch (2881:26): [True: 0, False: 14]
  ------------------
 2882|      0|		if (TAG(x) == R_NilValue)
  ------------------
  |  Branch (2882:7): [True: 0, False: 0]
  ------------------
 2883|      0|		    error(_("all elements of a list must be named"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("all elements of a list must be named"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2884|     14|	    PROTECT(s = allocSExp(ENVSXP));
  ------------------
  |  |  357|     14|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2885|     14|	    SET_FRAME(s, shallow_duplicate(CAR(args)));
  ------------------
  |  | 1030|     14|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 2886|     14|	} else if (isEnvironment(CAR(args))) {
  ------------------
  |  |  944|      0|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (2886:13): [True: 0, False: 0]
  ------------------
 2887|      0|	    SEXP p, loadenv = CAR(args);
 2888|       |
 2889|      0|	    PROTECT(s = allocSExp(ENVSXP));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2890|      0|	    if (HASHTAB(loadenv) != R_NilValue) {
  ------------------
  |  Branch (2890:10): [True: 0, False: 0]
  ------------------
 2891|      0|		int i, n;
 2892|      0|		n = length(HASHTAB(loadenv));
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 2893|      0|		for (i = 0; i < n; i++) {
  ------------------
  |  Branch (2893:15): [True: 0, False: 0]
  ------------------
 2894|      0|		    p = VECTOR_ELT(HASHTAB(loadenv), i);
 2895|      0|		    while (p != R_NilValue) {
  ------------------
  |  Branch (2895:14): [True: 0, False: 0]
  ------------------
 2896|      0|			set_attach_frame_value(p, s);
 2897|      0|			p = CDR(p);
 2898|      0|		    }
 2899|      0|		}
 2900|       |		/* FIXME: duplicate the hash table and assign here */
 2901|      0|	    } else {
 2902|      0|		for(p = FRAME(loadenv); p != R_NilValue; p = CDR(p))
  ------------------
  |  Branch (2902:27): [True: 0, False: 0]
  ------------------
 2903|      0|		    set_attach_frame_value(p, s);
 2904|      0|	    }
 2905|      0|	} else {
 2906|      0|	    error(_("'attach' only works for lists, data frames and environments"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("'attach' only works for lists, data frames and environments"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2907|      0|	    s = R_NilValue; /* -Wall */
 2908|      0|	}
 2909|       |
 2910|       |	/* Connect FRAME(s) into HASHTAB(s) */
 2911|     14|	if (length(s) < HASHMINSIZE)
  ------------------
  |  |  987|     14|#define length(x)		Rf_length(x)
  ------------------
              	if (length(s) < HASHMINSIZE)
  ------------------
  |  |  208|     14|#define HASHMINSIZE	     29
  ------------------
  |  Branch (2911:6): [True: 14, False: 0]
  ------------------
 2912|     14|	    hsize = HASHMINSIZE;
  ------------------
  |  |  208|     14|#define HASHMINSIZE	     29
  ------------------
 2913|      0|	else
 2914|      0|	    hsize = length(s);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 2915|       |
 2916|     14|	SET_HASHTAB(s, R_NewHashTable(hsize));
 2917|     14|	s = R_HashFrame(s);
 2918|       |
 2919|       |	/* FIXME: A little inefficient */
 2920|     14|	while (R_HashSizeCheck(HASHTAB(s)))
  ------------------
  |  Branch (2920:9): [True: 0, False: 14]
  ------------------
 2921|      0|	    SET_HASHTAB(s, R_HashResize(HASHTAB(s)));
 2922|       |
 2923|     14|    } else { /* is a user object */
 2924|       |	/* Having this here (rather than below) means that the onAttach routine
 2925|       |	   is called before the table is attached. This may not be necessary or
 2926|       |	   desirable. */
 2927|      0|	R_ObjectTable *tb = (R_ObjectTable*) R_ExternalPtrAddr(CAR(args));
 2928|      0|	if(tb->onAttach)
  ------------------
  |  Branch (2928:5): [True: 0, False: 0]
  ------------------
 2929|      0|	    tb->onAttach(tb);
 2930|      0|	PROTECT(s = allocSExp(ENVSXP));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2931|      0|	SET_HASHTAB(s, CAR(args));
 2932|      0|	setAttrib(s, R_ClassSymbol, getAttrib(HASHTAB(s), R_ClassSymbol));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              	setAttrib(s, R_ClassSymbol, getAttrib(HASHTAB(s), R_ClassSymbol));
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 2933|      0|    }
 2934|       |
 2935|     14|    setAttrib(s, R_NameSymbol, name);
  ------------------
  |  | 1027|     14|#define setAttrib		Rf_setAttrib
  ------------------
 2936|     14|    for (t = R_GlobalEnv; ENCLOS(t) != R_BaseEnv && pos > 2; t = ENCLOS(t))
  ------------------
  |  Branch (2936:27): [True: 12, False: 2]
  |  Branch (2936:53): [True: 0, False: 12]
  ------------------
 2937|      0|	pos--;
 2938|       |
 2939|     14|    if (ENCLOS(t) == R_BaseEnv) {
  ------------------
  |  Branch (2939:9): [True: 2, False: 12]
  ------------------
 2940|      2|	SET_ENCLOS(t, s);
 2941|      2|	SET_ENCLOS(s, R_BaseEnv);
 2942|      2|    }
 2943|     12|    else {
 2944|     12|	x = ENCLOS(t);
 2945|     12|	SET_ENCLOS(t, s);
 2946|     12|	SET_ENCLOS(s, x);
 2947|     12|    }
 2948|       |
 2949|     14|    if(!isSpecial) { /* Temporary: need to remove the elements identified by objects(CAR(args)) */
  ------------------
  |  Branch (2949:8): [True: 14, False: 0]
  ------------------
 2950|     14|#ifdef USE_GLOBAL_CACHE
 2951|     14|	R_FlushGlobalCacheFromTable(HASHTAB(s));
 2952|     14|	MARK_AS_GLOBAL_FRAME(s);
  ------------------
  |  |  655|     14|  SET_ENVFLAGS(e, ENVFLAGS(e) | GLOBAL_FRAME_MASK)
  |  |  ------------------
  |  |  |  |  652|     14|#define GLOBAL_FRAME_MASK (1<<15)
  |  |  ------------------
  ------------------
 2953|     14|#endif
 2954|     14|    } else {
 2955|      0|#ifdef USE_GLOBAL_CACHE
 2956|      0|	R_FlushGlobalCacheFromUserTable(HASHTAB(s));
 2957|      0|	MARK_AS_GLOBAL_FRAME(s);
  ------------------
  |  |  655|      0|  SET_ENVFLAGS(e, ENVFLAGS(e) | GLOBAL_FRAME_MASK)
  |  |  ------------------
  |  |  |  |  652|      0|#define GLOBAL_FRAME_MASK (1<<15)
  |  |  ------------------
  ------------------
 2958|      0|#endif
 2959|      0|    }
 2960|       |
 2961|     14|    UNPROTECT(1); /* s */
  ------------------
  |  |  358|     14|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2962|     14|    return s;
 2963|     14|}
do_search:
 3033|     52|{
 3034|     52|    SEXP ans, name, t;
 3035|     52|    int i, n;
 3036|       |
 3037|     52|    checkArity(op, args);
  ------------------
  |  | 1788|     52|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 3038|     52|    n = 2;
 3039|    248|    for (t = ENCLOS(R_GlobalEnv); t != R_BaseEnv ; t = ENCLOS(t))
  ------------------
  |  Branch (3039:35): [True: 196, False: 52]
  ------------------
 3040|    196|	n++;
 3041|     52|    PROTECT(ans = allocVector(STRSXP, n));
  ------------------
  |  |  357|     52|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3042|       |    /* TODO - what should the name of this be? */
 3043|     52|    SET_STRING_ELT(ans, 0, mkChar(".GlobalEnv"));
  ------------------
  |  |  998|     52|#define mkChar			Rf_mkChar
  ------------------
 3044|     52|    SET_STRING_ELT(ans, n-1, mkChar("package:base"));
  ------------------
  |  |  998|     52|#define mkChar			Rf_mkChar
  ------------------
 3045|     52|    i = 1;
 3046|    248|    for (t = ENCLOS(R_GlobalEnv); t != R_BaseEnv ; t = ENCLOS(t)) {
  ------------------
  |  Branch (3046:35): [True: 196, False: 52]
  ------------------
 3047|    196|	name = getAttrib(t, R_NameSymbol);
  ------------------
  |  |  924|    196|#define getAttrib		Rf_getAttrib
  ------------------
 3048|    196|	if (!isString(name) || length(name) < 1)
  ------------------
  |  |  966|    196|#define isString		Rf_isString
  ------------------
              	if (!isString(name) || length(name) < 1)
  ------------------
  |  |  987|    196|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (3048:6): [True: 0, False: 196]
  |  Branch (3048:25): [True: 0, False: 196]
  ------------------
 3049|      0|	    SET_STRING_ELT(ans, i, mkChar("(unknown)"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 3050|    196|	else
 3051|    196|	    SET_STRING_ELT(ans, i, STRING_ELT(name, 0));
 3052|    196|	i++;
 3053|    196|    }
 3054|     52|    UNPROTECT(1);
  ------------------
  |  |  358|     52|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3055|     52|    return ans;
 3056|     52|}
do_ls:
 3247|      8|{
 3248|      8|    checkArity(op, args);
  ------------------
  |  | 1788|      8|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 3249|       |
 3250|      8|    if(IS_USER_DATABASE(CAR(args))) {
  ------------------
  |  |  102|      8|#define IS_USER_DATABASE(rho)  (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  ------------------
  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  ------------------
  |  |  |  Branch (102:33): [True: 0, False: 8]
  |  |  |  Branch (102:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3251|      0|	R_ObjectTable *tb = (R_ObjectTable*)
 3252|      0|	    R_ExternalPtrAddr(HASHTAB(CAR(args)));
 3253|      0|	return(tb->objects(tb));
 3254|      0|    }
 3255|       |
 3256|      8|    SEXP env = CAR(args);
 3257|       |
 3258|       |    /* if (env == R_BaseNamespace) env = R_BaseEnv; */
 3259|       |
 3260|      8|    int all = asLogical(CADR(args));
  ------------------
  |  |  886|      8|#define asLogical		Rf_asLogical
  ------------------
 3261|      8|    if (all == NA_LOGICAL) all = 0;
  ------------------
  |  |   55|      8|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (3261:9): [True: 0, False: 8]
  ------------------
 3262|       |
 3263|      8|    int sort_nms = asLogical(CADDR(args)); /* sorted = TRUE/FALSE */
  ------------------
  |  |  886|      8|#define asLogical		Rf_asLogical
  ------------------
 3264|      8|    if (sort_nms == NA_LOGICAL) sort_nms = 0;
  ------------------
  |  |   55|      8|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (3264:9): [True: 0, False: 8]
  ------------------
 3265|       |
 3266|      8|    return R_lsInternal3(env, (Rboolean) all, (Rboolean) sort_nms);
 3267|      8|}
R_lsInternal3:
 3273|    174|{
 3274|    174|    if(IS_USER_DATABASE(env)) {
  ------------------
  |  |  102|    174|#define IS_USER_DATABASE(rho)  (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  ------------------
  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  ------------------
  |  |  |  Branch (102:33): [True: 0, False: 174]
  |  |  |  Branch (102:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3275|      0|	R_ObjectTable *tb = (R_ObjectTable*)
 3276|      0|	    R_ExternalPtrAddr(HASHTAB(env));
 3277|      0|	return(tb->objects(tb));
 3278|      0|    }
 3279|       |
 3280|       |    /* Step 1 : Compute the Vector Size */
 3281|    174|    int k = 0;
 3282|    174|    if (env == R_BaseEnv || env == R_BaseNamespace)
  ------------------
  |  Branch (3282:9): [True: 14, False: 160]
  |  Branch (3282:29): [True: 0, False: 160]
  ------------------
 3283|     14|	k += BuiltinSize(all, 0);
 3284|    160|    else if (isEnvironment(env) ||
  ------------------
  |  |  944|    160|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (3284:14): [True: 160, False: 0]
  ------------------
 3285|    160|	isEnvironment(env = simple_as_environment(env))) {
  ------------------
  |  |  944|      0|#define isEnvironment		Rf_isEnvironment
  ------------------
              	isEnvironment(env = simple_as_environment(env))) {
  ------------------
  |  | 2187|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (2187:37): [True: 0, False: 0]
  |  |  |  Branch (2187:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (3285:2): [True: 0, False: 0]
  ------------------
 3286|    160|	if (HASHTAB(env) != R_NilValue)
  ------------------
  |  Branch (3286:6): [True: 160, False: 0]
  ------------------
 3287|    160|	    k += HashTableSize(HASHTAB(env), all);
 3288|      0|	else
 3289|      0|	    k += FrameSize(FRAME(env), all);
 3290|    160|    }
 3291|      0|    else
 3292|      0|	error(_("invalid '%s' argument"), "envir");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "envir");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3293|       |
 3294|       |    /* Step 2 : Allocate and Fill the Result */
 3295|    174|    SEXP ans = PROTECT(allocVector(STRSXP, k));
  ------------------
  |  |  357|    174|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3296|    174|    k = 0;
 3297|    174|    if (env == R_BaseEnv || env == R_BaseNamespace)
  ------------------
  |  Branch (3297:9): [True: 14, False: 160]
  |  Branch (3297:29): [True: 0, False: 160]
  ------------------
 3298|     14|	BuiltinNames(all, 0, ans, &k);
 3299|    160|    else if (isEnvironment(env)) {
  ------------------
  |  |  944|    160|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (3299:14): [True: 160, False: 0]
  ------------------
 3300|    160|	if (HASHTAB(env) != R_NilValue)
  ------------------
  |  Branch (3300:6): [True: 160, False: 0]
  ------------------
 3301|    160|	    HashTableNames(HASHTAB(env), all, ans, &k);
 3302|      0|	else
 3303|      0|	    FrameNames(FRAME(env), all, ans, &k);
 3304|    160|    }
 3305|       |
 3306|    174|    if(sorted) sortVector(ans, FALSE);
  ------------------
  |  | 1986|      8|# define sortVector		Rf_sortVector
  ------------------
  |  Branch (3306:8): [True: 8, False: 166]
  ------------------
 3307|    174|    UNPROTECT(1);
  ------------------
  |  |  358|    174|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3308|    174|    return ans;
 3309|    174|}
Rf_envlength:
 3507|     14|TYPE_ NAME_(SEXP rho)							\
 3508|     14|{									\
 3509|     14|    if(IS_USER_DATABASE(rho)) {						\
  ------------------
  |  |  102|     14|#define IS_USER_DATABASE(rho)  (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  ------------------
  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  ------------------
  |  |  |  Branch (102:33): [True: 0, False: 14]
  |  |  |  Branch (102:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3510|      0|	R_ObjectTable *tb = (R_ObjectTable*) R_ExternalPtrAddr(HASHTAB(rho)); \
 3511|      0|	return LENGTH_FN_(tb->objects(tb));				\
  ------------------
  |  | 3520|      0|R_ENVLENGTH(Rf_envlength,   length, int)
  |  |  ------------------
  |  |  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  ------------------
  ------------------
 3512|     14|    } else if( HASHTAB(rho) != R_NilValue)				\
  ------------------
  |  Branch (3512:16): [True: 0, False: 14]
  ------------------
 3513|     14|	return HashTableSize(HASHTAB(rho), 1);				\
 3514|     14|    else if (rho == R_BaseEnv || rho == R_BaseNamespace) 		\
  ------------------
  |  Branch (3514:14): [True: 0, False: 14]
  |  Branch (3514:34): [True: 0, False: 14]
  ------------------
 3515|     14|	return BuiltinSize(1, 0);					\
 3516|     14|    else								\
 3517|     14|	return FrameSize(FRAME(rho), 1);				\
 3518|     14|}
do_pos2env:
 3598|    140|{
 3599|    140|    checkArity(op, args);
  ------------------
  |  | 1788|    140|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 3600|    140|    check1arg(args, call, "x");
  ------------------
  |  | 1867|    140|# define check1arg		Rf_check1arg
  ------------------
 3601|       |
 3602|    140|    SEXP pos = CAR(args);
 3603|    140|    if (!isNumeric(pos) || XLENGTH(pos) != 1)
  ------------------
  |  |  957|    140|#define isNumeric		Rf_isNumeric
  ------------------
  |  Branch (3603:9): [True: 0, False: 140]
  |  Branch (3603:28): [True: 0, False: 140]
  ------------------
 3604|      0|	errorcall(call, _("invalid '%s' argument"), "pos");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid '%s' argument"), "pos");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3605|    140|    return pos2env(asInteger(pos), call);
  ------------------
  |  |  885|    140|#define asInteger		Rf_asInteger
  ------------------
 3606|    140|}
do_as_environment:
 3633|    384|{
 3634|    384|    SEXP arg = CAR(args), ans;
 3635|    384|    checkArity(op, args);
  ------------------
  |  | 1788|    384|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 3636|    384|    check1arg(args, call, "x");
  ------------------
  |  | 1867|    384|# define check1arg		Rf_check1arg
  ------------------
 3637|    384|    if(isEnvironment(arg))
  ------------------
  |  |  944|    384|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (3637:8): [True: 244, False: 140]
  ------------------
 3638|    244|	return arg;
 3639|       |    /* DispatchOrEval internal generic: as.environment */
 3640|    140|    if(isObject(arg) &&
  ------------------
  |  |  959|    140|#define isObject		Rf_isObject
  ------------------
  |  Branch (3640:8): [True: 0, False: 140]
  ------------------
 3641|      0|       DispatchOrEval(call, op, "as.environment", args, rho, &ans, 0, 1))
  ------------------
  |  | 1887|      0|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (3641:8): [True: 0, False: 0]
  ------------------
 3642|      0|	return ans;
 3643|    140|    switch(TYPEOF(arg)) {
 3644|      0|    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (3644:5): [True: 0, False: 140]
  ------------------
 3645|      0|	return matchEnvir(call, translateChar(asChar(arg)));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
              	return matchEnvir(call, translateChar(asChar(arg)));
  ------------------
  |  |  882|      0|#define asChar			Rf_asChar
  ------------------
 3646|      2|    case REALSXP:
  ------------------
  |  |  124|      2|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (3646:5): [True: 2, False: 138]
  ------------------
 3647|    140|    case INTSXP:
  ------------------
  |  |  123|    140|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (3647:5): [True: 138, False: 2]
  ------------------
 3648|    140|	return do_pos2env(call, op, args, rho);
 3649|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (3649:5): [True: 0, False: 140]
  ------------------
 3650|      0|	errorcall(call,_("using 'as.environment(NULL)' is defunct"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call,_("using 'as.environment(NULL)' is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3651|      0|	return R_BaseEnv;	/* -Wall */
 3652|      0|    case OBJSXP: {
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (3652:5): [True: 0, False: 140]
  ------------------
 3653|       |	/* dispatch was tried above already */
 3654|      0|	SEXP dot_xData = R_getS4DataSlot(arg, ENVSXP);
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
 3655|      0|	if(!isEnvironment(dot_xData))
  ------------------
  |  |  944|      0|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (3655:5): [True: 0, False: 0]
  ------------------
 3656|      0|	    errorcall(call, _("S4 object does not extend class \"environment\""));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("S4 object does not extend class \"environment\""));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3657|      0|	else
 3658|      0|	    return(dot_xData);
 3659|      0|    }
 3660|      0|    case VECSXP: {
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (3660:5): [True: 0, False: 140]
  ------------------
 3661|       |	/* implement as.environment.list() {isObject(.) is false for a list} */
 3662|      0|	SEXP call, val;
 3663|      0|	PROTECT(call = lang4(install("list2env"), arg,
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3664|      0|			     /* envir = */R_NilValue,
 3665|      0|			     /* parent = */R_EmptyEnv));
 3666|      0|	val = eval(call, rho);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 3667|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3668|      0|	return val;
 3669|      0|    }
 3670|      0|    default:
  ------------------
  |  Branch (3670:5): [True: 0, False: 140]
  ------------------
 3671|      0|	errorcall(call, _("invalid object for 'as.environment'"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid object for 'as.environment'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3672|      0|	return R_NilValue;	/* -Wall */
 3673|    140|    }
 3674|    140|}
R_LockEnvironment:
 3677|     48|{
 3678|     48|    if(IS_S4_OBJECT(env) && (TYPEOF(env) == OBJSXP))
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (3678:8): [True: 0, False: 48]
  |  Branch (3678:29): [True: 0, False: 0]
  ------------------
 3679|      0|	env = R_getS4DataSlot(env, ANYSXP); /* better be an ENVSXP */
  ------------------
  |  |  128|      0|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
 3680|     48|    if (env == R_BaseEnv || env == R_BaseNamespace) {
  ------------------
  |  Branch (3680:9): [True: 2, False: 46]
  |  Branch (3680:29): [True: 2, False: 44]
  ------------------
 3681|      4|	if (bindings) {
  ------------------
  |  Branch (3681:6): [True: 2, False: 2]
  ------------------
 3682|      2|	    SEXP s;
 3683|      2|	    int j;
 3684|  98.3k|	    for (j = 0; j < HSIZE; j++)
  ------------------
  |  | 1174|  98.3k|#define HSIZE	  49157	/* The size of the hash table for symbols */
  ------------------
  |  Branch (3684:18): [True: 98.3k, False: 2]
  ------------------
 3685|   102k|		for (s = R_SymbolTable[j]; s != R_NilValue; s = CDR(s))
  ------------------
  |  Branch (3685:30): [True: 4.15k, False: 98.3k]
  ------------------
 3686|  4.15k|		    if(SYMVALUE(CAR(s)) != R_UnboundValue)
  ------------------
  |  Branch (3686:10): [True: 2.83k, False: 1.31k]
  ------------------
 3687|  2.83k|			LOCK_BINDING(CAR(s));
 3688|      2|	}
 3689|      4|	LOCK_FRAME(env);
  ------------------
  |  |  108|      4|#define LOCK_FRAME(e) SET_ENVFLAGS(e, ENVFLAGS(e) | FRAME_LOCK_MASK)
  |  |  ------------------
  |  |  |  |  106|      4|#define FRAME_LOCK_MASK (1<<14)
  |  |  ------------------
  ------------------
 3690|      4|	return;
 3691|      4|    }
 3692|       |
 3693|     44|    if (TYPEOF(env) != ENVSXP)
  ------------------
  |  |  115|     44|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (3693:9): [True: 0, False: 44]
  ------------------
 3694|      0|	error(_("not an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3695|     44|    if (bindings) {
  ------------------
  |  Branch (3695:9): [True: 44, False: 0]
  ------------------
 3696|     44|	if (IS_HASHED(env)) {
  ------------------
  |  |  212|     44|#define IS_HASHED(x)	     (HASHTAB(x) != R_NilValue)
  |  |  ------------------
  |  |  |  Branch (212:27): [True: 44, False: 0]
  |  |  ------------------
  ------------------
 3697|     44|	    SEXP table, chain;
 3698|     44|	    int i, size;
 3699|     44|	    table = HASHTAB(env);
 3700|     44|	    size = HASHSIZE(table);
  ------------------
  |  |  205|     44|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
 3701|  9.49k|	    for (i = 0; i < size; i++)
  ------------------
  |  Branch (3701:18): [True: 9.44k, False: 44]
  ------------------
 3702|  9.44k|		for (chain = VECTOR_ELT(table, i);
 3703|  19.8k|		     chain != R_NilValue;
  ------------------
  |  Branch (3703:8): [True: 10.3k, False: 9.44k]
  ------------------
 3704|  10.3k|		     chain = CDR(chain))
 3705|  10.3k|		    LOCK_BINDING(chain);
 3706|     44|	}
 3707|      0|	else {
 3708|      0|	    SEXP frame;
 3709|      0|	    for (frame = FRAME(env); frame != R_NilValue; frame = CDR(frame))
  ------------------
  |  Branch (3709:31): [True: 0, False: 0]
  ------------------
 3710|      0|		LOCK_BINDING(frame);
 3711|      0|	}
 3712|     44|    }
 3713|     44|    LOCK_FRAME(env);
  ------------------
  |  |  108|     44|#define LOCK_FRAME(e) SET_ENVFLAGS(e, ENVFLAGS(e) | FRAME_LOCK_MASK)
  |  |  ------------------
  |  |  |  |  106|     44|#define FRAME_LOCK_MASK (1<<14)
  |  |  ------------------
  ------------------
 3714|     44|}
R_EnvironmentIsLocked:
 3717|  1.19k|{
 3718|  1.19k|    if (TYPEOF(env) == NILSXP)
  ------------------
  |  |  111|  1.19k|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (3718:9): [True: 0, False: 1.19k]
  ------------------
 3719|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3720|  1.19k|    if (TYPEOF(env) != ENVSXP &&
  ------------------
  |  |  115|  2.38k|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (3720:9): [True: 0, False: 1.19k]
  ------------------
 3721|      0|	TYPEOF((env = simple_as_environment(env))) != ENVSXP)
  ------------------
  |  | 2187|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (2187:37): [True: 0, False: 0]
  |  |  |  Branch (2187:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	TYPEOF((env = simple_as_environment(env))) != ENVSXP)
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (3721:2): [True: 0, False: 0]
  ------------------
 3722|      0|	error(_("not an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3723|  1.19k|    return FRAME_IS_LOCKED(env) != 0;
  ------------------
  |  |  107|  1.19k|#define FRAME_IS_LOCKED(e) (ENVFLAGS(e) & FRAME_LOCK_MASK)
  |  |  ------------------
  |  |  |  |  106|  1.19k|#define FRAME_LOCK_MASK (1<<14)
  |  |  ------------------
  ------------------
 3724|  1.19k|}
do_lockEnv:
 3727|     44|{
 3728|     44|    SEXP frame;
 3729|     44|    Rboolean bindings;
 3730|     44|    checkArity(op, args);
  ------------------
  |  | 1788|     44|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 3731|     44|    frame = CAR(args);
 3732|     44|    bindings = asRbool(CADR(args), call);
  ------------------
  |  | 1861|     44|# define asRbool		Rf_asRbool
  ------------------
 3733|     44|    R_LockEnvironment(frame, bindings);
 3734|     44|    return R_NilValue;
 3735|     44|}
do_envIsLocked:
 3738|     36|{
 3739|     36|    checkArity(op, args);
  ------------------
  |  | 1788|     36|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 3740|     36|    return ScalarLogical(R_EnvironmentIsLocked(CAR(args)));
  ------------------
  |  | 1023|     36|#define ScalarLogical		Rf_ScalarLogical
  ------------------
 3741|     36|}
R_unLockBinding:
 3765|      6|{
 3766|      6|    if (TYPEOF(sym) != SYMSXP)
  ------------------
  |  |  112|      6|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (3766:9): [True: 0, False: 6]
  ------------------
 3767|      0|	error(_("not a symbol"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not a symbol"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3768|      6|    if (TYPEOF(env) == NILSXP)
  ------------------
  |  |  111|      6|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (3768:9): [True: 0, False: 6]
  ------------------
 3769|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3770|      6|    if (TYPEOF(env) != ENVSXP &&
  ------------------
  |  |  115|     12|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (3770:9): [True: 0, False: 6]
  ------------------
 3771|      0|	TYPEOF((env = simple_as_environment(env))) != ENVSXP)
  ------------------
  |  | 2187|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (2187:37): [True: 0, False: 0]
  |  |  |  Branch (2187:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	TYPEOF((env = simple_as_environment(env))) != ENVSXP)
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (3771:2): [True: 0, False: 0]
  ------------------
 3772|      0|	error(_("not an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3773|      6|    if (env == R_BaseEnv || env == R_BaseNamespace)
  ------------------
  |  Branch (3773:9): [True: 4, False: 2]
  |  Branch (3773:29): [True: 0, False: 2]
  ------------------
 3774|       |	/* It is a symbol, so must have a binding even if it is
 3775|       |	   R_UnboundSymbol */
 3776|      4|	UNLOCK_BINDING(sym);
 3777|      2|    else {
 3778|      2|	SEXP binding = findVarLocInFrame(env, sym, NULL);
 3779|      2|	if (binding == R_NilValue)
  ------------------
  |  Branch (3779:6): [True: 0, False: 2]
  ------------------
 3780|      0|	    error(_("no binding for \"%s\""), EncodeChar(PRINTNAME(sym)));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("no binding for \"%s\""), EncodeChar(PRINTNAME(sym)));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              	    error(_("no binding for \"%s\""), EncodeChar(PRINTNAME(sym)));
  ------------------
  |  | 1890|      0|# define EncodeChar             Rf_EncodeChar
  ------------------
 3781|      2|	UNLOCK_BINDING(binding);
 3782|      2|    }
 3783|      6|}
R_MakeActiveBinding:
 3812|      4|{
 3813|      4|    if (TYPEOF(sym) != SYMSXP)
  ------------------
  |  |  112|      4|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (3813:9): [True: 0, False: 4]
  ------------------
 3814|      0|	error(_("not a symbol"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not a symbol"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3815|      4|    if (! isFunction(fun))
  ------------------
  |  |  948|      4|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (3815:9): [True: 0, False: 4]
  ------------------
 3816|      0|	error(_("not a function"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not a function"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3817|      4|    if (TYPEOF(env) == NILSXP)
  ------------------
  |  |  111|      4|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (3817:9): [True: 0, False: 4]
  ------------------
 3818|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3819|      4|    if (TYPEOF(env) != ENVSXP &&
  ------------------
  |  |  115|      8|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (3819:9): [True: 0, False: 4]
  ------------------
 3820|      0|	TYPEOF((env = simple_as_environment(env))) != ENVSXP)
  ------------------
  |  | 2187|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (2187:37): [True: 0, False: 0]
  |  |  |  Branch (2187:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	TYPEOF((env = simple_as_environment(env))) != ENVSXP)
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (3820:2): [True: 0, False: 0]
  ------------------
 3821|      0|	error(_("not an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3822|      4|    if (env == R_BaseEnv || env == R_BaseNamespace) {
  ------------------
  |  Branch (3822:9): [True: 2, False: 2]
  |  Branch (3822:29): [True: 0, False: 2]
  ------------------
 3823|      2|	if (SYMVALUE(sym) != R_UnboundValue && ! IS_ACTIVE_BINDING(sym))
  ------------------
  |  Branch (3823:6): [True: 0, False: 2]
  |  Branch (3823:41): [True: 0, False: 0]
  ------------------
 3824|      0|	    error(_("symbol already has a regular binding"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("symbol already has a regular binding"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3825|      2|	else if (BINDING_IS_LOCKED(sym))
  ------------------
  |  Branch (3825:11): [True: 0, False: 2]
  ------------------
 3826|      0|	    error(_("cannot change active binding if binding is locked"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("cannot change active binding if binding is locked"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3827|      2|	SET_SYMVALUE(sym, fun);
 3828|      2|	SET_ACTIVE_BINDING_BIT(sym);
 3829|       |	/* we don't need to worry about the global cache here as
 3830|       |	   a regular binding cannot be changed */
 3831|      2|    }
 3832|      2|    else {
 3833|      2|	SEXP binding = findVarLocInFrame(env, sym, NULL);
 3834|      2|	if (binding == R_NilValue) {
  ------------------
  |  Branch (3834:6): [True: 2, False: 0]
  ------------------
 3835|      2|	    defineVar(sym, fun, env); /* fails if env is locked */
  ------------------
  |  |  905|      2|#define defineVar		Rf_defineVar
  ------------------
 3836|      2|	    binding = findVarLocInFrame(env, sym, NULL);
 3837|      2|	    SET_ACTIVE_BINDING_BIT(binding);
 3838|      2|	}
 3839|      0|	else if (! IS_ACTIVE_BINDING(binding))
  ------------------
  |  Branch (3839:11): [True: 0, False: 0]
  ------------------
 3840|      0|	    error(_("symbol already has a regular binding"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("symbol already has a regular binding"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3841|      0|	else if (BINDING_IS_LOCKED(binding))
  ------------------
  |  Branch (3841:11): [True: 0, False: 0]
  ------------------
 3842|      0|	    error(_("cannot change active binding if binding is locked"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("cannot change active binding if binding is locked"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3843|      0|	else
 3844|      0|	    SETCAR(binding, fun);
 3845|      2|    }
 3846|      4|}
R_BindingIsLocked:
 3849|      2|{
 3850|      2|    if (TYPEOF(sym) != SYMSXP)
  ------------------
  |  |  112|      2|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (3850:9): [True: 0, False: 2]
  ------------------
 3851|      0|	error(_("not a symbol"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not a symbol"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3852|      2|    if (TYPEOF(env) == NILSXP)
  ------------------
  |  |  111|      2|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (3852:9): [True: 0, False: 2]
  ------------------
 3853|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3854|      2|    if (TYPEOF(env) != ENVSXP &&
  ------------------
  |  |  115|      4|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (3854:9): [True: 0, False: 2]
  ------------------
 3855|      0|	TYPEOF((env = simple_as_environment(env))) != ENVSXP)
  ------------------
  |  | 2187|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (2187:37): [True: 0, False: 0]
  |  |  |  Branch (2187:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	TYPEOF((env = simple_as_environment(env))) != ENVSXP)
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (3855:2): [True: 0, False: 0]
  ------------------
 3856|      0|	error(_("not an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3857|      2|    if (env == R_BaseEnv || env == R_BaseNamespace)
  ------------------
  |  Branch (3857:9): [True: 2, False: 0]
  |  Branch (3857:29): [True: 0, False: 0]
  ------------------
 3858|       |	/* It is a symbol, so must have a binding even if it is
 3859|       |	   R_UnboundSymbol */
 3860|      2|	return BINDING_IS_LOCKED(sym) != 0;
 3861|      0|    else {
 3862|      0|	SEXP binding = findVarLocInFrame(env, sym, NULL);
 3863|      0|	if (binding == R_NilValue)
  ------------------
  |  Branch (3863:6): [True: 0, False: 0]
  ------------------
 3864|      0|	    error(_("no binding for \"%s\""), EncodeChar(PRINTNAME(sym)));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("no binding for \"%s\""), EncodeChar(PRINTNAME(sym)));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              	    error(_("no binding for \"%s\""), EncodeChar(PRINTNAME(sym)));
  ------------------
  |  | 1890|      0|# define EncodeChar             Rf_EncodeChar
  ------------------
 3865|      0|	return BINDING_IS_LOCKED(binding) != 0;
 3866|      0|    }
 3867|      2|}
R_BindingIsActive:
 3870|      2|{
 3871|      2|    if (TYPEOF(sym) != SYMSXP)
  ------------------
  |  |  112|      2|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (3871:9): [True: 0, False: 2]
  ------------------
 3872|      0|	error(_("not a symbol"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not a symbol"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3873|      2|    if (TYPEOF(env) == NILSXP)
  ------------------
  |  |  111|      2|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (3873:9): [True: 0, False: 2]
  ------------------
 3874|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3875|      2|    if (TYPEOF(env) != ENVSXP &&
  ------------------
  |  |  115|      4|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (3875:9): [True: 0, False: 2]
  ------------------
 3876|      0|	TYPEOF((env = simple_as_environment(env))) != ENVSXP)
  ------------------
  |  | 2187|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (2187:37): [True: 0, False: 0]
  |  |  |  Branch (2187:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	TYPEOF((env = simple_as_environment(env))) != ENVSXP)
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (3876:2): [True: 0, False: 0]
  ------------------
 3877|      0|	error(_("not an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3878|      2|    if (env == R_BaseEnv || env == R_BaseNamespace)
  ------------------
  |  Branch (3878:9): [True: 2, False: 0]
  |  Branch (3878:29): [True: 0, False: 0]
  ------------------
 3879|       |	/* It is a symbol, so must have a binding even if it is
 3880|       |	   R_UnboundSymbol */
 3881|      2|	return IS_ACTIVE_BINDING(sym) != 0;
 3882|      0|    else {
 3883|      0|	SEXP binding = findVarLocInFrame(env, sym, NULL);
 3884|      0|	if (binding == R_NilValue)
  ------------------
  |  Branch (3884:6): [True: 0, False: 0]
  ------------------
 3885|      0|	    error(_("no binding for \"%s\""), EncodeChar(PRINTNAME(sym)));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("no binding for \"%s\""), EncodeChar(PRINTNAME(sym)));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              	    error(_("no binding for \"%s\""), EncodeChar(PRINTNAME(sym)));
  ------------------
  |  | 1890|      0|# define EncodeChar             Rf_EncodeChar
  ------------------
 3886|      0|	return IS_ACTIVE_BINDING(binding) != 0;
 3887|      0|    }
 3888|      2|}
do_lockBnd:
 4018|      2|{
 4019|      2|    SEXP sym, env;
 4020|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 4021|      2|    sym = CAR(args);
 4022|      2|    env = CADR(args);
 4023|      2|    switch(PRIMVAL(op)) {
  ------------------
  |  | 1347|      2|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
 4024|      0|    case 0:
  ------------------
  |  Branch (4024:5): [True: 0, False: 2]
  ------------------
 4025|      0|	R_LockBinding(sym, env);
 4026|      0|	break;
 4027|      2|    case 1:
  ------------------
  |  Branch (4027:5): [True: 2, False: 0]
  ------------------
 4028|      2|	R_unLockBinding(sym, env);
 4029|      2|	break;
 4030|      0|    default:
  ------------------
  |  Branch (4030:5): [True: 0, False: 2]
  ------------------
 4031|      0|	error(_("unknown op"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("unknown op"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4032|      2|    }
 4033|      2|    return R_NilValue;
 4034|      2|}
do_mkActiveBnd:
 4046|      4|{
 4047|      4|    SEXP sym, fun, env;
 4048|      4|    checkArity(op, args);
  ------------------
  |  | 1788|      4|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 4049|      4|    sym = CAR(args);
 4050|      4|    fun = CADR(args);
 4051|      4|    env = CADDR(args);
 4052|      4|    R_MakeActiveBinding(sym, fun, env);
 4053|      4|    return R_NilValue;
 4054|      4|}
do_mkUnbound:
 4076|      2|{
 4077|      2|    SEXP sym;
 4078|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 4079|      2|    sym = CAR(args);
 4080|       |
 4081|      2|    if (TYPEOF(sym) != SYMSXP) error(_("not a symbol"));
  ------------------
  |  |  112|      2|#define SYMSXP	     1	  /* symbols */
  ------------------
                  if (TYPEOF(sym) != SYMSXP) error(_("not a symbol"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (TYPEOF(sym) != SYMSXP) error(_("not a symbol"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (4081:9): [True: 0, False: 2]
  ------------------
 4082|       |    /* This is not quite the same as SET_SYMBOL_BINDING_VALUE as it
 4083|       |       does not allow active bindings to be unbound */
 4084|      2|    if (FRAME_IS_LOCKED(R_BaseEnv))
  ------------------
  |  |  107|      2|#define FRAME_IS_LOCKED(e) (ENVFLAGS(e) & FRAME_LOCK_MASK)
  |  |  ------------------
  |  |  |  |  106|      2|#define FRAME_LOCK_MASK (1<<14)
  |  |  ------------------
  |  |  |  Branch (107:28): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 4085|      0|	error(_("cannot remove bindings from a locked environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot remove bindings from a locked environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4086|      2|    if (R_BindingIsLocked(sym, R_BaseEnv))
  ------------------
  |  Branch (4086:9): [True: 0, False: 2]
  ------------------
 4087|      0|	error(_("cannot unbind a locked binding"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot unbind a locked binding"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4088|      2|    if (R_BindingIsActive(sym, R_BaseEnv))
  ------------------
  |  Branch (4088:9): [True: 0, False: 2]
  ------------------
 4089|      0|	error(_("cannot unbind an active binding"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot unbind an active binding"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4090|      2|    SET_SYMVALUE(sym, R_UnboundValue);
 4091|      2|#ifdef USE_GLOBAL_CACHE
 4092|      2|    R_FlushGlobalCache(sym);
 4093|      2|#endif
 4094|      2|    return R_NilValue;
 4095|      2|}
R_NewEnv:
 4099|    781|{
 4100|    781|    if (hash)
  ------------------
  |  Branch (4100:9): [True: 779, False: 2]
  ------------------
 4101|    779|	return R_NewHashedEnv(enclos, size);
 4102|      2|    else
 4103|      2|	return NewEnvironment(R_NilValue, R_NilValue, enclos);
  ------------------
  |  | 1961|      2|# define NewEnvironment		Rf_NewEnvironment
  ------------------
 4104|    781|}
R_IsPackageEnv:
 4122|  3.88M|{
 4123|  3.88M|    if (TYPEOF(rho) == ENVSXP) {
  ------------------
  |  |  115|  3.88M|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (4123:9): [True: 3.88M, False: 0]
  ------------------
 4124|  3.88M|	SEXP name = getAttrib(rho, R_NameSymbol);
  ------------------
  |  |  924|  3.88M|#define getAttrib		Rf_getAttrib
  ------------------
 4125|  3.88M|	char *packprefix = "package:";
 4126|  3.88M|	size_t pplen = strlen(packprefix);
 4127|  3.88M|	if(isString(name) && length(name) > 0 &&
  ------------------
  |  |  966|  3.88M|#define isString		Rf_isString
  ------------------
              	if(isString(name) && length(name) > 0 &&
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (4127:5): [True: 0, False: 3.88M]
  |  Branch (4127:23): [True: 0, False: 0]
  ------------------
 4128|      0|	   ! strncmp(packprefix, CHAR(STRING_ELT(name, 0)), pplen)) /* ASCII */
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (4128:5): [True: 0, False: 0]
  ------------------
 4129|      0|	    return TRUE;
 4130|  3.88M|	else
 4131|  3.88M|	    return FALSE;
 4132|  3.88M|    }
 4133|      0|    else
 4134|      0|	return FALSE;
 4135|  3.88M|}
R_IsNamespaceEnv:
 4165|  4.65M|{
 4166|  4.65M|    if (rho == R_BaseNamespace)
  ------------------
  |  Branch (4166:9): [True: 385k, False: 4.27M]
  ------------------
 4167|   385k|	return TRUE;
 4168|  4.27M|    else if (TYPEOF(rho) == ENVSXP) {
  ------------------
  |  |  115|  4.27M|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (4168:14): [True: 3.88M, False: 386k]
  ------------------
 4169|  3.88M|	SEXP info = R_findVarInFrame(rho, R_NamespaceSymbol);
 4170|  3.88M|	if (info != R_UnboundValue && TYPEOF(info) == ENVSXP) {
  ------------------
  |  |  115|  2.45k|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (4170:6): [True: 2.45k, False: 3.88M]
  |  Branch (4170:32): [True: 2.45k, False: 0]
  ------------------
 4171|  2.45k|	    PROTECT(info);
  ------------------
  |  |  357|  2.45k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4172|  2.45k|	    SEXP spec = R_findVarInFrame(info, install("spec"));
  ------------------
  |  |  934|  2.45k|#define install			Rf_install
  ------------------
 4173|  2.45k|	    UNPROTECT(1);
  ------------------
  |  |  358|  2.45k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4174|  2.45k|	    if (spec != R_UnboundValue &&
  ------------------
  |  Branch (4174:10): [True: 2.45k, False: 0]
  ------------------
 4175|  2.45k|		TYPEOF(spec) == STRSXP && LENGTH(spec) > 0)
  ------------------
  |  |  126|  4.90k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (4175:3): [True: 2.45k, False: 0]
  |  Branch (4175:29): [True: 2.45k, False: 0]
  ------------------
 4176|  2.45k|		return TRUE;
 4177|      0|	    else
 4178|      0|		return FALSE;
 4179|  2.45k|	}
 4180|  3.88M|	else return FALSE;
 4181|  3.88M|    }
 4182|   386k|    else return FALSE;
 4183|  4.65M|}
do_isNSEnv:
 4186|    670|{
 4187|    670|    checkArity(op, args);
  ------------------
  |  | 1788|    670|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 4188|    670|    return R_IsNamespaceEnv(CAR(args)) ? mkTrue() : mkFalse();
  ------------------
  |  | 1960|    668|# define mkTrue			Rf_mkTrue
  ------------------
                  return R_IsNamespaceEnv(CAR(args)) ? mkTrue() : mkFalse();
  ------------------
  |  | 1956|      2|# define mkFalse		Rf_mkFalse
  ------------------
  |  Branch (4188:12): [True: 668, False: 2]
  ------------------
 4189|    670|}
R_NamespaceEnvSpec:
 4192|      8|{
 4193|       |    /* The namespace spec is a character vector that specifies the
 4194|       |       namespace.  The first element is the namespace name.  The
 4195|       |       second element, if present, is the namespace version.  Further
 4196|       |       elements may be added later. */
 4197|      8|    if (rho == R_BaseNamespace)
  ------------------
  |  Branch (4197:9): [True: 8, False: 0]
  ------------------
 4198|      8|	return R_BaseNamespaceName;
 4199|      0|    else if (TYPEOF(rho) == ENVSXP) {
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (4199:14): [True: 0, False: 0]
  ------------------
 4200|      0|	SEXP info = R_findVarInFrame(rho, R_NamespaceSymbol);
 4201|      0|	if (info != R_UnboundValue && TYPEOF(info) == ENVSXP) {
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (4201:6): [True: 0, False: 0]
  |  Branch (4201:32): [True: 0, False: 0]
  ------------------
 4202|      0|	    PROTECT(info);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4203|      0|	    SEXP spec = R_findVarInFrame(info, install("spec"));
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 4204|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4205|      0|	    if (spec != R_UnboundValue &&
  ------------------
  |  Branch (4205:10): [True: 0, False: 0]
  ------------------
 4206|      0|		TYPEOF(spec) == STRSXP && LENGTH(spec) > 0)
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (4206:3): [True: 0, False: 0]
  |  Branch (4206:29): [True: 0, False: 0]
  ------------------
 4207|      0|		return spec;
 4208|      0|	    else
 4209|      0|		return R_NilValue;
 4210|      0|	}
 4211|      0|	else return R_NilValue;
 4212|      0|    }
 4213|      0|    else return R_NilValue;
 4214|      8|}
R_FindNamespace:
 4217|      2|{
 4218|      2|    SEXP expr, val;
 4219|      2|    PROTECT(info);
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4220|      2|    SEXP s_getNamespace = install("getNamespace");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4221|      2|    PROTECT(expr = LCONS(s_getNamespace, LCONS(info, R_NilValue)));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4222|      2|    val = eval(expr, R_BaseEnv);
  ------------------
  |  |  913|      2|#define eval			Rf_eval
  ------------------
 4223|      2|    UNPROTECT(2);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4224|      2|    return val;
 4225|      2|}
do_regNS:
 4246|     14|{
 4247|     14|    SEXP name, val;
 4248|     14|    checkArity(op, args);
  ------------------
  |  | 1788|     14|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 4249|     14|    name = checkNSname(call, CAR(args));
 4250|     14|    val = CADR(args);
 4251|     14|    if (R_findVarInFrame(R_NamespaceRegistry, name) != R_UnboundValue)
  ------------------
  |  Branch (4251:9): [True: 0, False: 14]
  ------------------
 4252|      0|	errorcall(call, _("namespace already registered"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("namespace already registered"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4253|     14|    defineVar(name, val, R_NamespaceRegistry);
  ------------------
  |  |  905|     14|#define defineVar		Rf_defineVar
  ------------------
 4254|     14|    return R_NilValue;
 4255|     14|}
do_getRegNS:
 4277|  1.10k|{
 4278|  1.10k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.10k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 4279|  1.10k|    SEXP name = checkNSname(call, PROTECT(coerceVector(CAR(args), SYMSXP)));
  ------------------
  |  |  357|  1.10k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4280|  1.10k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.10k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4281|  1.10k|    SEXP val = R_findVarInFrame(R_NamespaceRegistry, name);
 4282|       |
 4283|  1.10k|    switch(PRIMVAL(op)) {
  ------------------
  |  | 1347|  1.10k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
 4284|  1.09k|    case 0: // get..()
  ------------------
  |  Branch (4284:5): [True: 1.09k, False: 12]
  ------------------
 4285|  1.09k|	if (val == R_UnboundValue)
  ------------------
  |  Branch (4285:6): [True: 16, False: 1.07k]
  ------------------
 4286|     16|	    return R_NilValue;
 4287|  1.07k|	else
 4288|  1.07k|	    return val;
 4289|     12|    case 1: // is..()
  ------------------
  |  Branch (4289:5): [True: 12, False: 1.09k]
  ------------------
 4290|     12|	return ScalarLogical(val == R_UnboundValue ? FALSE : TRUE);
  ------------------
  |  | 1023|     12|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  |  Branch (4290:23): [True: 12, False: 0]
  ------------------
 4291|       |
 4292|      0|    default: error(_("unknown op"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  default: error(_("unknown op"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (4292:5): [True: 0, False: 1.10k]
  ------------------
 4293|  1.10k|    }
 4294|      0|    return R_NilValue; // -Wall
 4295|  1.10k|}
R_getNSValue:
 4359|   386k|{
 4360|   386k|    static SEXP R_loadNamespaceSymbol = NULL;
 4361|   386k|    static SEXP R_exportsSymbol = NULL;
 4362|   386k|    static SEXP R_lazydataSymbol = NULL;
 4363|   386k|    static SEXP R_getNamespaceNameSymbol = NULL;
 4364|   386k|    if (R_loadNamespaceSymbol == NULL) {
  ------------------
  |  Branch (4364:9): [True: 2, False: 386k]
  ------------------
 4365|      2|	R_loadNamespaceSymbol = install("loadNamespace");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4366|      2|	R_exportsSymbol = install("exports");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4367|      2|	R_lazydataSymbol = install("lazydata");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4368|      2|	R_getNamespaceNameSymbol = install("getNamespaceName");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4369|      2|    }
 4370|       |
 4371|   386k|    if (R_IsNamespaceEnv(ns))
  ------------------
  |  Branch (4371:9): [True: 0, False: 386k]
  ------------------
 4372|      0|	PROTECT(ns);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4373|   386k|    else {
 4374|   386k|	SEXP pkg = checkNSname(call, ns);
 4375|   386k|	ns = R_findVarInFrame(R_NamespaceRegistry, pkg);
 4376|   386k|	if (ns == R_UnboundValue)
  ------------------
  |  Branch (4376:6): [True: 0, False: 386k]
  ------------------
 4377|      0|	    ns = callR1(R_loadNamespaceSymbol, pkg);
 4378|   386k|	PROTECT(ns);
  ------------------
  |  |  357|   386k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4379|   386k|	if (! R_IsNamespaceEnv(ns))
  ------------------
  |  Branch (4379:6): [True: 0, False: 386k]
  ------------------
 4380|      0|	    errorcall(call, _("bad namespace"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("bad namespace"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4381|   386k|    }
 4382|       |
 4383|   386k|    name = checkVarName(call, name);
 4384|       |
 4385|   386k|    SEXP val;
 4386|       |
 4387|       |    /* base or non-exported variables */
 4388|   386k|    if (ns == R_BaseNamespace || ! exported) {
  ------------------
  |  Branch (4388:9): [True: 385k, False: 969]
  |  Branch (4388:34): [True: 17, False: 952]
  ------------------
 4389|   385k|	val = getVarValInFrame(ns, name, FALSE);
 4390|   385k|	UNPROTECT(1); /* ns */
  ------------------
  |  |  358|   385k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4391|   385k|	return val;
 4392|   385k|    }
 4393|       |
 4394|       |    /* exported variables */
 4395|    952|    SEXP info = PROTECT(getVarValInFrame(ns, R_NamespaceSymbol, FALSE));
  ------------------
  |  |  357|    952|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4396|    952|    SEXP exports = PROTECT(getVarValInFrame(info, R_exportsSymbol, FALSE));
  ------------------
  |  |  357|    952|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4397|    952|    SEXP exportName = PROTECT(getVarValInFrame(exports, name, TRUE));
  ------------------
  |  |  357|    952|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4398|    952|    if (exportName != R_UnboundValue) {
  ------------------
  |  Branch (4398:9): [True: 952, False: 0]
  ------------------
 4399|    952|	val = eval(checkVarName(call, exportName), ns);
  ------------------
  |  |  913|    952|#define eval			Rf_eval
  ------------------
 4400|    952|	UNPROTECT(4);  /* ns, info, exports, exportName */
  ------------------
  |  |  358|    952|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4401|    952|	return val;
 4402|    952|    }
 4403|       |
 4404|       |    /* lazydata */
 4405|      0|    SEXP ld = PROTECT(getVarValInFrame(info, R_lazydataSymbol, FALSE));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4406|      0|    val = getVarValInFrame(ld, name, TRUE);
 4407|      0|    if (val != R_UnboundValue) {
  ------------------
  |  Branch (4407:9): [True: 0, False: 0]
  ------------------
 4408|      0|	UNPROTECT(5); /* ns, info, exports, exportName, ld */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4409|      0|	return val;
 4410|      0|    }
 4411|       |
 4412|      0|    SEXP nsname = PROTECT(callR1(R_getNamespaceNameSymbol, ns));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4413|      0|    if (TYPEOF(nsname) != STRSXP || LENGTH(nsname) != 1)
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (4413:9): [True: 0, False: 0]
  |  Branch (4413:37): [True: 0, False: 0]
  ------------------
 4414|      0|	errorcall(call, "bad value returned by `getNamespaceName'");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 4415|      0|    errorcall_cpy(call,
  ------------------
  |  | 1896|      0|# define errorcall_cpy		Rf_errorcall_cpy
  ------------------
 4416|      0|		  _("'%s' is not an exported object from 'namespace:%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4417|      0|		  EncodeChar(PRINTNAME(name)),
  ------------------
  |  | 1890|      0|# define EncodeChar             Rf_EncodeChar
  ------------------
 4418|      0|		  CHAR(STRING_ELT(nsname, 0)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 4419|       |    return NULL; /* not reached */
 4420|      0|}
do_colon2:
 4434|   386k|{
 4435|   386k|    checkArity(op, args);
  ------------------
  |  | 1788|   386k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 4436|       |    /* use R_NilValue for the call to avoid changing the error message */
 4437|   386k|    return R_getNSValue(R_NilValue, CAR(args), CADR(args), TRUE);
 4438|   386k|}
do_colon3:
 4442|     17|{
 4443|     17|    checkArity(op, args);
  ------------------
  |  | 1788|     17|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 4444|     17|    return R_getNSValue(call, CAR(args), CADR(args), FALSE);
 4445|     17|}
do_importIntoEnv:
 4448|     40|{
 4449|       |    /* This function copies values of variables from one environment
 4450|       |       to another environment, possibly with different names.
 4451|       |       Promises are not forced and active bindings are preserved. */
 4452|     40|    SEXP impenv, impnames, expenv, expnames;
 4453|     40|    SEXP impsym, expsym, val;
 4454|     40|    int i, n;
 4455|       |
 4456|     40|    checkArity(op, args);
  ------------------
  |  | 1788|     40|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 4457|       |
 4458|     40|    impenv = CAR(args); args = CDR(args);
 4459|     40|    impnames = CAR(args); args = CDR(args);
 4460|     40|    expenv = CAR(args); args = CDR(args);
 4461|     40|    expnames = CAR(args); args = CDR(args);
 4462|       |
 4463|     40|    if (TYPEOF(impenv) == NILSXP)
  ------------------
  |  |  111|     40|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (4463:9): [True: 0, False: 40]
  ------------------
 4464|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4465|     40|    if (TYPEOF(impenv) != ENVSXP &&
  ------------------
  |  |  115|     80|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (4465:9): [True: 0, False: 40]
  ------------------
 4466|      0|	TYPEOF((impenv = simple_as_environment(impenv))) != ENVSXP)
  ------------------
  |  | 2187|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (2187:37): [True: 0, False: 0]
  |  |  |  Branch (2187:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	TYPEOF((impenv = simple_as_environment(impenv))) != ENVSXP)
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (4466:2): [True: 0, False: 0]
  ------------------
 4467|      0|	error(_("bad import environment argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("bad import environment argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4468|     40|    if (TYPEOF(expenv) == NILSXP)
  ------------------
  |  |  111|     40|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (4468:9): [True: 0, False: 40]
  ------------------
 4469|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4470|     40|    if (TYPEOF(expenv) != ENVSXP &&
  ------------------
  |  |  115|     80|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (4470:9): [True: 0, False: 40]
  ------------------
 4471|      0|	TYPEOF((expenv = simple_as_environment(expenv))) != ENVSXP)
  ------------------
  |  | 2187|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (2187:37): [True: 0, False: 0]
  |  |  |  Branch (2187:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	TYPEOF((expenv = simple_as_environment(expenv))) != ENVSXP)
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (4471:2): [True: 0, False: 0]
  ------------------
 4472|      0|	error(_("bad export environment argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("bad export environment argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4473|     40|    if (TYPEOF(impnames) != STRSXP || TYPEOF(expnames) != STRSXP)
  ------------------
  |  |  126|     80|#define STRSXP	    16	  /* string vectors */
  ------------------
                  if (TYPEOF(impnames) != STRSXP || TYPEOF(expnames) != STRSXP)
  ------------------
  |  |  126|     40|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (4473:9): [True: 0, False: 40]
  |  Branch (4473:39): [True: 0, False: 40]
  ------------------
 4474|      0|	error(_("invalid '%s' argument"), "names");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "names");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4475|     40|    if (LENGTH(impnames) != LENGTH(expnames))
  ------------------
  |  Branch (4475:9): [True: 0, False: 40]
  ------------------
 4476|      0|	error(_("length of import and export names must match"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("length of import and export names must match"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4477|       |
 4478|     40|    n = LENGTH(impnames);
 4479|  4.15k|    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (4479:17): [True: 4.11k, False: 40]
  ------------------
 4480|  4.11k|	impsym = installTrChar(STRING_ELT(impnames, i));
  ------------------
  |  |  937|  4.11k|#define installTrChar		Rf_installTrChar
  ------------------
 4481|  4.11k|	expsym = installTrChar(STRING_ELT(expnames, i));
  ------------------
  |  |  937|  4.11k|#define installTrChar		Rf_installTrChar
  ------------------
 4482|       |
 4483|       |	/* find the binding--may be a CONS cell or a symbol */
 4484|  4.11k|	SEXP binding = R_NilValue;
 4485|  4.11k|	for (SEXP env = expenv;
 4486|  8.22k|	     env != R_EmptyEnv && binding == R_NilValue;
  ------------------
  |  Branch (4486:7): [True: 8.22k, False: 0]
  |  Branch (4486:28): [True: 4.11k, False: 4.11k]
  ------------------
 4487|  4.11k|	     env = ENCLOS(env))
 4488|  4.11k|	    if (env == R_BaseNamespace) {
  ------------------
  |  Branch (4488:10): [True: 4, False: 4.11k]
  ------------------
 4489|      4|		if (SYMVALUE(expsym) != R_UnboundValue)
  ------------------
  |  Branch (4489:7): [True: 4, False: 0]
  ------------------
 4490|      4|		    binding = expsym;
 4491|      4|	    } else
 4492|  4.11k|		binding = findVarLocInFrame(env, expsym, NULL);
 4493|  4.11k|	if (binding == R_NilValue)
  ------------------
  |  Branch (4493:6): [True: 0, False: 4.11k]
  ------------------
 4494|      0|	    binding = expsym;
 4495|       |
 4496|       |	/* get value of the binding; do not force promises */
 4497|  4.11k|	if (TYPEOF(binding) == SYMSXP) {
  ------------------
  |  |  112|  4.11k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (4497:6): [True: 4, False: 4.10k]
  ------------------
 4498|      4|	    if (SYMVALUE(expsym) == R_UnboundValue)
  ------------------
  |  Branch (4498:10): [True: 0, False: 4]
  ------------------
 4499|      0|		error(_("exported symbol '%s' has no value"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("exported symbol '%s' has no value"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4500|      0|		      CHAR(PRINTNAME(expsym)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 4501|      4|	    val = SYMVALUE(expsym);
 4502|      4|	}
 4503|  4.10k|	else val = CAR(binding);
 4504|       |
 4505|       |	/* import the binding */
 4506|  4.11k|	if (IS_ACTIVE_BINDING(binding))
  ------------------
  |  Branch (4506:6): [True: 0, False: 4.11k]
  ------------------
 4507|      0|	    R_MakeActiveBinding(impsym, val, impenv);
 4508|       |	/* This is just a tiny optimization */
 4509|  4.11k|	else if (impenv == R_BaseNamespace || impenv == R_BaseEnv)
  ------------------
  |  Branch (4509:11): [True: 0, False: 4.11k]
  |  Branch (4509:40): [True: 0, False: 4.11k]
  ------------------
 4510|      0|	    gsetVar(impsym, val, impenv);
  ------------------
  |  |  932|      0|#define gsetVar			Rf_gsetVar
  ------------------
 4511|  4.11k|	else
 4512|  4.11k|	    defineVar(impsym, val, impenv);
  ------------------
  |  |  905|  4.11k|#define defineVar		Rf_defineVar
  ------------------
 4513|  4.11k|    }
 4514|     40|    return R_NilValue;
 4515|     40|}
Rf_mkCharCE:
 4537|   621k|{
 4538|   621k|    size_t len =  strlen(name);
 4539|   621k|    if (len > INT_MAX)
  ------------------
  |  Branch (4539:9): [True: 0, False: 621k]
  ------------------
 4540|      0|	error("R character strings are limited to 2^31-1 bytes");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4541|   621k|   return mkCharLenCE(name, (int) len, enc);
  ------------------
  |  | 1001|   621k|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
 4542|   621k|}
Rf_mkChar:
 4551|   431k|{
 4552|   431k|    size_t len =  strlen(name);
 4553|   431k|    if (len > INT_MAX)
  ------------------
  |  Branch (4553:9): [True: 0, False: 431k]
  ------------------
 4554|      0|	error("R character strings are limited to 2^31-1 bytes");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4555|   431k|    return mkCharLenCE(name, (int) len, CE_NATIVE);
  ------------------
  |  | 1001|   431k|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
 4556|   431k|}
Rf_InitStringHash:
 4600|      2|{
 4601|      2|    R_StringHash = R_NewHashTable(char_hash_size);
 4602|      2|}
Rf_mkCharLenCE:
 4731|  1.19M|{
 4732|  1.19M|    SEXP cval, chain;
 4733|  1.19M|    unsigned int hashcode;
 4734|  1.19M|    int need_enc;
 4735|  1.19M|    Rboolean embedNul = FALSE, is_ascii = TRUE;
 4736|  1.19M|    static int checkValid = -1;
 4737|  1.19M|    static int actionWhenInvalid = 0;
 4738|       |
 4739|  1.19M|    switch(enc){
 4740|  1.19M|    case CE_NATIVE:
  ------------------
  |  Branch (4740:5): [True: 1.19M, False: 12]
  ------------------
 4741|  1.19M|    case CE_UTF8:
  ------------------
  |  Branch (4741:5): [True: 12, False: 1.19M]
  ------------------
 4742|  1.19M|    case CE_LATIN1:
  ------------------
  |  Branch (4742:5): [True: 0, False: 1.19M]
  ------------------
 4743|  1.19M|    case CE_BYTES:
  ------------------
  |  Branch (4743:5): [True: 0, False: 1.19M]
  ------------------
 4744|  1.19M|    case CE_SYMBOL:
  ------------------
  |  Branch (4744:5): [True: 0, False: 1.19M]
  ------------------
 4745|  1.19M|    case CE_ANY:
  ------------------
  |  Branch (4745:5): [True: 0, False: 1.19M]
  ------------------
 4746|  1.19M|	break;
 4747|      0|    default:
  ------------------
  |  Branch (4747:5): [True: 0, False: 1.19M]
  ------------------
 4748|      0|	error(_("unknown encoding: %d"), enc);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("unknown encoding: %d"), enc);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4749|  1.19M|    }
 4750|  25.3M|    for (int slen = 0; slen < len; slen++) {
  ------------------
  |  Branch (4750:24): [True: 24.1M, False: 1.19M]
  ------------------
 4751|  24.1M|	if ((unsigned int) name[slen] > 127) is_ascii = FALSE;
  ------------------
  |  Branch (4751:6): [True: 5.23k, False: 24.1M]
  ------------------
 4752|  24.1M|	if (!name[slen]) embedNul = TRUE;
  ------------------
  |  Branch (4752:6): [True: 0, False: 24.1M]
  ------------------
 4753|  24.1M|    }
 4754|  1.19M|    if (embedNul) {
  ------------------
  |  Branch (4754:9): [True: 0, False: 1.19M]
  ------------------
 4755|      0|	SEXP c;
 4756|       |	/* This is tricky: we want to make a reasonable job of
 4757|       |	   representing this string, and EncodeString() is the most
 4758|       |	   comprehensive.  It may translate c, and the R_alloc() that
 4759|       |	   involves can run the GC, so c must be protected: the error
 4760|       |	   unwind pops from the PROTECT stack. */
 4761|      0|	PROTECT(c = allocCharsxp(len));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4762|      0|	if (len) memcpy(CHAR_RW(c), name, len);
  ------------------
  |  |  930|      0|#define CHAR_RW(x)	((char *) CHAR(x))
  |  |  ------------------
  |  |  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  ------------------
  |  Branch (4762:6): [True: 0, False: 0]
  ------------------
 4763|      0|	switch(enc) {
 4764|      0|	case CE_UTF8: SET_UTF8(c); break;
  ------------------
  |  Branch (4764:2): [True: 0, False: 0]
  ------------------
 4765|      0|	case CE_LATIN1: SET_LATIN1(c); break;
  ------------------
  |  Branch (4765:2): [True: 0, False: 0]
  ------------------
 4766|      0|	case CE_BYTES: SET_BYTES(c); break;
  ------------------
  |  Branch (4766:2): [True: 0, False: 0]
  ------------------
 4767|      0|	default: break;
  ------------------
  |  Branch (4767:2): [True: 0, False: 0]
  ------------------
 4768|      0|	}
 4769|      0|	if (is_ascii) SET_ASCII(c);
  ------------------
  |  Branch (4769:6): [True: 0, False: 0]
  ------------------
 4770|      0|	error(_("embedded nul in string: '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("embedded nul in string: '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4771|      0|	      EncodeString(c, 0, 0, Rprt_adj_none));
  ------------------
  |  | 1893|      0|# define EncodeString           Rf_EncodeString
  ------------------
 4772|      0|    }
 4773|       |
 4774|  1.19M|    if (enc && is_ascii) enc = CE_NATIVE;
  ------------------
  |  Branch (4774:9): [True: 12, False: 1.19M]
  |  Branch (4774:16): [True: 12, False: 0]
  ------------------
 4775|  1.19M|    switch(enc) {
 4776|      0|    case CE_UTF8: need_enc = UTF8_MASK; break;
  ------------------
  |  |  935|      0|#define UTF8_MASK (1<<3)
  ------------------
  |  Branch (4776:5): [True: 0, False: 1.19M]
  ------------------
 4777|      0|    case CE_LATIN1: need_enc = LATIN1_MASK; break;
  ------------------
  |  |  934|      0|#define LATIN1_MASK (1<<2)
  ------------------
  |  Branch (4777:5): [True: 0, False: 1.19M]
  ------------------
 4778|      0|    case CE_BYTES: need_enc = BYTES_MASK; break;
  ------------------
  |  |  933|      0|#define BYTES_MASK (1<<1)
  ------------------
  |  Branch (4778:5): [True: 0, False: 1.19M]
  ------------------
 4779|  1.19M|    default: need_enc = 0;
  ------------------
  |  Branch (4779:5): [True: 1.19M, False: 0]
  ------------------
 4780|  1.19M|    }
 4781|       |
 4782|  1.19M|    hashcode = char_hash(name, len) & char_hash_mask;
 4783|       |
 4784|       |    /* Search for a cached value */
 4785|  1.19M|    cval = R_NilValue;
 4786|  1.19M|    chain = VECTOR_ELT(R_StringHash, hashcode);
 4787|  1.28M|    for (; !ISNULL(chain) ; chain = CXTAIL(chain)) {
  ------------------
  |  |  176|  1.28M|#define ISNULL(x) ((x) == R_NilValue)
  ------------------
                  for (; !ISNULL(chain) ; chain = CXTAIL(chain)) {
  ------------------
  |  |  972|  94.0k|# define CXTAIL(x) ATTRIB(x)
  ------------------
  |  Branch (4787:12): [True: 1.24M, False: 35.7k]
  ------------------
 4788|  1.24M|	SEXP val = CXHEAD(chain);
  ------------------
  |  |  971|  1.24M|# define CXHEAD(x) (x)
  ------------------
 4789|  1.24M|	if (TYPEOF(val) != CHARSXP) break; /* sanity check */
  ------------------
  |  |  120|  1.24M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (4789:6): [True: 0, False: 1.24M]
  ------------------
 4790|  1.24M|	if (need_enc == (ENC_KNOWN(val) | IS_BYTES(val)) &&
  ------------------
  |  Branch (4790:6): [True: 1.24M, False: 0]
  ------------------
 4791|  1.24M|	    LENGTH(val) == len &&  /* quick pretest */
  ------------------
  |  Branch (4791:6): [True: 1.15M, False: 93.3k]
  ------------------
 4792|  1.15M|	    (!len || (memcmp(CHAR(val), name, len) == 0))) { // called with len = 0
  ------------------
  |  |  203|  1.04M|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (4792:7): [True: 106k, False: 1.04M]
  |  Branch (4792:15): [True: 1.04M, False: 664]
  ------------------
 4793|  1.15M|	    cval = val;
 4794|  1.15M|	    break;
 4795|  1.15M|	}
 4796|  1.24M|    }
 4797|  1.19M|    if (cval == R_NilValue) {
  ------------------
  |  Branch (4797:9): [True: 35.7k, False: 1.15M]
  ------------------
 4798|       |	/* no cached value; need to allocate one and add to the cache */
 4799|  35.7k|	PROTECT(cval = allocCharsxp(len));
  ------------------
  |  |  357|  35.7k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4800|  35.7k|	if (len) memcpy(CHAR_RW(cval), name, len);
  ------------------
  |  |  930|  35.7k|#define CHAR_RW(x)	((char *) CHAR(x))
  |  |  ------------------
  |  |  |  |  203|  35.7k|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  ------------------
  |  Branch (4800:6): [True: 35.7k, False: 2]
  ------------------
 4801|  35.7k|	switch(enc) {
 4802|  35.7k|	case CE_NATIVE:
  ------------------
  |  Branch (4802:2): [True: 35.7k, False: 0]
  ------------------
 4803|  35.7k|	    break;          /* don't set encoding */
 4804|      0|	case CE_UTF8:
  ------------------
  |  Branch (4804:2): [True: 0, False: 35.7k]
  ------------------
 4805|      0|	    SET_UTF8(cval);
 4806|      0|	    break;
 4807|      0|	case CE_LATIN1:
  ------------------
  |  Branch (4807:2): [True: 0, False: 35.7k]
  ------------------
 4808|      0|	    SET_LATIN1(cval);
 4809|      0|	    break;
 4810|      0|	case CE_BYTES:
  ------------------
  |  Branch (4810:2): [True: 0, False: 35.7k]
  ------------------
 4811|      0|	    SET_BYTES(cval);
 4812|      0|	    break;
 4813|      0|	default:
  ------------------
  |  Branch (4813:2): [True: 0, False: 35.7k]
  ------------------
 4814|      0|	    error("unknown encoding mask: %d", enc);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4815|  35.7k|	}
 4816|  35.7k|	if (is_ascii) SET_ASCII(cval);
  ------------------
  |  Branch (4816:6): [True: 35.0k, False: 695]
  ------------------
 4817|  35.7k|	SET_CACHED(cval);  /* Mark it */
 4818|       |	/* add the new value to the cache */
 4819|  35.7k|	chain = VECTOR_ELT(R_StringHash, hashcode);
 4820|  35.7k|	if (ISNULL(chain))
  ------------------
  |  |  176|  35.7k|#define ISNULL(x) ((x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (176:19): [True: 32.1k, False: 3.62k]
  |  |  ------------------
  ------------------
 4821|  32.1k|	    SET_HASHPRI(R_StringHash, HASHPRI(R_StringHash) + 1);
  ------------------
  |  |  209|  32.1k|#define SET_HASHPRI(x,v)     SET_TRUELENGTH(x,v)
  ------------------
 4822|       |	/* this is a destructive modification */
 4823|  35.7k|	chain = SET_CXTAIL(cval, chain);
 4824|  35.7k|	SET_VECTOR_ELT(R_StringHash, hashcode, chain);
 4825|       |
 4826|       |	/* resize the hash table if necessary with the new entry still
 4827|       |	   protected.
 4828|       |	   Maximum possible power of two is 2^30 for a VECSXP.
 4829|       |	   FIXME: this has changed with long vectors.
 4830|       |	*/
 4831|  35.7k|	if (R_HashSizeCheck(R_StringHash)
  ------------------
  |  Branch (4831:6): [True: 0, False: 35.7k]
  ------------------
 4832|      0|	    && char_hash_size < 1073741824 /* 2^30 */)
  ------------------
  |  Branch (4832:9): [True: 0, False: 0]
  ------------------
 4833|      0|	    R_StringHash_resize(char_hash_size * 2);
 4834|       |
 4835|  35.7k|	if (checkValid && !IS_ASCII(cval)) {
  ------------------
  |  Branch (4835:6): [True: 17.0k, False: 18.6k]
  |  Branch (4835:20): [True: 1, False: 17.0k]
  ------------------
 4836|      1|	    if (checkValid == -1) {
  ------------------
  |  Branch (4836:10): [True: 1, False: 0]
  ------------------
 4837|      1|		checkValid = 0;
 4838|       |		/* _R_CHECK_STRING_VALIDITY_ = XY (decimal)
 4839|       |
 4840|       |		   Y = 0 ... no checks
 4841|       |		   Y = 1 ... check marked strings
 4842|       |		   Y = 2 ... check also native strings
 4843|       |
 4844|       |		   X = 0 ... just print
 4845|       |		   X = 1 ... print + issue a warning
 4846|       |		   X = 2 ... print + throw R error
 4847|       |		   X = 3 ... print + abort R
 4848|       |
 4849|       |		   This is experimental and will be likely changed or
 4850|       |		   removed.
 4851|       |		*/
 4852|      1|		const char *p = getenv("_R_CHECK_STRING_VALIDITY_");
 4853|      1|		if (p) {
  ------------------
  |  Branch (4853:7): [True: 0, False: 1]
  ------------------
 4854|      0|		    checkValid = atoi(p);
 4855|      0|		    actionWhenInvalid = checkValid / 10;
 4856|      0|		    checkValid -= actionWhenInvalid * 10;
 4857|       |
 4858|      0|		    if (checkValid < 0 || checkValid > 2) {
  ------------------
  |  Branch (4858:11): [True: 0, False: 0]
  |  Branch (4858:29): [True: 0, False: 0]
  ------------------
 4859|      0|			checkValid = 0;
 4860|      0|			actionWhenInvalid = 0;
 4861|      0|		    }
 4862|      0|		    if (actionWhenInvalid < 0 || actionWhenInvalid > 3)
  ------------------
  |  Branch (4862:11): [True: 0, False: 0]
  |  Branch (4862:36): [True: 0, False: 0]
  ------------------
 4863|      0|			actionWhenInvalid = 0;
 4864|      0|		}
 4865|      1|	    }
 4866|      1|	    if (checkValid >= 1) {
  ------------------
  |  Branch (4866:10): [True: 0, False: 1]
  ------------------
 4867|       |		/* check strings flagged UTF-8 and latin1 */
 4868|      0|		if (IS_UTF8(cval)) {
  ------------------
  |  Branch (4868:7): [True: 0, False: 0]
  ------------------
 4869|      0|		    if (!utf8Valid(CHAR(cval)))
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
              		    if (!utf8Valid(CHAR(cval)))
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (4869:11): [True: 0, False: 0]
  ------------------
 4870|      0|			reportInvalidString(cval, actionWhenInvalid);
 4871|      0|		    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4872|      0|		    return cval;
 4873|      0|		} else if (IS_LATIN1(cval)) {
  ------------------
  |  Branch (4873:14): [True: 0, False: 0]
  ------------------
 4874|      0|		    const void *vmax = vmaxget();
 4875|      0|		    const wchar_t *dummy = wtransChar2(cval);
  ------------------
  |  | 2017|      0|# define wtransChar2		Rf_wtransChar2
  ------------------
 4876|      0|		    if (!dummy)
  ------------------
  |  Branch (4876:11): [True: 0, False: 0]
  ------------------
 4877|      0|			reportInvalidString(cval, actionWhenInvalid);
 4878|      0|		    vmaxset(vmax);
 4879|      0|		    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4880|      0|		    return cval;
 4881|      0|		}
 4882|      0|	    }
 4883|      1|	    if (checkValid >= 2 && !IS_BYTES(cval)) {
  ------------------
  |  Branch (4883:10): [True: 0, False: 1]
  |  Branch (4883:29): [True: 0, False: 0]
  ------------------
 4884|       |		/* check strings flagged native/unknown */
 4885|      0|		if (known_to_be_utf8) {
  ------------------
  |  Branch (4885:7): [True: 0, False: 0]
  ------------------
 4886|      0|		    if (!utf8Valid(CHAR(cval)))
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
              		    if (!utf8Valid(CHAR(cval)))
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (4886:11): [True: 0, False: 0]
  ------------------
 4887|      0|			reportInvalidString(cval, actionWhenInvalid);
 4888|      0|		    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4889|      0|		    return cval;
 4890|      0|		} else if (!mbcsValid(CHAR(cval))) {
  ------------------
  |  | 1952|      0|# define mbcsValid		Rf_mbcsValid
  ------------------
              		} else if (!mbcsValid(CHAR(cval))) {
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (4890:14): [True: 0, False: 0]
  ------------------
 4891|      0|		    reportInvalidString(cval, actionWhenInvalid);
 4892|      0|		    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4893|      0|		    return cval;
 4894|      0|		}
 4895|      0|	    }
 4896|      1|	}
 4897|       |
 4898|  35.7k|	UNPROTECT(1);
  ------------------
  |  |  358|  35.7k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4899|  35.7k|    }
 4900|  1.19M|    return cval;
 4901|  1.19M|}
Rf_topenv:
 4966|  1.55M|SEXP topenv(SEXP target, SEXP envir) {
 4967|  1.55M|    SEXP env = envir;
 4968|  5.43M|    while (env != R_EmptyEnv) {
  ------------------
  |  Branch (4968:12): [True: 5.43M, False: 0]
  ------------------
 4969|  5.43M|	if (env == target || env == R_GlobalEnv ||
  ------------------
  |  Branch (4969:6): [True: 0, False: 5.43M]
  |  Branch (4969:23): [True: 0, False: 5.43M]
  ------------------
 4970|  5.43M|	    env == R_BaseEnv || env == R_BaseNamespace ||
  ------------------
  |  Branch (4970:6): [True: 2, False: 5.43M]
  |  Branch (4970:26): [True: 1.55M, False: 3.88M]
  ------------------
 4971|  3.88M|	    R_IsPackageEnv(env) || R_IsNamespaceEnv(env) ||
  ------------------
  |  Branch (4971:6): [True: 0, False: 3.88M]
  |  Branch (4971:29): [True: 1.16k, False: 3.88M]
  ------------------
 4972|  3.88M|	    R_existsVarInFrame(env, R_dot_packageName)) {
  ------------------
  |  Branch (4972:6): [True: 0, False: 3.88M]
  ------------------
 4973|  1.55M|	    return env;
 4974|  3.88M|	} else {
 4975|  3.88M|	    env = ENCLOS(env);
 4976|  3.88M|	}
 4977|  5.43M|    }
 4978|      0|    return R_GlobalEnv;
 4979|  1.55M|}
do_topenv:
 4987|      1|attribute_hidden SEXP do_topenv(SEXP call, SEXP op, SEXP args, SEXP rho) {
 4988|      1|    checkArity(op, args);
  ------------------
  |  | 1788|      1|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 4989|      1|    SEXP envir = CAR(args);
 4990|      1|    SEXP target = CADR(args); // = matchThisEnv, typically NULL (R_NilValue)
 4991|      1|    if (TYPEOF(envir) != ENVSXP) envir = rho; // envir = parent.frame()
  ------------------
  |  |  115|      1|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (4991:9): [True: 0, False: 1]
  ------------------
 4992|      1|    if (target != R_NilValue && TYPEOF(target) != ENVSXP)  target = R_NilValue;
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (4992:9): [True: 0, False: 1]
  |  Branch (4992:33): [True: 0, False: 0]
  ------------------
 4993|      1|    return topenv(target, envir);
  ------------------
  |  | 1036|      1|#define topenv		        Rf_topenv
  ------------------
 4994|      1|}
envir.c:R_NewHashTable:
  353|  1.40k|{
  354|  1.40k|    SEXP table;
  355|       |
  356|  1.40k|    if (size <= 0) size = HASHMINSIZE;
  ------------------
  |  |  208|      8|#define HASHMINSIZE	     29
  ------------------
  |  Branch (356:9): [True: 8, False: 1.40k]
  ------------------
  357|       |
  358|       |    /* Allocate hash table in the form of a vector */
  359|  1.40k|    PROTECT(table = allocVector(VECSXP, size));
  ------------------
  |  |  357|  1.40k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  360|  1.40k|    SET_HASHPRI(table, 0);
  ------------------
  |  |  209|  1.40k|#define SET_HASHPRI(x,v)     SET_TRUELENGTH(x,v)
  ------------------
  361|  1.40k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.40k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  362|  1.40k|    return(table);
  363|  1.40k|}
envir.c:RemoveFromList:
  942|     34|{
  943|     34|    if (list == R_NilValue) {
  ------------------
  |  Branch (943:9): [True: 0, False: 34]
  ------------------
  944|      0|	*found = 0;
  945|      0|	return R_NilValue;
  946|      0|    }
  947|     34|    else if (TAG(list) == thing) {
  ------------------
  |  Branch (947:14): [True: 18, False: 16]
  ------------------
  948|     18|	*found = 1;
  949|     18|	SET_BNDCELL(list, R_UnboundValue); /* in case binding is cached */
  950|     18|	LOCK_BINDING(list);                /* in case binding is cached */
  951|     18|	SEXP rest = CDR(list);
  952|     18|	SETCDR(list, R_NilValue);          /* to fix refcnt on 'rest' */
  953|     18|	return rest;
  954|     18|    }
  955|     16|    else {
  956|     16|	SEXP last = list;
  957|     16|	SEXP next = CDR(list);
  958|     16|	while (next != R_NilValue) {
  ------------------
  |  Branch (958:9): [True: 16, False: 0]
  ------------------
  959|     16|	    if (TAG(next) == thing) {
  ------------------
  |  Branch (959:10): [True: 16, False: 0]
  ------------------
  960|     16|		*found = 1;
  961|     16|		SETCAR(next, R_UnboundValue); /* in case binding is cached */
  962|     16|		LOCK_BINDING(next);           /* in case binding is cached */
  963|     16|		SETCDR(last, CDR(next));
  964|     16|		SETCDR(next, R_NilValue);     /* to fix refcnt on 'list' */
  965|     16|		return list;
  966|     16|	    }
  967|      0|	    else {
  968|      0|		last = next;
  969|      0|		next = CDR(next);
  970|      0|	    }
  971|     16|	}
  972|      0|	*found = 0;
  973|      0|	return list;
  974|     16|    }
  975|     34|}
envir.c:R_FlushGlobalCache:
  710|  5.24k|{
  711|  5.24k|    SEXP entry = R_HashGetLoc(hashIndex(sym, R_GlobalCache), sym,
  712|  5.24k|			      R_GlobalCache);
  713|  5.24k|    if (entry != R_NilValue) {
  ------------------
  |  Branch (713:9): [True: 0, False: 5.24k]
  ------------------
  714|      0|	SETCAR(entry, R_UnboundValue);
  715|      0|#ifdef FAST_BASE_CACHE_LOOKUP
  716|      0|	UNSET_BASE_SYM_CACHED(sym);
  717|      0|#endif
  718|      0|    }
  719|  5.24k|}
envir.c:R_HashGetLoc:
  329|  23.6k|{
  330|  23.6k|    SEXP chain;
  331|       |
  332|       |    /* Grab the chain from the hashtable */
  333|  23.6k|    chain = VECTOR_ELT(table, hashcode);
  334|       |    /* Retrieve the value from the chain */
  335|  34.8k|    for (; !ISNULL(chain); chain = CDR(chain))
  ------------------
  |  |  176|  34.8k|#define ISNULL(x) ((x) == R_NilValue)
  ------------------
  |  Branch (335:12): [True: 29.3k, False: 5.49k]
  ------------------
  336|  29.3k|	if (TAG(chain) == symbol) return chain;
  ------------------
  |  Branch (336:6): [True: 18.1k, False: 11.1k]
  ------------------
  337|       |    /* If not found */
  338|  5.49k|    return R_NilValue;
  339|  23.6k|}
envir.c:hashIndex:
  700|  5.25k|{
  701|  5.25k|    SEXP c = PRINTNAME(symbol);
  702|  5.25k|    if( !HASHASH(c) ) {
  ------------------
  |  Branch (702:9): [True: 0, False: 5.25k]
  ------------------
  703|      0|	SET_HASHVALUE(c, R_Newhashpjw(CHAR(c)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  704|      0|	SET_HASHASH(c, 1);
  705|      0|    }
  706|  5.25k|    return HASHVALUE(c) % HASHSIZE(table);
  ------------------
  |  |  205|  5.25k|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
  707|  5.25k|}
envir.c:R_HashDelete:
  397|      2|{
  398|      2|    int idx;
  399|      2|    SEXP list, hashtab;
  400|       |
  401|      2|    hashtab = HASHTAB(env);
  402|      2|    idx = hashcode % HASHSIZE(hashtab);
  ------------------
  |  |  205|      2|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
  403|      2|    list = RemoveFromList(symbol, VECTOR_ELT(hashtab, idx), found);
  404|      2|    if (*found) {
  ------------------
  |  Branch (404:9): [True: 2, False: 0]
  ------------------
  405|      2|	if (env == R_GlobalEnv)
  ------------------
  |  Branch (405:6): [True: 2, False: 0]
  ------------------
  406|      2|	    R_DirtyImage = 1;
  407|      2|	if (list == R_NilValue)
  ------------------
  |  Branch (407:6): [True: 2, False: 0]
  ------------------
  408|      2|	    SET_HASHPRI(hashtab, HASHPRI(hashtab) - 1);
  ------------------
  |  |  209|      2|#define SET_HASHPRI(x,v)     SET_TRUELENGTH(x,v)
  ------------------
  409|      2|	SET_VECTOR_ELT(hashtab, idx, list);
  410|      2|    }
  411|      2|}
envir.c:findVarLocInFrame:
 1031|  17.3M|{
 1032|  17.3M|    int hashcode;
 1033|  17.3M|    SEXP frame, c;
 1034|       |
 1035|  17.3M|    if (rho == R_BaseEnv || rho == R_BaseNamespace)
  ------------------
  |  Branch (1035:9): [True: 0, False: 17.3M]
  |  Branch (1035:29): [True: 4.73k, False: 17.3M]
  ------------------
 1036|  4.73k|	return (SYMVALUE(symbol) == R_UnboundValue) ? R_NilValue : symbol;
  ------------------
  |  Branch (1036:9): [True: 0, False: 4.73k]
  ------------------
 1037|       |
 1038|  17.3M|    if (rho == R_EmptyEnv)
  ------------------
  |  Branch (1038:9): [True: 0, False: 17.3M]
  ------------------
 1039|      0|	return R_NilValue;
 1040|       |
 1041|  17.3M|    if(IS_USER_DATABASE(rho)) {
  ------------------
  |  |  102|  17.3M|#define IS_USER_DATABASE(rho)  (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  ------------------
  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  ------------------
  |  |  |  Branch (102:33): [True: 0, False: 17.3M]
  |  |  |  Branch (102:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1042|      0|	R_ObjectTable *table;
 1043|      0|	SEXP val, tmp = R_NilValue;
 1044|      0|	table = (R_ObjectTable *) R_ExternalPtrAddr(HASHTAB(rho));
 1045|       |	/* Better to use exists() here if we don't actually need the value! */
 1046|      0|	val = table->get(CHAR(PRINTNAME(symbol)), canCache, table);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1047|      0|	if(val != R_UnboundValue) {
  ------------------
  |  Branch (1047:5): [True: 0, False: 0]
  ------------------
 1048|       |	    /* The result should probably be identified as being from
 1049|       |	       a user database, or maybe use an active binding
 1050|       |	       mechanism to allow setting a new value to get back to
 1051|       |	       the data base. */
 1052|      0|	    tmp = allocSExp(LISTSXP);
  ------------------
  |  |  874|      0|#define allocSExp		Rf_allocSExp
  ------------------
              	    tmp = allocSExp(LISTSXP);
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
 1053|      0|	    SETCAR(tmp, val);
 1054|      0|	    SET_TAG(tmp, symbol);
 1055|       |	    /* If the database has a canCache method, then call that.
 1056|       |	       Otherwise, we believe the setting for canCache. */
 1057|      0|	    if(canCache && table->canCache) {
  ------------------
  |  Branch (1057:9): [True: 0, False: 0]
  |  Branch (1057:21): [True: 0, False: 0]
  ------------------
 1058|      0|		PROTECT(tmp);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1059|      0|		*canCache = table->canCache(CHAR(PRINTNAME(symbol)), table);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1060|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1061|      0|	    }
 1062|      0|	    MARK_NOT_MUTABLE(val); /* to keep complex assignment code sane */
 1063|      0|	}
 1064|      0|	return(tmp);
 1065|      0|    }
 1066|       |
 1067|  17.3M|    if (HASHTAB(rho) == R_NilValue) {
  ------------------
  |  Branch (1067:9): [True: 17.2M, False: 18.4k]
  ------------------
 1068|  17.2M|	frame = FRAME(rho);
 1069|  36.2M|	while (frame != R_NilValue && TAG(frame) != symbol)
  ------------------
  |  Branch (1069:9): [True: 36.0M, False: 124k]
  |  Branch (1069:32): [True: 18.9M, False: 17.1M]
  ------------------
 1070|  18.9M|	    frame = CDR(frame);
 1071|  17.2M|	return frame;
 1072|  17.2M|    }
 1073|  18.4k|    else {
 1074|  18.4k|	c = PRINTNAME(symbol);
 1075|  18.4k|	if( !HASHASH(c) ) {
  ------------------
  |  Branch (1075:6): [True: 0, False: 18.4k]
  ------------------
 1076|      0|	    SET_HASHVALUE(c, R_Newhashpjw(CHAR(c)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1077|      0|	    SET_HASHASH(c,  1);
 1078|      0|	}
 1079|  18.4k|	hashcode = HASHVALUE(c) % HASHSIZE(HASHTAB(rho));
  ------------------
  |  |  205|  18.4k|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
 1080|       |	/* Will return 'R_NilValue' if not found */
 1081|  18.4k|	return R_HashGetLoc(hashcode, symbol, HASHTAB(rho));
 1082|  18.4k|    }
 1083|  17.3M|}
envir.c:getActiveValue:
  165|     12|{
  166|     12|    SEXP expr = LCONS(fun, R_NilValue);
  ------------------
  |  |  310|     12|#define LCONS(a, b)	Rf_lcons((a), (b))		/* language lists */
  ------------------
  167|     12|    PROTECT(expr);
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
  168|     12|    expr = eval(expr, R_GlobalEnv);
  ------------------
  |  |  913|     12|#define eval			Rf_eval
  ------------------
  169|     12|    UNPROTECT(1);
  ------------------
  |  |  358|     12|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  170|       |    /* mark unmutable to prevent mutations in complex assignments */
  171|     12|    MARK_NOT_MUTABLE(expr);
  172|     12|    return expr;
  173|     12|}
envir.c:BINDING_VALUE:
  114|  5.89M|{
  115|  5.89M|    if (BNDCELL_TAG(b)) {
  ------------------
  |  Branch (115:9): [True: 13, False: 5.89M]
  ------------------
  116|     13|	R_expand_binding_value(b);
  117|     13|	return CAR0(b);
  118|     13|    }
  119|  5.89M|    if (IS_ACTIVE_BINDING(b)) return getActiveValue(CAR(b));
  ------------------
  |  Branch (119:9): [True: 0, False: 5.89M]
  ------------------
  120|  5.89M|    else return CAR(b);
  121|  5.89M|}
envir.c:setActiveValue:
  155|      6|{
  156|      6|    SEXP qfun = lang3(R_DoubleColonSymbol, R_BaseSymbol, R_QuoteSymbol);
  ------------------
  |  |  980|      6|#define lang3			Rf_lang3
  ------------------
  157|      6|    SEXP arg = lang2(qfun, val);
  ------------------
  |  |  979|      6|#define lang2			Rf_lang2
  ------------------
  158|      6|    SEXP expr = lang2(fun, arg);
  ------------------
  |  |  979|      6|#define lang2			Rf_lang2
  ------------------
  159|      6|    PROTECT(expr);
  ------------------
  |  |  357|      6|#define PROTECT(s)	Rf_protect(s)
  ------------------
  160|      6|    eval(expr, R_BaseEnv);
  ------------------
  |  |  913|      6|#define eval			Rf_eval
  ------------------
  161|      6|    UNPROTECT(1);
  ------------------
  |  |  358|      6|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  162|      6|}
envir.c:R_HashGet:
  291|  3.53M|{
  292|  3.53M|    SEXP chain;
  293|       |
  294|       |    /* Grab the chain from the hashtable */
  295|  3.53M|    chain = HASHCHAIN(table, hashcode);
  ------------------
  |  |  210|  3.53M|#define HASHCHAIN(table, i)  ((SEXP *) STDVEC_DATAPTR(table))[i]
  ------------------
  296|       |    /* Retrieve the value from the chain */
  297|  5.11M|    for (; chain != R_NilValue ; chain = CDR(chain))
  ------------------
  |  Branch (297:12): [True: 1.99M, False: 3.12M]
  ------------------
  298|  1.99M|	if (TAG(chain) == symbol) return BINDING_VALUE(chain);
  ------------------
  |  Branch (298:6): [True: 415k, False: 1.57M]
  ------------------
  299|       |    /* If not found */
  300|  3.12M|    return R_UnboundValue;
  301|  3.53M|}
envir.c:R_HashExists:
  304|  2.32k|{
  305|  2.32k|    SEXP chain;
  306|       |
  307|       |    /* Grab the chain from the hashtable */
  308|  2.32k|    chain = VECTOR_ELT(table, hashcode);
  309|       |    /* Find the binding in the chain */
  310|  4.02k|    for (; chain != R_NilValue ; chain = CDR(chain))
  ------------------
  |  Branch (310:12): [True: 2.50k, False: 1.51k]
  ------------------
  311|  2.50k|	if (TAG(chain) == symbol) return TRUE;
  ------------------
  |  Branch (311:6): [True: 816, False: 1.69k]
  ------------------
  312|       |    /* If not found */
  313|  1.51k|    return FALSE;
  314|  2.32k|}
envir.c:findGlobalVar:
 1361|      6|{
 1362|      6|    SEXP loc = findGlobalVarLoc(symbol);
 1363|      6|    switch (TYPEOF(loc)) {
 1364|      0|    case NILSXP: return R_UnboundValue;
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1364:5): [True: 0, False: 6]
  ------------------
 1365|      6|    case SYMSXP: return SYMBOL_BINDING_VALUE(symbol);
  ------------------
  |  |  112|      6|#define SYMSXP	     1	  /* symbols */
  ------------------
                  case SYMSXP: return SYMBOL_BINDING_VALUE(symbol);
  ------------------
  |  |  123|      6|#define SYMBOL_BINDING_VALUE(s) ((IS_ACTIVE_BINDING(s) ? getActiveValue(SYMVALUE(s)) : SYMVALUE(s)))
  |  |  ------------------
  |  |  |  Branch (123:35): [True: 0, False: 6]
  |  |  ------------------
  ------------------
  |  Branch (1365:5): [True: 6, False: 0]
  ------------------
 1366|      0|    default: return BINDING_VALUE(loc);
  ------------------
  |  Branch (1366:5): [True: 0, False: 6]
  ------------------
 1367|       |                    /* loc is protected by callee when needed */
 1368|      6|    }
 1369|      6|}
envir.c:findGlobalVarLoc:
 1336|      6|{
 1337|      6|    SEXP vl, rho;
 1338|      6|    Rboolean canCache = TRUE;
 1339|      6|    vl = R_GetGlobalCacheLoc(symbol);
 1340|      6|    if (vl != R_UnboundValue)
  ------------------
  |  Branch (1340:9): [True: 0, False: 6]
  ------------------
 1341|      0|	return vl;
 1342|     32|    for (rho = R_GlobalEnv; rho != R_EmptyEnv; rho = ENCLOS(rho)) {
  ------------------
  |  Branch (1342:29): [True: 32, False: 0]
  ------------------
 1343|     32|	if (rho != R_BaseEnv) { /* we won't have R_BaseNamespace */
  ------------------
  |  Branch (1343:6): [True: 26, False: 6]
  ------------------
 1344|     26|	    vl = findVarLocInFrame(rho, symbol, &canCache);
 1345|     26|	    if (vl != R_NilValue) {
  ------------------
  |  Branch (1345:10): [True: 0, False: 26]
  ------------------
 1346|      0|		if(canCache)
  ------------------
  |  Branch (1346:6): [True: 0, False: 0]
  ------------------
 1347|      0|		    R_AddGlobalCache(symbol, vl);
 1348|      0|		return vl;
 1349|      0|	    }
 1350|     26|	}
 1351|      6|	else {
 1352|      6|	    if (SYMVALUE(symbol) != R_UnboundValue)
  ------------------
  |  Branch (1352:10): [True: 4, False: 2]
  ------------------
 1353|      4|		R_AddGlobalCache(symbol, symbol);
 1354|      6|	    return symbol;
 1355|      6|	}
 1356|     32|    }
 1357|      0|    return R_NilValue;
 1358|      6|}
envir.c:R_GetGlobalCacheLoc:
  768|      6|{
  769|      6|#ifdef FAST_BASE_CACHE_LOOKUP
  770|      6|    if (BASE_SYM_CACHED(symbol))
  ------------------
  |  Branch (770:9): [True: 0, False: 6]
  ------------------
  771|      0|	return symbol;
  772|      6|#endif
  773|       |
  774|      6|    return R_HashGet(hashIndex(symbol, R_GlobalCache), symbol, R_GlobalCache);
  775|      6|}
envir.c:R_AddGlobalCache:
  750|      4|{
  751|      4|    int oldpri = HASHPRI(R_GlobalCache);
  ------------------
  |  |  206|      4|#define HASHPRI(x)	     ((int) STDVEC_TRUELENGTH(x))
  ------------------
  752|      4|    R_HashSet(hashIndex(symbol, R_GlobalCache), symbol, R_GlobalCache, place,
  753|      4|	      FALSE);
  754|      4|#ifdef FAST_BASE_CACHE_LOOKUP
  755|      4|    if (symbol == place)
  ------------------
  |  Branch (755:9): [True: 4, False: 0]
  ------------------
  756|      4|	SET_BASE_SYM_CACHED(symbol);
  757|      0|    else
  758|      0|	UNSET_BASE_SYM_CACHED(symbol);
  759|      4|#endif
  760|      4|    if (oldpri != HASHPRI(R_GlobalCache) &&
  ------------------
  |  |  206|      8|#define HASHPRI(x)	     ((int) STDVEC_TRUELENGTH(x))
  ------------------
  |  Branch (760:9): [True: 4, False: 0]
  ------------------
  761|      4|	HASHPRI(R_GlobalCache) > 0.85 * HASHSIZE(R_GlobalCache)) {
  ------------------
  |  |  206|      4|#define HASHPRI(x)	     ((int) STDVEC_TRUELENGTH(x))
  ------------------
              	HASHPRI(R_GlobalCache) > 0.85 * HASHSIZE(R_GlobalCache)) {
  ------------------
  |  |  205|      4|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
  |  Branch (761:2): [True: 0, False: 4]
  ------------------
  762|      0|	R_GlobalCache = R_HashResize(R_GlobalCache);
  763|      0|	SETCAR(R_GlobalCachePreserve, R_GlobalCache);
  764|      0|    }
  765|      4|}
envir.c:findVarLoc:
 1411|  44.7k|{
 1412|  44.7k|    SEXP vl;
 1413|       |
 1414|  44.7k|    if (TYPEOF(rho) == NILSXP)
  ------------------
  |  |  111|  44.7k|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1414:9): [True: 0, False: 44.7k]
  ------------------
 1415|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1416|       |
 1417|  44.7k|    if (!isEnvironment(rho))
  ------------------
  |  |  944|  44.7k|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (1417:9): [True: 0, False: 44.7k]
  ------------------
 1418|      0|	error(_("argument to '%s' is not an environment"), "findVarLoc");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("argument to '%s' is not an environment"), "findVarLoc");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1419|       |
 1420|  44.7k|#ifdef USE_GLOBAL_CACHE
 1421|       |    /* This first loop handles local frames, if there are any.  It
 1422|       |       will also handle all frames if rho is a global frame other than
 1423|       |       R_GlobalEnv */
 1424|   100k|    while (rho != R_GlobalEnv && rho != R_EmptyEnv) {
  ------------------
  |  Branch (1424:12): [True: 100k, False: 0]
  |  Branch (1424:34): [True: 100k, False: 0]
  ------------------
 1425|   100k|	vl = findVarLocInFrame(rho, symbol, NULL);
 1426|   100k|	if (vl != R_NilValue) return vl;
  ------------------
  |  Branch (1426:6): [True: 44.7k, False: 55.5k]
  ------------------
 1427|  55.5k|	rho = ENCLOS(rho);
 1428|  55.5k|    }
 1429|      0|    if (rho == R_GlobalEnv)
  ------------------
  |  Branch (1429:9): [True: 0, False: 0]
  ------------------
 1430|      0|	return findGlobalVarLoc(symbol);
 1431|      0|    else
 1432|      0|	return R_NilValue;
 1433|       |#else
 1434|       |    while (rho != R_EmptyEnv) {
 1435|       |	vl = R_findVarInLocFrame(rho, symbol, NULL);
 1436|       |	if (vl != R_NilValue) return vl;
 1437|       |	rho = ENCLOS(rho);
 1438|       |    }
 1439|       |    return R_NilValue;
 1440|       |#endif
 1441|      0|}
envir.c:ddfindInFrame:
 1614|    952|{
 1615|    952|    if(i <= 0)
  ------------------
  |  Branch (1615:8): [True: 0, False: 952]
  ------------------
 1616|      0|	error(_("indexing '...' with non-positive index %d"), i);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("indexing '...' with non-positive index %d"), i);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1617|    952|    SEXP vl = R_findVarInFrame(rho, R_DotsSymbol);
 1618|    952|    if (vl != R_UnboundValue) {
  ------------------
  |  Branch (1618:9): [True: 952, False: 0]
  ------------------
 1619|    952|	if (TYPEOF(vl) != DOTSXP && vl != R_MissingArg)
  ------------------
  |  |  127|  1.90k|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (1619:6): [True: 0, False: 952]
  |  Branch (1619:30): [True: 0, False: 0]
  ------------------
 1620|      0|	    error(_("bad ... value"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("bad ... value"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1621|    952|	if (length_DOTS(vl) >= i) {
  ------------------
  |  | 1578|    952|#define length_DOTS(_v_) (TYPEOF(_v_) == DOTSXP ? length(_v_) : 0)
  |  |  ------------------
  |  |  |  |  127|    952|#define DOTSXP	    17	  /* dot-dot-dot object */
  |  |  ------------------
  |  |               #define length_DOTS(_v_) (TYPEOF(_v_) == DOTSXP ? length(_v_) : 0)
  |  |  ------------------
  |  |  |  |  987|    952|#define length(x)		Rf_length(x)
  |  |  ------------------
  |  |  |  Branch (1578:27): [True: 952, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1621:6): [True: 952, False: 0]
  ------------------
 1622|    952|	    vl = nthcdr(vl, i - 1);
  ------------------
  |  | 1009|    952|#define nthcdr			Rf_nthcdr
  ------------------
 1623|    952|	    return(CAR(vl));
 1624|    952|	}
 1625|      0|	else // length(...) < i
 1626|      0|	    error(ngettext("the ... list contains fewer than %d element",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 1627|      0|			   "the ... list contains fewer than %d elements", i),
 1628|      0|                  i);
 1629|    952|    }
 1630|      0|    else error(_("..%d used in an incorrect context, no ... to look in"), i);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  else error(_("..%d used in an incorrect context, no ... to look in"), i);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1631|       |
 1632|      0|    return R_NilValue;
 1633|    952|}
envir.c:R_HashSet:
  255|  20.2k|{
  256|  20.2k|    SEXP chain;
  257|       |
  258|       |    /* Grab the chain from the hashtable */
  259|  20.2k|    chain = VECTOR_ELT(table, hashcode);
  260|       |
  261|       |    /* Search for the value in the chain */
  262|  40.5k|    for (; !ISNULL(chain); chain = CDR(chain))
  ------------------
  |  |  176|  40.5k|#define ISNULL(x) ((x) == R_NilValue)
  ------------------
  |  Branch (262:12): [True: 20.3k, False: 20.2k]
  ------------------
  263|  20.3k|	if (TAG(chain) == symbol) {
  ------------------
  |  Branch (263:6): [True: 71, False: 20.2k]
  ------------------
  264|     71|	    SET_BINDING_VALUE(chain, value);
  ------------------
  |  |  126|     71|#define SET_BINDING_VALUE(b,val) do { \
  |  |  127|     71|  SEXP __b__ = (b); \
  |  |  128|     71|  SEXP __val__ = (val); \
  |  |  129|     71|  if (BINDING_IS_LOCKED(__b__)) \
  |  |  ------------------
  |  |  |  Branch (129:7): [True: 0, False: 71]
  |  |  ------------------
  |  |  130|     71|    error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |                   error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  131|      0|	  CHAR(PRINTNAME(TAG(__b__)))); \
  |  |  ------------------
  |  |  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  |  |  132|     71|  if (IS_ACTIVE_BINDING(__b__)) { \
  |  |  ------------------
  |  |  |  Branch (132:7): [True: 0, False: 71]
  |  |  ------------------
  |  |  133|      0|    PROTECT(__val__); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  134|      0|    setActiveValue(CAR(__b__), __val__); \
  |  |  135|      0|    UNPROTECT(1); \
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |  136|      0|   } else \
  |  |  137|     71|    SET_BNDCELL(__b__, __val__); \
  |  |  138|     71|} while (0)
  |  |  ------------------
  |  |  |  Branch (138:10): [Folded, False: 71]
  |  |  ------------------
  ------------------
  265|     71|	    SET_MISSING(chain, 0);	/* Over-ride for new value */
  266|     71|	    return;
  267|     71|	}
  268|  20.2k|    if (frame_locked)
  ------------------
  |  Branch (268:9): [True: 0, False: 20.2k]
  ------------------
  269|      0|	error(_("cannot add bindings to a locked environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot add bindings to a locked environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  270|  20.2k|    if (ISNULL(chain))
  ------------------
  |  |  176|  20.2k|#define ISNULL(x) ((x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (176:19): [True: 20.2k, False: 0]
  |  |  ------------------
  ------------------
  271|  20.2k|	SET_HASHPRI(table, HASHPRI(table) + 1);
  ------------------
  |  |  209|  20.2k|#define SET_HASHPRI(x,v)     SET_TRUELENGTH(x,v)
  ------------------
  272|       |    /* Add the value into the chain */
  273|  20.2k|    SET_VECTOR_ELT(table, hashcode, CONS(value, VECTOR_ELT(table, hashcode)));
  ------------------
  |  |  309|  20.2k|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  274|  20.2k|    SET_TAG(VECTOR_ELT(table, hashcode), symbol);
  275|  20.2k|    return;
  276|  20.2k|}
envir.c:R_HashSizeCheck:
  482|  56.0k|{
  483|  56.0k|    int resize;
  484|  56.0k|    double thresh_val;
  485|       |
  486|       |    /* Do some checking */
  487|  56.0k|    if (TYPEOF(table) != VECSXP)
  ------------------
  |  |  131|  56.0k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (487:9): [True: 0, False: 56.0k]
  ------------------
  488|      0|	error("first argument ('table') not of type VECSXP, R_HashSizeCheck");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  489|  56.0k|    resize = 0; thresh_val = 0.85;
  490|  56.0k|    if ((double)HASHPRI(table) > (double)HASHSIZE(table) * thresh_val)
  ------------------
  |  |  206|  56.0k|#define HASHPRI(x)	     ((int) STDVEC_TRUELENGTH(x))
  ------------------
                  if ((double)HASHPRI(table) > (double)HASHSIZE(table) * thresh_val)
  ------------------
  |  |  205|  56.0k|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
  |  Branch (490:9): [True: 601, False: 55.4k]
  ------------------
  491|    601|	resize = 1;
  492|  56.0k|    return resize;
  493|  56.0k|}
envir.c:R_HashResize:
  428|    601|{
  429|       |    /* Do some checking */
  430|    601|    if (TYPEOF(table) != VECSXP)
  ------------------
  |  |  131|    601|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (430:9): [True: 0, False: 601]
  ------------------
  431|      0|	error("first argument ('table') not of type VECSXP, from R_HashResize");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  432|       |
  433|       |    /* This may have to change.	 The growth rate should
  434|       |       be independent of the size (not implemented yet) */
  435|       |    /* hash_grow = HASHSIZE(table); */
  436|       |
  437|       |    /* Allocate the new hash table */
  438|    601|    SEXP new_table = R_NewHashTable(1 + (int)(HASHSIZE(table) * HASHTABLEGROWTHRATE));
  ------------------
  |  |  205|    601|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
                  SEXP new_table = R_NewHashTable(1 + (int)(HASHSIZE(table) * HASHTABLEGROWTHRATE));
  ------------------
  |  |  207|    601|#define HASHTABLEGROWTHRATE  1.2
  ------------------
  439|  68.7k|    for (int counter = 0; counter < length(table); counter++) {
  ------------------
  |  |  987|  68.7k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (439:27): [True: 68.1k, False: 601]
  ------------------
  440|  68.1k|	SEXP chain = VECTOR_ELT(table, counter);
  441|   150k|	while (!ISNULL(chain)) {
  ------------------
  |  |  176|   150k|#define ISNULL(x) ((x) == R_NilValue)
  ------------------
  |  Branch (441:9): [True: 82.8k, False: 68.1k]
  ------------------
  442|  82.8k|	    int new_hashcode = R_Newhashpjw(CHAR(PRINTNAME(TAG(chain)))) %
  ------------------
  |  |  203|  82.8k|#define CHAR(x) R_CHAR(x)
  ------------------
  443|  82.8k|		HASHSIZE(new_table);
  ------------------
  |  |  205|  82.8k|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
  444|  82.8k|	    SEXP new_chain = VECTOR_ELT(new_table, new_hashcode);
  445|       |	    /* If using a primary slot then increase HASHPRI */
  446|  82.8k|	    if (ISNULL(new_chain))
  ------------------
  |  |  176|  82.8k|#define ISNULL(x) ((x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (176:19): [True: 51.9k, False: 30.8k]
  |  |  ------------------
  ------------------
  447|  51.9k|		SET_HASHPRI(new_table, HASHPRI(new_table) + 1);
  ------------------
  |  |  209|  51.9k|#define SET_HASHPRI(x,v)     SET_TRUELENGTH(x,v)
  ------------------
  448|  82.8k|	    SEXP tmp_chain = chain;
  449|  82.8k|	    chain = CDR(chain);
  450|  82.8k|	    SETCDR(tmp_chain, new_chain);
  451|  82.8k|	    SET_VECTOR_ELT(new_table, new_hashcode,  tmp_chain);
  452|       |#ifdef MIKE_DEBUG
  453|       |	    fprintf(stdout, "HASHSIZE = %d\nHASHPRI = %d\ncounter = %d\nHASHCODE = %d\n",
  454|       |		    HASHSIZE(table), HASHPRI(table), counter, new_hashcode);
  455|       |#endif
  456|  82.8k|	}
  457|  68.1k|    }
  458|       |    /* Some debugging statements */
  459|       |#ifdef MIKE_DEBUG
  460|       |    fprintf(stdout, "Resized O.K.\n");
  461|       |    fprintf(stdout, "Old size: %d, New size: %d\n",
  462|       |	    HASHSIZE(table), HASHSIZE(new_table));
  463|       |    fprintf(stdout, "Old pri: %d, New pri: %d\n",
  464|       |	    HASHPRI(table), HASHPRI(new_table));
  465|       |#endif
  466|    601|    return new_table;
  467|    601|} /* end R_HashResize */
envir.c:setVarInFrame:
 2080|  3.67k|{
 2081|  3.67k|    int hashcode;
 2082|  3.67k|    SEXP frame, c;
 2083|       |
 2084|       |    /* R_DirtyImage should only be set if assigning to R_GlobalEnv. */
 2085|  3.67k|    if (rho == R_GlobalEnv) R_DirtyImage = 1;
  ------------------
  |  Branch (2085:9): [True: 0, False: 3.67k]
  ------------------
 2086|  3.67k|    if (rho == R_EmptyEnv) return R_NilValue;
  ------------------
  |  Branch (2086:9): [True: 0, False: 3.67k]
  ------------------
 2087|       |
 2088|  3.67k|    if(IS_USER_DATABASE(rho)) {
  ------------------
  |  |  102|  3.67k|#define IS_USER_DATABASE(rho)  (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  ------------------
  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  ------------------
  |  |  |  Branch (102:33): [True: 0, False: 3.67k]
  |  |  |  Branch (102:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2089|       |	/* FIXME: This does not behave as described */
 2090|      0|	R_ObjectTable *table;
 2091|      0|	table = (R_ObjectTable *) R_ExternalPtrAddr(HASHTAB(rho));
 2092|      0|	if(table->assign == NULL)
  ------------------
  |  Branch (2092:5): [True: 0, False: 0]
  ------------------
 2093|      0|	    error(_("cannot assign variables to this database"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("cannot assign variables to this database"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2094|      0|	PROTECT(value);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2095|      0|	SEXP result = table->assign(CHAR(PRINTNAME(symbol)), value, table);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 2096|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2097|      0|	return(result);
 2098|      0|    }
 2099|       |
 2100|  3.67k|    if (rho == R_BaseNamespace || rho == R_BaseEnv) {
  ------------------
  |  Branch (2100:9): [True: 0, False: 3.67k]
  |  Branch (2100:35): [True: 0, False: 3.67k]
  ------------------
 2101|      0|	if (SYMVALUE(symbol) == R_UnboundValue) return R_NilValue;
  ------------------
  |  Branch (2101:6): [True: 0, False: 0]
  ------------------
 2102|      0|	SET_SYMBOL_BINDING_VALUE(symbol, value);
  ------------------
  |  |  140|      0|#define SET_SYMBOL_BINDING_VALUE(sym, val) do { \
  |  |  141|      0|  SEXP __sym__ = (sym); \
  |  |  142|      0|  SEXP __val__ = (val); \
  |  |  143|      0|  if (BINDING_IS_LOCKED(__sym__)) \
  |  |  ------------------
  |  |  |  Branch (143:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|    error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |                   error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|	  CHAR(PRINTNAME(__sym__))); \
  |  |  ------------------
  |  |  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  |  |  146|      0|  if (IS_ACTIVE_BINDING(__sym__)) { \
  |  |  ------------------
  |  |  |  Branch (146:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  147|      0|    PROTECT(__val__); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  148|      0|    setActiveValue(SYMVALUE(__sym__), __val__); \
  |  |  149|      0|    UNPROTECT(1); \
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |  150|      0|  } else \
  |  |  151|      0|    SET_SYMVALUE(__sym__, __val__); \
  |  |  152|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (152:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2103|      0|	return symbol;
 2104|      0|    }
 2105|       |
 2106|  3.67k|    if (HASHTAB(rho) == R_NilValue) {
  ------------------
  |  Branch (2106:9): [True: 3.65k, False: 18]
  ------------------
 2107|  3.65k|	frame = FRAME(rho);
 2108|  18.7k|	while (frame != R_NilValue) {
  ------------------
  |  Branch (2108:9): [True: 17.3k, False: 1.41k]
  ------------------
 2109|  17.3k|	    if (TAG(frame) == symbol) {
  ------------------
  |  Branch (2109:10): [True: 2.24k, False: 15.0k]
  ------------------
 2110|  2.24k|		SET_BINDING_VALUE(frame, value);
  ------------------
  |  |  126|  2.24k|#define SET_BINDING_VALUE(b,val) do { \
  |  |  127|  2.24k|  SEXP __b__ = (b); \
  |  |  128|  2.24k|  SEXP __val__ = (val); \
  |  |  129|  2.24k|  if (BINDING_IS_LOCKED(__b__)) \
  |  |  ------------------
  |  |  |  Branch (129:7): [True: 0, False: 2.24k]
  |  |  ------------------
  |  |  130|  2.24k|    error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |                   error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  131|      0|	  CHAR(PRINTNAME(TAG(__b__)))); \
  |  |  ------------------
  |  |  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  |  |  132|  2.24k|  if (IS_ACTIVE_BINDING(__b__)) { \
  |  |  ------------------
  |  |  |  Branch (132:7): [True: 0, False: 2.24k]
  |  |  ------------------
  |  |  133|      0|    PROTECT(__val__); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  134|      0|    setActiveValue(CAR(__b__), __val__); \
  |  |  135|      0|    UNPROTECT(1); \
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |  136|      0|   } else \
  |  |  137|  2.24k|    SET_BNDCELL(__b__, __val__); \
  |  |  138|  2.24k|} while (0)
  |  |  ------------------
  |  |  |  Branch (138:10): [Folded, False: 2.24k]
  |  |  ------------------
  ------------------
 2111|  2.24k|		SET_MISSING(frame, 0);	/* same as defineVar */
 2112|  2.24k|		return symbol;
 2113|  2.24k|	    }
 2114|  15.0k|	    frame = CDR(frame);
 2115|  15.0k|	}
 2116|  3.65k|    } else {
 2117|       |	/* Do the hash table thing */
 2118|     18|	c = PRINTNAME(symbol);
 2119|     18|	if( !HASHASH(c) ) {
  ------------------
  |  Branch (2119:6): [True: 0, False: 18]
  ------------------
 2120|      0|	    SET_HASHVALUE(c, R_Newhashpjw(CHAR(c)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 2121|      0|	    SET_HASHASH(c, 1);
 2122|      0|	}
 2123|     18|	hashcode = HASHVALUE(c) % HASHSIZE(HASHTAB(rho));
  ------------------
  |  |  205|     18|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
 2124|     18|	frame = R_HashGetLoc(hashcode, symbol, HASHTAB(rho));
 2125|     18|	if (frame != R_NilValue) {
  ------------------
  |  Branch (2125:6): [True: 18, False: 0]
  ------------------
 2126|     18|	    SET_BINDING_VALUE(frame, value);
  ------------------
  |  |  126|     18|#define SET_BINDING_VALUE(b,val) do { \
  |  |  127|     18|  SEXP __b__ = (b); \
  |  |  128|     18|  SEXP __val__ = (val); \
  |  |  129|     18|  if (BINDING_IS_LOCKED(__b__)) \
  |  |  ------------------
  |  |  |  Branch (129:7): [True: 0, False: 18]
  |  |  ------------------
  |  |  130|     18|    error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |                   error(_("cannot change value of locked binding for '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  131|      0|	  CHAR(PRINTNAME(TAG(__b__)))); \
  |  |  ------------------
  |  |  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  |  |  132|     18|  if (IS_ACTIVE_BINDING(__b__)) { \
  |  |  ------------------
  |  |  |  Branch (132:7): [True: 0, False: 18]
  |  |  ------------------
  |  |  133|      0|    PROTECT(__val__); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  134|      0|    setActiveValue(CAR(__b__), __val__); \
  |  |  135|      0|    UNPROTECT(1); \
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |  136|      0|   } else \
  |  |  137|     18|    SET_BNDCELL(__b__, __val__); \
  |  |  138|     18|} while (0)
  |  |  ------------------
  |  |  |  Branch (138:10): [Folded, False: 18]
  |  |  ------------------
  ------------------
 2127|     18|	    SET_MISSING(frame, 0);	/* same as defineVar */
 2128|     18|	    return symbol;
 2129|     18|	}
 2130|     18|    }
 2131|  1.41k|    return R_NilValue; /* -Wall */
 2132|  3.67k|}
envir.c:RemoveVariable:
 2272|      2|{
 2273|      2|    int found;
 2274|      2|    SEXP list;
 2275|       |
 2276|      2|    if (env == R_BaseNamespace)
  ------------------
  |  Branch (2276:9): [True: 0, False: 2]
  ------------------
 2277|      0|	error(_("cannot remove variables from base namespace"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot remove variables from base namespace"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2278|      2|    if (env == R_BaseEnv)
  ------------------
  |  Branch (2278:9): [True: 0, False: 2]
  ------------------
 2279|      0|	error(_("cannot remove variables from the base environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot remove variables from the base environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2280|      2|    if (env == R_EmptyEnv)
  ------------------
  |  Branch (2280:9): [True: 0, False: 2]
  ------------------
 2281|      0|	error(_("cannot remove variables from the empty environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot remove variables from the empty environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2282|      2|    if (FRAME_IS_LOCKED(env))
  ------------------
  |  |  107|      2|#define FRAME_IS_LOCKED(e) (ENVFLAGS(e) & FRAME_LOCK_MASK)
  |  |  ------------------
  |  |  |  |  106|      2|#define FRAME_LOCK_MASK (1<<14)
  |  |  ------------------
  |  |  |  Branch (107:28): [True: 0, False: 2]
  |  |  ------------------
  ------------------
 2283|      0|	error(_("cannot remove bindings from a locked environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot remove bindings from a locked environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2284|       |
 2285|      2|    if(IS_USER_DATABASE(env)) {
  ------------------
  |  |  102|      2|#define IS_USER_DATABASE(rho)  (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  ------------------
  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  ------------------
  |  |  |  Branch (102:33): [True: 0, False: 2]
  |  |  |  Branch (102:50): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2286|      0|	R_ObjectTable *table;
 2287|      0|	table = (R_ObjectTable *) R_ExternalPtrAddr(HASHTAB(env));
 2288|      0|	if(table->remove == NULL)
  ------------------
  |  Branch (2288:5): [True: 0, False: 0]
  ------------------
 2289|      0|	    error(_("cannot remove variables from this database"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("cannot remove variables from this database"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2290|      0|	return(table->remove(CHAR(PRINTNAME(name)), table));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 2291|      0|    }
 2292|       |
 2293|      2|    if (IS_HASHED(env)) {
  ------------------
  |  |  212|      2|#define IS_HASHED(x)	     (HASHTAB(x) != R_NilValue)
  |  |  ------------------
  |  |  |  Branch (212:27): [True: 2, False: 0]
  |  |  ------------------
  ------------------
 2294|      2|	R_HashDelete(hashcode, name, env, &found);
 2295|      2|#ifdef USE_GLOBAL_CACHE
 2296|      2|	if (found && IS_GLOBAL_FRAME(env))
  ------------------
  |  |  653|      2|#define IS_GLOBAL_FRAME(e) (ENVFLAGS(e) & GLOBAL_FRAME_MASK)
  |  |  ------------------
  |  |  |  |  652|      2|#define GLOBAL_FRAME_MASK (1<<15)
  |  |  ------------------
  |  |  |  Branch (653:28): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (2296:6): [True: 2, False: 0]
  ------------------
 2297|      2|	    R_FlushGlobalCache(name);
 2298|      2|#endif
 2299|      2|    } else {
 2300|      0|	list = RemoveFromList(name, FRAME(env), &found);
 2301|      0|	if (found) {
  ------------------
  |  Branch (2301:6): [True: 0, False: 0]
  ------------------
 2302|      0|	    if(env == R_GlobalEnv) R_DirtyImage = 1;
  ------------------
  |  Branch (2302:9): [True: 0, False: 0]
  ------------------
 2303|      0|	    SET_FRAME(env, list);
 2304|      0|#ifdef USE_GLOBAL_CACHE
 2305|      0|	    if (IS_GLOBAL_FRAME(env))
  ------------------
  |  |  653|      0|#define IS_GLOBAL_FRAME(e) (ENVFLAGS(e) & GLOBAL_FRAME_MASK)
  |  |  ------------------
  |  |  |  |  652|      0|#define GLOBAL_FRAME_MASK (1<<15)
  |  |  ------------------
  |  |  |  Branch (653:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2306|      0|		R_FlushGlobalCache(name);
 2307|      0|#endif
 2308|      0|	}
 2309|      0|    }
 2310|      2|    return found;
 2311|      2|}
envir.c:str2mode:
 2394|  6.89k|{
 2395|  6.89k|    if (!strcmp(modestr, "function"))
  ------------------
  |  Branch (2395:9): [True: 46, False: 6.84k]
  ------------------
 2396|     46|	return FUNSXP;
  ------------------
  |  |  144|     46|#define FUNSXP      99    /* Closure or Builtin or Special */
  ------------------
 2397|  6.84k|    else if (!strcmp(modestr, "S4")) {
  ------------------
  |  Branch (2397:14): [True: 0, False: 6.84k]
  ------------------
 2398|      0|	if (pS4 != NULL)
  ------------------
  |  Branch (2398:6): [True: 0, False: 0]
  ------------------
 2399|      0|	    *pS4 = TRUE;
 2400|      0|	return OBJSXP;
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
 2401|      0|    }
 2402|  6.84k|    else {
 2403|  6.84k|	SEXPTYPE gmode = str2type(modestr);
  ------------------
  |  | 1031|  6.84k|#define str2type		Rf_str2type
  ------------------
 2404|  6.84k|	if(gmode == (SEXPTYPE) (-1))
  ------------------
  |  Branch (2404:5): [True: 0, False: 6.84k]
  ------------------
 2405|      0|	    error(_("invalid '%s' argument '%s'"), "mode", modestr);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' argument '%s'"), "mode", modestr);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2406|  6.84k|	return gmode;
 2407|  6.84k|    }
 2408|  6.89k|}
envir.c:findVar1mode:
 1495|  6.89k|{
 1496|  6.89k|    SEXP vl;
 1497|  6.89k|    int tl;
 1498|  6.89k|    if (mode == INTSXP) mode = REALSXP;
  ------------------
  |  |  123|  6.89k|#define INTSXP	    13	  /* integer vectors */
  ------------------
                  if (mode == INTSXP) mode = REALSXP;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1498:9): [True: 0, False: 6.89k]
  ------------------
 1499|  6.89k|    if (mode == FUNSXP || mode ==  BUILTINSXP || mode == SPECIALSXP)
  ------------------
  |  |  144|  13.7k|#define FUNSXP      99    /* Closure or Builtin or Special */
  ------------------
                  if (mode == FUNSXP || mode ==  BUILTINSXP || mode == SPECIALSXP)
  ------------------
  |  |  119|  13.7k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
                  if (mode == FUNSXP || mode ==  BUILTINSXP || mode == SPECIALSXP)
  ------------------
  |  |  118|  6.84k|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (1499:9): [True: 46, False: 6.84k]
  |  Branch (1499:27): [True: 0, False: 6.84k]
  |  Branch (1499:50): [True: 0, False: 6.84k]
  ------------------
 1500|     46|	mode = CLOSXP;
  ------------------
  |  |  114|     46|#define CLOSXP	     3	  /* closures */
  ------------------
 1501|  7.08k|    while (rho != R_EmptyEnv) {
  ------------------
  |  Branch (1501:12): [True: 7.08k, False: 0]
  ------------------
 1502|  7.08k|	if (! doGet && mode == ANYSXP)
  ------------------
  |  |  128|  2.33k|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
  |  Branch (1502:6): [True: 2.33k, False: 4.74k]
  |  Branch (1502:17): [True: 2.33k, False: 0]
  ------------------
 1503|  2.33k|	    vl = R_existsVarInFrame(rho, symbol) ? R_NilValue : R_UnboundValue;
  ------------------
  |  Branch (1503:11): [True: 904, False: 1.43k]
  ------------------
 1504|  4.74k|	else
 1505|  4.74k|	    vl = findVarInFrame3(rho, symbol, doGet);
  ------------------
  |  |  920|  4.74k|#define findVarInFrame3		Rf_findVarInFrame3
  ------------------
 1506|       |
 1507|  7.08k|	if (vl != R_UnboundValue) {
  ------------------
  |  Branch (1507:6): [True: 5.07k, False: 2.00k]
  ------------------
 1508|  5.07k|	    if (mode == ANYSXP) return vl;
  ------------------
  |  |  128|  5.07k|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
  |  Branch (1508:10): [True: 5.02k, False: 46]
  ------------------
 1509|     46|	    if (TYPEOF(vl) == PROMSXP) {
  ------------------
  |  |  116|     46|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (1509:10): [True: 4, False: 42]
  ------------------
 1510|      4|		PROTECT(vl);
  ------------------
  |  |  357|      4|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1511|      4|		vl = eval(vl, rho);
  ------------------
  |  |  913|      4|#define eval			Rf_eval
  ------------------
 1512|      4|		UNPROTECT(1);
  ------------------
  |  |  358|      4|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1513|      4|	    }
 1514|     46|	    tl = TYPEOF(vl);
 1515|     46|	    if (tl == INTSXP) tl = REALSXP;
  ------------------
  |  |  123|     46|#define INTSXP	    13	  /* integer vectors */
  ------------------
              	    if (tl == INTSXP) tl = REALSXP;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1515:10): [True: 0, False: 46]
  ------------------
 1516|     46|	    if (tl == FUNSXP || tl ==  BUILTINSXP || tl == SPECIALSXP)
  ------------------
  |  |  144|     92|#define FUNSXP      99    /* Closure or Builtin or Special */
  ------------------
              	    if (tl == FUNSXP || tl ==  BUILTINSXP || tl == SPECIALSXP)
  ------------------
  |  |  119|     92|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
              	    if (tl == FUNSXP || tl ==  BUILTINSXP || tl == SPECIALSXP)
  ------------------
  |  |  118|      4|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (1516:10): [True: 0, False: 46]
  |  Branch (1516:26): [True: 42, False: 4]
  |  Branch (1516:47): [True: 0, False: 4]
  ------------------
 1517|     42|		tl = CLOSXP;
  ------------------
  |  |  114|     42|#define CLOSXP	     3	  /* closures */
  ------------------
 1518|     46|	    if (tl == mode) {
  ------------------
  |  Branch (1518:10): [True: 46, False: 0]
  ------------------
 1519|     46|		if (tl == OBJSXP) {
  ------------------
  |  |  137|     46|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (1519:7): [True: 0, False: 46]
  ------------------
 1520|      0|		    if ((wants_S4 && IS_S4_OBJECT(vl)) ||
  ------------------
  |  Branch (1520:12): [True: 0, False: 0]
  |  Branch (1520:24): [True: 0, False: 0]
  ------------------
 1521|      0|			(! wants_S4 && ! IS_S4_OBJECT(vl)))
  ------------------
  |  Branch (1521:5): [True: 0, False: 0]
  |  Branch (1521:19): [True: 0, False: 0]
  ------------------
 1522|      0|			return vl;
 1523|      0|		}
 1524|     46|		else return vl;
 1525|     46|	    }
 1526|     46|	}
 1527|  2.00k|	if (inherits)
  ------------------
  |  |  933|  2.00k|#define inherits		Rf_inherits
  |  |  ------------------
  |  |  |  Branch (933:19): [True: 188, False: 1.81k]
  |  |  ------------------
  ------------------
 1528|    188|	    rho = ENCLOS(rho);
 1529|  1.81k|	else
 1530|  1.81k|	    return (R_UnboundValue);
 1531|  2.00k|    }
 1532|      0|    return (R_UnboundValue);
 1533|  6.89k|}
envir.c:gfind:
 2512|  3.06k|{
 2513|  3.06k|    SEXP rval, t1, R_fcall, var;
 2514|       |
 2515|  3.06k|    t1 = install(name);
  ------------------
  |  |  934|  3.06k|#define install			Rf_install
  ------------------
 2516|       |
 2517|       |    /* Search for the object - last arg is 1 to 'get' */
 2518|  3.06k|    rval = findVar1mode(t1, env, mode, wants_S4, inherits, 1);
  ------------------
  |  |  933|  3.06k|#define inherits		Rf_inherits
  ------------------
 2519|       |
 2520|  3.06k|    if (rval == R_UnboundValue) {
  ------------------
  |  Branch (2520:9): [True: 0, False: 3.06k]
  ------------------
 2521|      0|	if( isFunction(ifnotfound) ) {
  ------------------
  |  |  948|      0|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (2521:6): [True: 0, False: 0]
  ------------------
 2522|      0|	    PROTECT(var = mkString(name));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2523|      0|	    PROTECT(R_fcall = LCONS(ifnotfound, LCONS(var, R_NilValue)));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2524|      0|	    rval = eval(R_fcall, enclos);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 2525|      0|	    UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2526|      0|	} else
 2527|      0|	    rval = ifnotfound;
 2528|      0|    }
 2529|       |
 2530|       |    /* We need to evaluate if it is a promise */
 2531|  3.06k|    if (TYPEOF(rval) == PROMSXP) {
  ------------------
  |  |  116|  3.06k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2531:9): [True: 0, False: 3.06k]
  ------------------
 2532|      0|	PROTECT(rval);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2533|      0|	rval = eval(rval, env);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 2534|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2535|      0|    }
 2536|  3.06k|    ENSURE_NAMED(rval);
 2537|  3.06k|    return rval;
 2538|  3.06k|}
envir.c:findRootPromise:
 2656|  2.60k|static SEXP findRootPromise(SEXP p) {
 2657|  2.60k|    if (TYPEOF(p) == PROMSXP) {
  ------------------
  |  |  116|  2.60k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2657:9): [True: 1.34k, False: 1.26k]
  ------------------
 2658|  1.34k|	while(TYPEOF(PREXPR(p)) == PROMSXP) {
  ------------------
  |  |  720|  1.34k|#define PREXPR(e) R_PromiseExpr(e)
  ------------------
              	while(TYPEOF(PREXPR(p)) == PROMSXP) {
  ------------------
  |  |  116|  1.34k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2658:8): [True: 0, False: 1.34k]
  ------------------
 2659|      0|	    p = PREXPR(p);
  ------------------
  |  |  720|      0|#define PREXPR(e) R_PromiseExpr(e)
  ------------------
 2660|      0|	}
 2661|  1.34k|    }
 2662|  2.60k|    return p;
 2663|  2.60k|}
envir.c:R_HashFrame:
  509|     14|{
  510|     14|    int hashcode;
  511|     14|    SEXP frame, chain, tmp_chain, table;
  512|       |
  513|       |    /* Do some checking */
  514|     14|    if (TYPEOF(rho) != ENVSXP)
  ------------------
  |  |  115|     14|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (514:9): [True: 0, False: 14]
  ------------------
  515|      0|	error("first argument ('table') not of type ENVSXP, from R_HashVector2Hash");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  516|     14|    table = HASHTAB(rho);
  517|     14|    frame = FRAME(rho);
  518|     14|    while (!ISNULL(frame)) {
  ------------------
  |  |  176|     14|#define ISNULL(x) ((x) == R_NilValue)
  ------------------
  |  Branch (518:12): [True: 0, False: 14]
  ------------------
  519|      0|	if( !HASHASH(PRINTNAME(TAG(frame))) ) {
  ------------------
  |  Branch (519:6): [True: 0, False: 0]
  ------------------
  520|      0|	    SET_HASHVALUE(PRINTNAME(TAG(frame)),
  521|      0|			  R_Newhashpjw(CHAR(PRINTNAME(TAG(frame)))));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  522|      0|	    SET_HASHASH(PRINTNAME(TAG(frame)), 1);
  523|      0|	}
  524|      0|	hashcode = HASHVALUE(PRINTNAME(TAG(frame))) % HASHSIZE(table);
  ------------------
  |  |  205|      0|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
  525|      0|	chain = VECTOR_ELT(table, hashcode);
  526|       |	/* If using a primary slot then increase HASHPRI */
  527|      0|	if (ISNULL(chain)) SET_HASHPRI(table, HASHPRI(table) + 1);
  ------------------
  |  |  176|      0|#define ISNULL(x) ((x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (176:19): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	if (ISNULL(chain)) SET_HASHPRI(table, HASHPRI(table) + 1);
  ------------------
  |  |  209|      0|#define SET_HASHPRI(x,v)     SET_TRUELENGTH(x,v)
  ------------------
  528|      0|	tmp_chain = frame;
  529|      0|	frame = CDR(frame);
  530|      0|	SETCDR(tmp_chain, chain);
  531|      0|	SET_VECTOR_ELT(table, hashcode, tmp_chain);
  532|      0|    }
  533|     14|    SET_FRAME(rho, R_NilValue);
  534|     14|    return rho;
  535|     14|}
envir.c:R_FlushGlobalCacheFromTable:
  722|     14|{
  723|     14|    int i, size;
  724|     14|    SEXP chain;
  725|     14|    size = HASHSIZE(table);
  ------------------
  |  |  205|     14|#define HASHSIZE(x)	     ((int) STDVEC_LENGTH(x))
  ------------------
  726|    420|    for (i = 0; i < size; i++) {
  ------------------
  |  Branch (726:17): [True: 406, False: 14]
  ------------------
  727|    406|	for (chain = VECTOR_ELT(table, i); chain != R_NilValue; chain = CDR(chain))
  ------------------
  |  Branch (727:37): [True: 0, False: 406]
  ------------------
  728|      0|	    R_FlushGlobalCache(TAG(chain));
  729|    406|    }
  730|     14|}
envir.c:BuiltinSize:
 3171|     14|{
 3172|     14|    int count = 0;
 3173|     14|    SEXP s;
 3174|     14|    int j;
 3175|   688k|    for (j = 0; j < HSIZE; j++) {
  ------------------
  |  | 1174|   688k|#define HSIZE	  49157	/* The size of the hash table for symbols */
  ------------------
  |  Branch (3175:17): [True: 688k, False: 14]
  ------------------
 3176|   753k|	for (s = R_SymbolTable[j]; s != R_NilValue; s = CDR(s)) {
  ------------------
  |  Branch (3176:29): [True: 65.0k, False: 688k]
  ------------------
 3177|  65.0k|	    if (intern) {
  ------------------
  |  Branch (3177:10): [True: 0, False: 65.0k]
  ------------------
 3178|      0|		if (INTERNAL(CAR(s)) != R_NilValue)
  ------------------
  |  Branch (3178:7): [True: 0, False: 0]
  ------------------
 3179|      0|		    count++;
 3180|      0|	    }
 3181|  65.0k|	    else {
 3182|  65.0k|		if ((all || CHAR(PRINTNAME(CAR(s)))[0] != '.')
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (3182:8): [True: 65.0k, False: 0]
  |  Branch (3182:15): [True: 0, False: 0]
  ------------------
 3183|  65.0k|		    && SYMVALUE(CAR(s)) != R_UnboundValue)
  ------------------
  |  Branch (3183:10): [True: 19.8k, False: 45.2k]
  ------------------
 3184|  19.8k|		    count++;
 3185|  65.0k|	    }
 3186|  65.0k|	}
 3187|   688k|    }
 3188|     14|    return count;
 3189|     14|}
envir.c:HashTableSize:
 3142|    160|{
 3143|    160|    CHECK_HASH_TABLE(table);
  ------------------
  |  | 3136|    160|#define CHECK_HASH_TABLE(table) do {		\
  |  | 3137|    160|	if (TYPEOF(table) != VECSXP)		\
  |  |  ------------------
  |  |  |  |  131|    160|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (3137:6): [True: 0, False: 160]
  |  |  ------------------
  |  | 3138|    160|	    error("bad hash table contents");	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  | 3139|    160|    } while (0)
  |  |  ------------------
  |  |  |  Branch (3139:14): [Folded, False: 160]
  |  |  ------------------
  ------------------
 3144|    160|    int count = 0;
 3145|    160|    int n = length(table);
  ------------------
  |  |  987|    160|#define length(x)		Rf_length(x)
  ------------------
 3146|    160|    int i;
 3147|  30.6k|    for (i = 0; i < n; i++)
  ------------------
  |  Branch (3147:17): [True: 30.4k, False: 160]
  ------------------
 3148|  30.4k|	count += FrameSize(VECTOR_ELT(table, i), all);
 3149|    160|    return count;
 3150|    160|}
envir.c:FrameSize:
 3071|  30.4k|{
 3072|  30.4k|    int count = 0;
 3073|  30.4k|    if (all) {
  ------------------
  |  Branch (3073:9): [True: 30.4k, False: 0]
  ------------------
 3074|  63.1k|	while (frame != R_NilValue) {
  ------------------
  |  Branch (3074:9): [True: 32.6k, False: 30.4k]
  ------------------
 3075|  32.6k|	    count += 1;
 3076|  32.6k|	    frame = CDR(frame);
 3077|  32.6k|	}
 3078|  30.4k|    } else {
 3079|      0|	while (frame != R_NilValue) {
  ------------------
  |  Branch (3079:9): [True: 0, False: 0]
  ------------------
 3080|      0|	    if (NONEMPTY_(frame))
  ------------------
  |  | 3068|      0|    CHAR(PRINTNAME(TAG(_FRAME_)))[0] != '.'
  |  |  ------------------
  |  |  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  |  |  |  Branch (3068:5): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3081|      0|		count += 1;
 3082|      0|	    frame = CDR(frame);
 3083|      0|	}
 3084|      0|    }
 3085|  30.4k|    return count;
 3086|  30.4k|}
envir.c:BuiltinNames:
 3193|     14|{
 3194|     14|    SEXP s;
 3195|     14|    int j;
 3196|   688k|    for (j = 0; j < HSIZE; j++) {
  ------------------
  |  | 1174|   688k|#define HSIZE	  49157	/* The size of the hash table for symbols */
  ------------------
  |  Branch (3196:17): [True: 688k, False: 14]
  ------------------
 3197|   753k|	for (s = R_SymbolTable[j]; s != R_NilValue; s = CDR(s)) {
  ------------------
  |  Branch (3197:29): [True: 65.0k, False: 688k]
  ------------------
 3198|  65.0k|	    if (intern) {
  ------------------
  |  Branch (3198:10): [True: 0, False: 65.0k]
  ------------------
 3199|      0|		if (INTERNAL(CAR(s)) != R_NilValue)
  ------------------
  |  Branch (3199:7): [True: 0, False: 0]
  ------------------
 3200|      0|		    SET_STRING_ELT(names, (*indx)++, PRINTNAME(CAR(s)));
 3201|      0|	    }
 3202|  65.0k|	    else {
 3203|  65.0k|		if ((all || CHAR(PRINTNAME(CAR(s)))[0] != '.')
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (3203:8): [True: 65.0k, False: 0]
  |  Branch (3203:15): [True: 0, False: 0]
  ------------------
 3204|  65.0k|		    && SYMVALUE(CAR(s)) != R_UnboundValue)
  ------------------
  |  Branch (3204:10): [True: 19.8k, False: 45.2k]
  ------------------
 3205|  19.8k|		    SET_STRING_ELT(names, (*indx)++, PRINTNAME(CAR(s)));
 3206|  65.0k|	    }
 3207|  65.0k|	}
 3208|   688k|    }
 3209|     14|}
envir.c:HashTableNames:
 3153|    160|{
 3154|    160|    CHECK_HASH_TABLE(table);
  ------------------
  |  | 3136|    160|#define CHECK_HASH_TABLE(table) do {		\
  |  | 3137|    160|	if (TYPEOF(table) != VECSXP)		\
  |  |  ------------------
  |  |  |  |  131|    160|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (3137:6): [True: 0, False: 160]
  |  |  ------------------
  |  | 3138|    160|	    error("bad hash table contents");	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  | 3139|    160|    } while (0)
  |  |  ------------------
  |  |  |  Branch (3139:14): [Folded, False: 160]
  |  |  ------------------
  ------------------
 3155|    160|    int n = length(table);
  ------------------
  |  |  987|    160|#define length(x)		Rf_length(x)
  ------------------
 3156|    160|    int i;
 3157|  30.6k|    for (i = 0; i < n; i++)
  ------------------
  |  Branch (3157:17): [True: 30.4k, False: 160]
  ------------------
 3158|  30.4k|	FrameNames(VECTOR_ELT(table, i), all, names, indx);
 3159|    160|}
envir.c:FrameNames:
 3089|  30.4k|{
 3090|  30.4k|    if (all) {
  ------------------
  |  Branch (3090:9): [True: 30.4k, False: 0]
  ------------------
 3091|  63.0k|	while (frame != R_NilValue) {
  ------------------
  |  Branch (3091:9): [True: 32.6k, False: 30.4k]
  ------------------
 3092|  32.6k|	    SET_STRING_ELT(names, *indx, PRINTNAME(TAG(frame)));
 3093|  32.6k|	    (*indx)++;
 3094|  32.6k|	    frame = CDR(frame);
 3095|  32.6k|	}
 3096|  30.4k|    } else {
 3097|      0|	while (frame != R_NilValue) {
  ------------------
  |  Branch (3097:9): [True: 0, False: 0]
  ------------------
 3098|      0|	    if (NONEMPTY_(frame)) {
  ------------------
  |  | 3068|      0|    CHAR(PRINTNAME(TAG(_FRAME_)))[0] != '.'
  |  |  ------------------
  |  |  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  |  |  |  Branch (3068:5): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3099|      0|		SET_STRING_ELT(names, *indx, PRINTNAME(TAG(frame)));
 3100|      0|		(*indx)++;
 3101|      0|	    }
 3102|      0|	    frame = CDR(frame);
 3103|      0|	}
 3104|      0|    }
 3105|  30.4k|}
envir.c:pos2env:
 3565|    140|{
 3566|    140|    SEXP env;
 3567|    140|    RCNTXT *cptr;
 3568|       |
 3569|    140|    if (pos == NA_INTEGER || pos < -1 || pos == 0) {
  ------------------
  |  |   56|    280|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (3569:9): [True: 0, False: 140]
  |  Branch (3569:30): [True: 0, False: 140]
  |  Branch (3569:42): [True: 0, False: 140]
  ------------------
 3570|      0|	errorcall(call, _("invalid '%s' argument"), "pos");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid '%s' argument"), "pos");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3571|      0|	env = call;/* just for -Wall */
 3572|      0|    }
 3573|    140|    else if (pos == -1) {
  ------------------
  |  Branch (3573:14): [True: 38, False: 102]
  ------------------
 3574|       |	/* make sure the context is a funcall */
 3575|     38|	cptr = R_GlobalContext;
 3576|     38|	while( !(cptr->callflag & CTXT_FUNCTION) && cptr->nextcontext
  ------------------
  |  Branch (3576:9): [True: 0, False: 38]
  |  Branch (3576:46): [True: 0, False: 0]
  ------------------
 3577|      0|	       != NULL )
 3578|      0|	    cptr = cptr->nextcontext;
 3579|     38|	if( !(cptr->callflag & CTXT_FUNCTION) )
  ------------------
  |  Branch (3579:6): [True: 0, False: 38]
  ------------------
 3580|      0|	    errorcall(call, _("no enclosing environment"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("no enclosing environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3581|       |
 3582|     38|	env = cptr->sysparent;
 3583|     38|	if (R_GlobalEnv != R_NilValue && env == R_NilValue)
  ------------------
  |  Branch (3583:6): [True: 38, False: 0]
  |  Branch (3583:35): [True: 0, False: 38]
  ------------------
 3584|      0|	    errorcall(call, _("invalid '%s' argument"), "pos");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("invalid '%s' argument"), "pos");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3585|     38|    }
 3586|    102|    else {
 3587|    302|	for (env = R_GlobalEnv; env != R_EmptyEnv && pos > 1;
  ------------------
  |  Branch (3587:26): [True: 302, False: 0]
  |  Branch (3587:47): [True: 200, False: 102]
  ------------------
 3588|    200|	     env = ENCLOS(env))
 3589|    200|	    pos--;
 3590|    102|	if (pos != 1)
  ------------------
  |  Branch (3590:6): [True: 0, False: 102]
  ------------------
 3591|      0|	    errorcall(call, _("invalid '%s' argument"), "pos");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("invalid '%s' argument"), "pos");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3592|    102|    }
 3593|    140|    return env;
 3594|    140|}
envir.c:checkNSname:
 4228|   387k|{
 4229|   387k|    switch (TYPEOF(name)) {
 4230|   387k|    case SYMSXP:
  ------------------
  |  |  112|   387k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (4230:5): [True: 387k, False: 14]
  ------------------
 4231|   387k|	break;
 4232|     14|    case STRSXP:
  ------------------
  |  |  126|     14|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (4232:5): [True: 14, False: 387k]
  ------------------
 4233|     14|	if (LENGTH(name) >= 1) {
  ------------------
  |  Branch (4233:6): [True: 14, False: 0]
  ------------------
 4234|     14|	    name = installTrChar(STRING_ELT(name, 0));
  ------------------
  |  |  937|     14|#define installTrChar		Rf_installTrChar
  ------------------
 4235|     14|	    break;
 4236|     14|	}
 4237|       |	/* else fall through */
 4238|      0|    default:
  ------------------
  |  Branch (4238:5): [True: 0, False: 387k]
  ------------------
 4239|      0|	errorcall(call, _("bad namespace name"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("bad namespace name"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4240|   387k|    }
 4241|   387k|    return name;
 4242|   387k|}
envir.c:checkVarName:
 4328|   387k|{
 4329|   387k|    switch(TYPEOF(name)) {
 4330|   386k|    case SYMSXP: break;
  ------------------
  |  |  112|   386k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (4330:5): [True: 386k, False: 952]
  ------------------
 4331|    952|    case STRSXP:
  ------------------
  |  |  126|    952|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (4331:5): [True: 952, False: 386k]
  ------------------
 4332|    952|	if (LENGTH(name) >= 1) {
  ------------------
  |  Branch (4332:6): [True: 952, False: 0]
  ------------------
 4333|    952|	    name = installTrChar(STRING_ELT(name, 0));
  ------------------
  |  |  937|    952|#define installTrChar		Rf_installTrChar
  ------------------
 4334|    952|	    break;
 4335|    952|	}
 4336|       |	/* else fall through */
 4337|      0|    default:
  ------------------
  |  Branch (4337:5): [True: 0, False: 387k]
  ------------------
 4338|      0|	errorcall(call, _("bad variable name"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("bad variable name"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4339|   387k|    }
 4340|   387k|    return name;
 4341|   387k|}
envir.c:getVarValInFrame:
 4315|   388k|{
 4316|   388k|    SEXP val = R_findVarInFrame(rho, sym);
 4317|   388k|    if (! unbound_ok && val == R_UnboundValue)
  ------------------
  |  Branch (4317:9): [True: 387k, False: 952]
  |  Branch (4317:25): [True: 0, False: 387k]
  ------------------
 4318|      0|	R_ObjectNotFoundError(sym, R_CurrentExpression, NULL);
 4319|   388k|    if (TYPEOF(val) == PROMSXP) {
  ------------------
  |  |  116|   388k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (4319:9): [True: 17, False: 388k]
  ------------------
 4320|     17|	PROTECT(val);
  ------------------
  |  |  357|     17|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4321|     17|	val = eval(val, R_EmptyEnv);
  ------------------
  |  |  913|     17|#define eval			Rf_eval
  ------------------
 4322|     17|	UNPROTECT(1);
  ------------------
  |  |  358|     17|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4323|     17|    }
 4324|   388k|    return val;
 4325|   388k|}
envir.c:char_hash:
 4589|  1.19M|{
 4590|       |    /* djb2 as from http://www.cse.yorku.ca/~oz/hash.html */
 4591|  1.19M|    char *p;
 4592|  1.19M|    int i;
 4593|  1.19M|    unsigned int h = 5381;
 4594|  25.3M|    for (p = (char *) s, i = 0; i < len; p++, i++)
  ------------------
  |  Branch (4594:33): [True: 24.1M, False: 1.19M]
  ------------------
 4595|  24.1M|	h = ((h << 5) + h) + (*p);
 4596|  1.19M|    return h;
 4597|  1.19M|}

R_CheckStack:
  115|  9.37M|{
  116|  9.37M|    int dummy;
  117|  9.37M|    intptr_t usage = R_CStackDir * (R_CStackStart - (uintptr_t)&dummy);
  118|       |
  119|       |    /* printf("usage %ld\n", usage); */
  120|  9.37M|    if(R_CStackLimit != -1 && usage > ((intptr_t) R_CStackLimit))
  ------------------
  |  Branch (120:8): [True: 8.33M, False: 1.04M]
  |  Branch (120:31): [True: 0, False: 8.33M]
  ------------------
  121|      0|	R_SignalCStackOverflow(usage);
  122|  9.37M|}
R_CheckStack2:
  125|    826|{
  126|    826|    int dummy;
  127|    826|    intptr_t usage = R_CStackDir * (R_CStackStart - (uintptr_t)&dummy);
  128|       |
  129|    826|    if (INTPTR_MAX - usage < extra)
  ------------------
  |  Branch (129:9): [True: 0, False: 826]
  ------------------
  130|       |	/* addition would overflow, this is definitely too much */
  131|      0|	R_SignalCStackOverflow(INTPTR_MAX);
  132|       |
  133|       |    /* do it this way, as some compilers do usage + extra
  134|       |       in unsigned arithmetic */
  135|    826|    usage += extra;
  136|    826|    if(R_CStackLimit != -1 && usage > ((intptr_t) R_CStackLimit))
  ------------------
  |  Branch (136:8): [True: 0, False: 826]
  |  Branch (136:31): [True: 0, False: 0]
  ------------------
  137|      0|	R_SignalCStackOverflow(usage);
  138|       |
  139|    826|}
R_CheckUserInterrupt:
  142|  1.24M|{
  143|  1.24M|    R_CheckStack();
  144|       |
  145|       |    /* Don't do any processing of interrupts, timing limits, or other
  146|       |       asynchronous events if interrupts are suspended. */
  147|  1.24M|    if (R_interrupts_suspended) return;
  ------------------
  |  Branch (147:9): [True: 0, False: 1.24M]
  ------------------
  148|       |
  149|       |    /* This is the point where GUI systems need to do enough event
  150|       |       processing to determine whether there is a user interrupt event
  151|       |       pending.  Need to be careful not to do too much event
  152|       |       processing though: if event handlers written in R are allowed
  153|       |       to run at this point then we end up with concurrent R
  154|       |       evaluations and that can cause problems until we have proper
  155|       |       concurrency support. LT */
  156|       |
  157|  1.24M|    R_ProcessEvents(); /* Also processes timing limits */
  158|  1.24M|    if (R_interrupts_pending) onintr();
  ------------------
  |  |  112|      0|# define onintr			Rf_onintr
  ------------------
  |  Branch (158:9): [True: 0, False: 1.24M]
  ------------------
  159|  1.24M|}
Rvsnprintf_mbcs:
  308|   778k|{
  309|   778k|    int val;
  310|   778k|    val = vsnprintf(buf, size, format, ap);
  311|   778k|    if (size) {
  ------------------
  |  Branch (311:9): [True: 778k, False: 0]
  ------------------
  312|   778k|	if (val < 0) buf[0] = '\0'; /* not all uses check val < 0 */
  ------------------
  |  Branch (312:6): [True: 0, False: 778k]
  ------------------
  313|   778k|	else buf[size-1] = '\0';
  314|   778k|	if (val >= size)
  ------------------
  |  Branch (314:6): [True: 0, False: 778k]
  ------------------
  315|      0|	    mbcsTruncateToValid(buf);
  316|   778k|    }
  317|   778k|    return val;
  318|   778k|}
Rsnprintf_mbcs:
  328|  3.82k|{
  329|  3.82k|    int val;
  330|  3.82k|    va_list ap;
  331|       |
  332|  3.82k|    va_start(ap, format);
  333|  3.82k|    val = Rvsnprintf_mbcs(str, size, format, ap);
  334|  3.82k|    va_end(ap);
  335|       |
  336|  3.82k|    return val;
  337|  3.82k|}
Rf_warning:
  395|   385k|{
  396|   385k|    char buf[BUFSIZE], *p;
  397|       |
  398|   385k|    va_list(ap);
  399|   385k|    va_start(ap, format);
  400|   385k|    size_t psize;
  401|   385k|    int pval;
  402|       |
  403|   385k|    psize = min(BUFSIZE, R_WarnLength+1);
  ------------------
  |  |   49|   385k|#define min(a, b) (a<b?a:b)
  |  |  ------------------
  |  |  |  Branch (49:20): [True: 0, False: 385k]
  |  |  ------------------
  ------------------
  404|   385k|    pval = Rvsnprintf_mbcs(buf, psize, format, ap);
  405|   385k|    va_end(ap);
  406|   385k|    p = buf + strlen(buf) - 1;
  407|   385k|    if(strlen(buf) > 0 && *p == '\n') *p = '\0';
  ------------------
  |  Branch (407:8): [True: 385k, False: 0]
  |  Branch (407:27): [True: 0, False: 385k]
  ------------------
  408|   385k|    RprintTrunc(buf, pval >= psize);
  409|   385k|    SEXP call = PROTECT(getCurrentCall());
  ------------------
  |  |  357|   385k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  410|   385k|    warningcall(call, "%s", buf);
  ------------------
  |  | 2013|   385k|# define warningcall		Rf_warningcall
  ------------------
  411|   385k|    UNPROTECT(1);
  ------------------
  |  |  358|   385k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  412|   385k|}
Rf_warningcall:
  559|   385k|{
  560|   385k|    va_list(ap);
  561|   385k|    va_start(ap, format);
  562|   385k|    vsignalWarning(call, format, ap);
  563|       |    va_end(ap);
  564|   385k|}
do_gettext:
 1191|      8|{
 1192|       |#ifdef _gettext_3_args_only_
 1193|       |    checkArity(op, args);
 1194|       |#else
 1195|       |    // legacy code allowing "captured" 2-arg calls
 1196|      8|    int nargs = length(args);
  ------------------
  |  |  987|      8|#define length(x)		Rf_length(x)
  ------------------
 1197|      8|    if (nargs < 2 || nargs > 3)
  ------------------
  |  Branch (1197:9): [True: 0, False: 8]
  |  Branch (1197:22): [True: 0, False: 8]
  ------------------
 1198|      0|	errorcall(call, "either 2 or 3 arguments are required");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 1199|      8|#endif
 1200|      8|#ifdef ENABLE_NLS
 1201|      8|    SEXP string = CADR(args);
 1202|      8|    int n = LENGTH(string);
 1203|       |
 1204|      8|    if(isNull(string) || !n) return string;
  ------------------
  |  |  956|      8|#define isNull			Rf_isNull
  ------------------
  |  Branch (1204:8): [True: 0, False: 8]
  |  Branch (1204:26): [True: 0, False: 8]
  ------------------
 1205|       |
 1206|      8|    if(!isString(string)) error(_("invalid '%s' value"), "string");
  ------------------
  |  |  966|      8|#define isString		Rf_isString
  ------------------
                  if(!isString(string)) error(_("invalid '%s' value"), "string");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if(!isString(string)) error(_("invalid '%s' value"), "string");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (1206:8): [True: 0, False: 8]
  ------------------
 1207|       |
 1208|      8|    const char * domain = determine_domain_gettext(CAR(args), /*up*/TRUE);
 1209|       |
 1210|      8|    if(domain && strlen(domain)) {
  ------------------
  |  Branch (1210:8): [True: 8, False: 0]
  |  Branch (1210:18): [True: 8, False: 0]
  ------------------
 1211|      8|	SEXP ans = PROTECT(allocVector(STRSXP, n));
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1212|      8|	Rboolean trim;
 1213|       |#ifdef _gettext_3_args_only_
 1214|       |#else
 1215|      8|	if(nargs == 2)
  ------------------
  |  Branch (1215:5): [True: 0, False: 8]
  ------------------
 1216|      0|	    trim = TRUE;
 1217|      8|	else
 1218|      8|#endif
 1219|      8|	    trim = asRbool(CADDR(args), call);
  ------------------
  |  | 1861|      8|# define asRbool		Rf_asRbool
  ------------------
 1220|     16|	for(int i = 0; i < n; i++) {
  ------------------
  |  Branch (1220:17): [True: 8, False: 8]
  ------------------
 1221|      8|	    int ihead = 0, itail = 0;
 1222|      8|	    const char * This = translateChar(STRING_ELT(string, i));
  ------------------
  |  | 1037|      8|#define translateChar		Rf_translateChar
  ------------------
 1223|      8|	    char *tmp, *head = NULL, *tail = NULL, *tr;
 1224|      8|	    const char *p;
 1225|       |
 1226|      8|	    if(trim) {
  ------------------
  |  Branch (1226:9): [True: 8, False: 0]
  ------------------
 1227|      8|		R_CheckStack2(strlen(This) + 1);
 1228|      8|		tmp = (char *) alloca(strlen(This) + 1);
  ------------------
  |  | 2562|      8|# define alloca(x) __builtin_alloca((x))
  ------------------
 1229|      8|		strcpy(tmp, This);
 1230|       |
 1231|       |		/* strip leading and trailing white spaces and
 1232|       |		   add back after translation */
 1233|      8|		for(p = tmp;
 1234|      8|		    *p && (*p == ' ' || *p == '\t' || *p == '\n');
  ------------------
  |  Branch (1234:7): [True: 8, False: 0]
  |  Branch (1234:14): [True: 0, False: 8]
  |  Branch (1234:27): [True: 0, False: 8]
  |  Branch (1234:41): [True: 0, False: 8]
  ------------------
 1235|      8|		    p++, ihead++) ;
 1236|       |
 1237|      8|		if(ihead > 0) {
  ------------------
  |  Branch (1237:6): [True: 0, False: 8]
  ------------------
 1238|      0|		    R_CheckStack2(ihead + 1);
 1239|      0|		    head = (char *) alloca(ihead + 1);
  ------------------
  |  | 2562|      0|# define alloca(x) __builtin_alloca((x))
  ------------------
 1240|      0|		    Rstrncpy(head, tmp, ihead + 1);
 1241|      0|		    tmp += ihead;
 1242|      0|		}
 1243|       |
 1244|      8|		if(strlen(tmp))
  ------------------
  |  Branch (1244:6): [True: 8, False: 0]
  ------------------
 1245|      8|		    for(p = tmp+strlen(tmp)-1;
 1246|      8|			p >= tmp && (*p == ' ' || *p == '\t' || *p == '\n');
  ------------------
  |  Branch (1246:4): [True: 8, False: 0]
  |  Branch (1246:17): [True: 0, False: 8]
  |  Branch (1246:30): [True: 0, False: 8]
  |  Branch (1246:44): [True: 0, False: 8]
  ------------------
 1247|      8|			p--, itail++) ;
 1248|       |
 1249|      8|		if(itail > 0) {
  ------------------
  |  Branch (1249:6): [True: 0, False: 8]
  ------------------
 1250|      0|		    R_CheckStack2(itail + 1);
 1251|      0|		    tail = (char *) alloca(itail + 1);
  ------------------
  |  | 2562|      0|# define alloca(x) __builtin_alloca((x))
  ------------------
 1252|      0|		    strcpy(tail, tmp+strlen(tmp)-itail);
 1253|      0|		    tmp[strlen(tmp)-itail] = '\0';
 1254|      0|		}
 1255|       |
 1256|      8|		p = tmp;
 1257|      8|	    } else
 1258|      0|		p = This;
 1259|      8|	    if(strlen(p)) {
  ------------------
  |  Branch (1259:9): [True: 8, False: 0]
  ------------------
 1260|      8|		GETT_PRINT("translating '%s' in domain '%s'\n", p, domain);
  ------------------
  |  | 1105|      8|# define GETT_PRINT(...) do {} while(0)
  |  |  ------------------
  |  |  |  Branch (1105:38): [Folded, False: 8]
  |  |  ------------------
  ------------------
 1261|      8|		tr = dgettext(domain, p);
 1262|      8|		if(ihead > 0 || itail > 0) {
  ------------------
  |  Branch (1262:6): [True: 0, False: 8]
  |  Branch (1262:19): [True: 0, False: 8]
  ------------------
 1263|      0| 		R_CheckStack2(        strlen(tr) + ihead + itail + 1);
 1264|      0|		tmp = (char *) alloca(strlen(tr) + ihead + itail + 1);
  ------------------
  |  | 2562|      0|# define alloca(x) __builtin_alloca((x))
  ------------------
 1265|      0|		tmp[0] ='\0';
 1266|      0|		if(ihead > 0) strcat(tmp, head);
  ------------------
  |  Branch (1266:6): [True: 0, False: 0]
  ------------------
 1267|      0|		strcat(tmp, tr);
 1268|      0|		if(itail > 0) strcat(tmp, tail);
  ------------------
  |  Branch (1268:6): [True: 0, False: 0]
  ------------------
 1269|      0|		} else
 1270|      8|		    tmp = tr;
 1271|      8|		SET_STRING_ELT(ans, i, mkChar(tmp));
  ------------------
  |  |  998|      8|#define mkChar			Rf_mkChar
  ------------------
 1272|      8|	    } else
 1273|      0|		SET_STRING_ELT(ans, i, mkChar(This));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 1274|      8|	}
 1275|      8|	UNPROTECT(1);
  ------------------
  |  |  358|      8|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1276|      8|	return ans;
 1277|      8|    } else
 1278|      0|#endif
 1279|       |	// no NLS or no domain :
 1280|      0|	return CADR(args);
 1281|      8|}
do_bindtextdomain:
 1316|     28|{
 1317|     28|#ifdef ENABLE_NLS
 1318|     28|    checkArity(op, args);
  ------------------
  |  | 1788|     28|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1319|     28|    if(isNull(CAR(args)) && isNull(CADR(args))) {
  ------------------
  |  |  956|     28|#define isNull			Rf_isNull
  ------------------
                  if(isNull(CAR(args)) && isNull(CADR(args))) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (1319:8): [True: 0, False: 28]
  |  Branch (1319:29): [True: 0, False: 0]
  ------------------
 1320|      0|	textdomain(textdomain(NULL)); // flush the cache
 1321|      0|	return ScalarLogical(TRUE);
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
 1322|      0|    }
 1323|     28|    else if(!isString(CAR(args)) || LENGTH(CAR(args)) != 1)
  ------------------
  |  |  966|     28|#define isString		Rf_isString
  ------------------
  |  Branch (1323:13): [True: 0, False: 28]
  |  Branch (1323:37): [True: 0, False: 28]
  ------------------
 1324|      0|	error(_("invalid '%s' value"), "domain");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' value"), "domain");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1325|       |
 1326|     28|    char *res;
 1327|     28|    if(isNull(CADR(args))) {
  ------------------
  |  |  956|     28|#define isNull			Rf_isNull
  ------------------
  |  Branch (1327:8): [True: 0, False: 28]
  ------------------
 1328|      0|	res = bindtextdomain(translateChar(STRING_ELT(CAR(args),0)), NULL);
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
 1329|     28|    } else {
 1330|     28|	if(!isString(CADR(args)) || LENGTH(CADR(args)) != 1)
  ------------------
  |  |  966|     28|#define isString		Rf_isString
  ------------------
  |  Branch (1330:5): [True: 0, False: 28]
  |  Branch (1330:30): [True: 0, False: 28]
  ------------------
 1331|      0|	    error(_("invalid '%s' value"), "dirname");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' value"), "dirname");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1332|     28|	res = bindtextdomain(translateChar(STRING_ELT(CAR (args),0)),
  ------------------
  |  | 1037|     28|#define translateChar		Rf_translateChar
  ------------------
 1333|     28|			     translateChar(STRING_ELT(CADR(args),0)));
  ------------------
  |  | 1037|     28|#define translateChar		Rf_translateChar
  ------------------
 1334|     28|    }
 1335|     28|    if(res) return mkString(res);
  ------------------
  |  | 1003|     28|#define mkString		Rf_mkString
  ------------------
  |  Branch (1335:8): [True: 28, False: 0]
  ------------------
 1336|       |    /* else this failed */
 1337|      0|#endif
 1338|      0|    return R_NilValue;
 1339|     28|}
R_GetTracebackOnly:
 1524|  1.90k|{
 1525|  1.90k|    int nback = 0, ns;
 1526|  1.90k|    RCNTXT *c;
 1527|  1.90k|    SEXP s, t;
 1528|       |
 1529|  1.90k|    for (c = R_GlobalContext, ns = skip;
 1530|  7.63k|	 c != NULL && c->callflag != CTXT_TOPLEVEL;
  ------------------
  |  Branch (1530:3): [True: 7.63k, False: 0]
  |  Branch (1530:16): [True: 5.72k, False: 1.90k]
  ------------------
 1531|  5.72k|	 c = c->nextcontext)
 1532|  5.72k|	if (c->callflag & (CTXT_FUNCTION | CTXT_BUILTIN) ) {
  ------------------
  |  Branch (1532:6): [True: 1.90k, False: 3.81k]
  ------------------
 1533|  1.90k|	    if (ns > 0)
  ------------------
  |  Branch (1533:10): [True: 0, False: 1.90k]
  ------------------
 1534|      0|		ns--;
 1535|  1.90k|	    else
 1536|  1.90k|		nback++;
 1537|  1.90k|	}
 1538|       |
 1539|  1.90k|    PROTECT(s = allocList(nback));
  ------------------
  |  |  357|  1.90k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1540|  1.90k|    t = s;
 1541|  1.90k|    for (c = R_GlobalContext ;
 1542|  7.63k|	 c != NULL && c->callflag != CTXT_TOPLEVEL;
  ------------------
  |  Branch (1542:3): [True: 7.63k, False: 0]
  |  Branch (1542:16): [True: 5.72k, False: 1.90k]
  ------------------
 1543|  5.72k|	 c = c->nextcontext)
 1544|  5.72k|	if (c->callflag & (CTXT_FUNCTION | CTXT_BUILTIN) ) {
  ------------------
  |  Branch (1544:6): [True: 1.90k, False: 3.81k]
  ------------------
 1545|  1.90k|	    if (skip > 0)
  ------------------
  |  Branch (1545:10): [True: 0, False: 1.90k]
  ------------------
 1546|      0|		skip--;
 1547|  1.90k|	    else {
 1548|  1.90k|		SETCAR(t, duplicate(c->call));
  ------------------
  |  |  909|  1.90k|#define duplicate		Rf_duplicate
  ------------------
 1549|  1.90k|		if (c->srcref && !isNull(c->srcref)) {
  ------------------
  |  |  956|  1.90k|#define isNull			Rf_isNull
  ------------------
  |  Branch (1549:7): [True: 1.90k, False: 0]
  |  Branch (1549:20): [True: 0, False: 1.90k]
  ------------------
 1550|      0|		    SEXP sref;
 1551|      0|		    if (c->srcref == R_InBCInterpreter)
  ------------------
  |  Branch (1551:11): [True: 0, False: 0]
  ------------------
 1552|      0|			sref = R_findBCInterpreterSrcref(c);
 1553|      0|		    else
 1554|      0|			sref = c->srcref;
 1555|      0|		    setAttrib(CAR(t), R_SrcrefSymbol, duplicate(sref));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              		    setAttrib(CAR(t), R_SrcrefSymbol, duplicate(sref));
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 1556|      0|		}
 1557|  1.90k|		t = CDR(t);
 1558|  1.90k|	    }
 1559|  1.90k|	}
 1560|  1.90k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.90k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1561|  1.90k|    return s;
 1562|  1.90k|}
R_UnwindHandlerStack:
 1687|  4.30M|{
 1688|  4.30M|    SEXP hs;
 1689|       |
 1690|       |    /* check that the target is in the current stack */
 1691|  4.31M|    for (hs = R_HandlerStack; hs != target && hs != R_NilValue; hs = CDR(hs))
  ------------------
  |  Branch (1691:31): [True: 1.77k, False: 4.30M]
  |  Branch (1691:47): [True: 1.77k, False: 0]
  ------------------
 1692|  1.77k|	if (hs == target)
  ------------------
  |  Branch (1692:6): [True: 0, False: 1.77k]
  ------------------
 1693|      0|	    break;
 1694|  4.30M|    if (hs != target)
  ------------------
  |  Branch (1694:9): [True: 0, False: 4.30M]
  ------------------
 1695|      0|	return target; /* restoring a saved stack */
 1696|       |
 1697|  4.31M|    for (hs = R_HandlerStack; hs != target; hs = CDR(hs)) {
  ------------------
  |  Branch (1697:31): [True: 1.77k, False: 4.30M]
  ------------------
 1698|       |	/* pop top handler; may not be needed */
 1699|  1.77k|	R_HandlerStack = CDR(hs);
 1700|       |
 1701|       |	/* clear the two environments to reduce reference counts */
 1702|  1.77k|	CLEAR_ENTRY_CALLING_ENVIR(CAR(hs));
  ------------------
  |  | 1683|  1.77k|#define CLEAR_ENTRY_CALLING_ENVIR(e) SET_VECTOR_ELT(e, 1, R_NilValue)
  ------------------
 1703|  1.77k|	CLEAR_ENTRY_TARGET_ENVIR(CAR(hs));
  ------------------
  |  | 1684|  1.77k|#define CLEAR_ENTRY_TARGET_ENVIR(e) SET_VECTOR_ELT(e, 3, R_NilValue)
  ------------------
 1704|  1.77k|    }
 1705|  4.30M|    return target;
 1706|  4.30M|}
R_FixupExitingHandlerResult:
 1713|    136|{
 1714|       |    /* The internal error handling mechanism stores the error message
 1715|       |       in 'errbuf'.  If an on.exit() action is processed while jumping
 1716|       |       to an exiting handler for such an error, then endcontext()
 1717|       |       calls R_FixupExitingHandlerResult to save the error message
 1718|       |       currently in the buffer before processing the on.exit
 1719|       |       action. This is in case an error occurs in the on.exit action
 1720|       |       that over-writes the buffer. The allocation should occur in a
 1721|       |       more favorable stack context than before the jump. The
 1722|       |       R_HandlerResultToken is used to make sure the result being
 1723|       |       modified is associated with jumping to an exiting handler. */
 1724|    136|    if (result != NULL &&
  ------------------
  |  Branch (1724:9): [True: 100, False: 36]
  ------------------
 1725|    100|	TYPEOF(result) == VECSXP &&
  ------------------
  |  |  131|    236|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1725:2): [True: 0, False: 100]
  ------------------
 1726|      0|	XLENGTH(result) == RESULT_SIZE &&
  ------------------
  |  | 1708|    136|#define RESULT_SIZE 4
  ------------------
  |  Branch (1726:2): [True: 0, False: 0]
  ------------------
 1727|      0|	VECTOR_ELT(result, 0) == R_NilValue &&
  ------------------
  |  Branch (1727:2): [True: 0, False: 0]
  ------------------
 1728|      0|	VECTOR_ELT(result, RESULT_SIZE - 1) == R_HandlerResultToken) {
  ------------------
  |  | 1708|      0|#define RESULT_SIZE 4
  ------------------
  |  Branch (1728:2): [True: 0, False: 0]
  ------------------
 1729|      0|	SET_VECTOR_ELT(result, 0, mkString(errbuf));
  ------------------
  |  | 1003|      0|#define mkString		Rf_mkString
  ------------------
 1730|      0|    }
 1731|    136|}
do_addCondHands:
 1734|  2.33k|{
 1735|  2.33k|    SEXP classes, handlers, parentenv, target, oldstack, newstack, result;
 1736|  2.33k|    int calling, i, n;
 1737|  2.33k|    PROTECT_INDEX osi;
 1738|       |
 1739|  2.33k|    if (R_HandlerResultToken == NULL) {
  ------------------
  |  Branch (1739:9): [True: 2, False: 2.33k]
  ------------------
 1740|      2|	R_HandlerResultToken = allocVector(VECSXP, 1);
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
              	R_HandlerResultToken = allocVector(VECSXP, 1);
  ------------------
  |  |  131|      2|#define VECSXP	    19	  /* generic vectors */
  ------------------
 1741|      2|	R_PreserveObject(R_HandlerResultToken);
 1742|      2|    }
 1743|       |
 1744|  2.33k|    checkArity(op, args);
  ------------------
  |  | 1788|  2.33k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1745|       |
 1746|  2.33k|    classes = CAR(args); args = CDR(args);
 1747|  2.33k|    handlers = CAR(args); args = CDR(args);
 1748|  2.33k|    parentenv = CAR(args); args = CDR(args);
 1749|  2.33k|    target = CAR(args); args = CDR(args);
 1750|  2.33k|    calling = asLogical(CAR(args));
  ------------------
  |  |  886|  2.33k|#define asLogical		Rf_asLogical
  ------------------
 1751|       |
 1752|  2.33k|    if (classes == R_NilValue || handlers == R_NilValue)
  ------------------
  |  Branch (1752:9): [True: 0, False: 2.33k]
  |  Branch (1752:34): [True: 0, False: 2.33k]
  ------------------
 1753|      0|	return R_HandlerStack;
 1754|       |
 1755|  2.33k|    if (TYPEOF(classes) != STRSXP || TYPEOF(handlers) != VECSXP ||
  ------------------
  |  |  126|  4.67k|#define STRSXP	    16	  /* string vectors */
  ------------------
                  if (TYPEOF(classes) != STRSXP || TYPEOF(handlers) != VECSXP ||
  ------------------
  |  |  131|  4.67k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1755:9): [True: 0, False: 2.33k]
  |  Branch (1755:38): [True: 0, False: 2.33k]
  ------------------
 1756|  2.33k|	LENGTH(classes) != LENGTH(handlers))
  ------------------
  |  Branch (1756:2): [True: 0, False: 2.33k]
  ------------------
 1757|      0|	error(_("bad handler data"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("bad handler data"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1758|       |
 1759|  2.33k|    n = LENGTH(handlers);
 1760|  2.33k|    oldstack = R_HandlerStack;
 1761|       |
 1762|  2.33k|    PROTECT(result = allocVector(VECSXP, RESULT_SIZE));
  ------------------
  |  |  357|  2.33k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1763|  2.33k|    SET_VECTOR_ELT(result, RESULT_SIZE - 1, R_HandlerResultToken);
  ------------------
  |  | 1708|  2.33k|#define RESULT_SIZE 4
  ------------------
 1764|  2.33k|    PROTECT_WITH_INDEX(newstack = oldstack, &osi);
  ------------------
  |  |  366|  2.33k|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
 1765|       |
 1766|  4.67k|    for (i = n - 1; i >= 0; i--) {
  ------------------
  |  Branch (1766:21): [True: 2.33k, False: 2.33k]
  ------------------
 1767|  2.33k|	SEXP klass = STRING_ELT(classes, i);
 1768|  2.33k|	SEXP handler = VECTOR_ELT(handlers, i);
 1769|  2.33k|	SEXP entry = mkHandlerEntry(klass, parentenv, handler, target, result,
 1770|  2.33k|				    calling);
 1771|  2.33k|	REPROTECT(newstack = CONS(entry, newstack), osi);
  ------------------
  |  |  367|  2.33k|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 1772|  2.33k|    }
 1773|       |
 1774|  2.33k|    R_HandlerStack = newstack;
 1775|  2.33k|    UNPROTECT(2);
  ------------------
  |  |  358|  2.33k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1776|       |
 1777|  2.33k|    return oldstack;
 1778|  2.33k|}
do_signalCondition:
 1896|   385k|{
 1897|   385k|    SEXP list, cond, msg, ecall, oldstack;
 1898|       |
 1899|   385k|    checkArity(op, args);
  ------------------
  |  | 1788|   385k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1900|       |
 1901|   385k|    cond = CAR(args);
 1902|   385k|    msg = CADR(args);
 1903|   385k|    ecall = CADDR(args);
 1904|       |
 1905|   385k|    PROTECT(oldstack = R_HandlerStack);
  ------------------
  |  |  357|   385k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1906|   386k|    while ((list = findConditionHandler(cond)) != R_NilValue) {
  ------------------
  |  Branch (1906:12): [True: 1.14k, False: 385k]
  ------------------
 1907|  1.14k|	SEXP entry = CAR(list);
 1908|  1.14k|	R_HandlerStack = CDR(list);
 1909|  1.14k|	if (IS_CALLING_ENTRY(entry)) {
  ------------------
  |  | 1677|  1.14k|#define IS_CALLING_ENTRY(e) LEVELS(e)
  |  |  ------------------
  |  |  |  Branch (1677:29): [True: 1.14k, False: 0]
  |  |  ------------------
  ------------------
 1910|  1.14k|	    SEXP h = ENTRY_HANDLER(entry);
  ------------------
  |  | 1680|  1.14k|#define ENTRY_HANDLER(e) VECTOR_ELT(e, 2)
  ------------------
 1911|  1.14k|	    if (h == R_RestartToken) {
  ------------------
  |  Branch (1911:10): [True: 0, False: 1.14k]
  ------------------
 1912|      0|		const char *msgstr = NULL;
 1913|      0|		if (TYPEOF(msg) == STRSXP && LENGTH(msg) > 0)
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1913:7): [True: 0, False: 0]
  |  Branch (1913:32): [True: 0, False: 0]
  ------------------
 1914|      0|		    msgstr = translateChar(STRING_ELT(msg, 0));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
 1915|      0|		else error(_("error message not a string"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		else error(_("error message not a string"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1916|      0|		errorcall_dflt(ecall, "%s", msgstr);
 1917|      0|	    }
 1918|  1.14k|	    else {
 1919|  1.14k|		SEXP hcall = LCONS(h, LCONS(cond, R_NilValue));
  ------------------
  |  |  310|  1.14k|#define LCONS(a, b)	Rf_lcons((a), (b))		/* language lists */
  ------------------
 1920|  1.14k|		PROTECT(hcall);
  ------------------
  |  |  357|  1.14k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1921|  1.14k|		eval(hcall, R_GlobalEnv);
  ------------------
  |  |  913|  1.14k|#define eval			Rf_eval
  ------------------
 1922|  1.14k|		UNPROTECT(1);
  ------------------
  |  |  358|  1.14k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1923|  1.14k|	    }
 1924|  1.14k|	}
 1925|      0|	else gotoExitingHandler(cond, ecall, entry);
 1926|  1.14k|    }
 1927|   385k|    R_HandlerStack = oldstack;
 1928|   385k|    UNPROTECT(1);
  ------------------
  |  |  358|   385k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1929|   385k|    return R_NilValue;
 1930|   385k|}
do_dfltWarn:
 2033|   384k|{
 2034|   384k|    checkArity(op, args);
  ------------------
  |  | 1788|   384k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2035|       |
 2036|   384k|    if (TYPEOF(CAR(args)) != STRSXP || LENGTH(CAR(args)) != 1)
  ------------------
  |  |  126|   768k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2036:9): [True: 0, False: 384k]
  |  Branch (2036:40): [True: 0, False: 384k]
  ------------------
 2037|      0|	error(_("bad error message"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("bad error message"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2038|   384k|    const char *msg = translateChar(STRING_ELT(CAR(args), 0));
  ------------------
  |  | 1037|   384k|#define translateChar		Rf_translateChar
  ------------------
 2039|   384k|    SEXP ecall = CADR(args);
 2040|       |
 2041|   384k|    warningcall_dflt(ecall, "%s", msg);
 2042|   384k|    return R_NilValue;
 2043|   384k|}
do_getRestart:
 2063|  1.14k|{
 2064|  1.14k|    int i;
 2065|  1.14k|    SEXP list;
 2066|  1.14k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.14k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2067|  1.14k|    i = asInteger(CAR(args));
  ------------------
  |  |  885|  1.14k|#define asInteger		Rf_asInteger
  ------------------
 2068|  1.14k|    for (list = R_RestartStack;
 2069|  1.14k|	 list != R_NilValue && i > 1;
  ------------------
  |  Branch (2069:3): [True: 1.14k, False: 0]
  |  Branch (2069:25): [True: 0, False: 1.14k]
  ------------------
 2070|  1.14k|	 list = CDR(list), i--);
 2071|  1.14k|    if (list != R_NilValue)
  ------------------
  |  Branch (2071:9): [True: 1.14k, False: 0]
  ------------------
 2072|  1.14k|	return CAR(list);
 2073|      0|    else if (i == 1) {
  ------------------
  |  Branch (2073:14): [True: 0, False: 0]
  ------------------
 2074|       |	/**** need to pre-allocate */
 2075|      0|	SEXP name, entry;
 2076|      0|	PROTECT(name = mkString("abort"));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2077|      0|	PROTECT(entry = allocVector(VECSXP, 2));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2078|      0|	SET_VECTOR_ELT(entry, 0, name);
 2079|      0|	SET_VECTOR_ELT(entry, 1, R_NilValue);
 2080|      0|	setAttrib(entry, R_ClassSymbol, mkString("restart"));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              	setAttrib(entry, R_ClassSymbol, mkString("restart"));
  ------------------
  |  | 1003|      0|#define mkString		Rf_mkString
  ------------------
 2081|      0|	UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2082|      0|	return entry;
 2083|      0|    }
 2084|      0|    else return R_NilValue;
 2085|  1.14k|}
do_addRestart:
 2095|   385k|{
 2096|   385k|    checkArity(op, args);
  ------------------
  |  | 1788|   385k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2097|   385k|    CHECK_RESTART(CAR(args));
  ------------------
  |  | 2088|   385k|#define CHECK_RESTART(r) do { \
  |  | 2089|   385k|    SEXP __r__ = (r); \
  |  | 2090|   385k|    if (TYPEOF(__r__) != VECSXP || LENGTH(__r__) < 2) \
  |  |  ------------------
  |  |  |  |  131|   770k|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (2090:9): [True: 0, False: 385k]
  |  |  |  Branch (2090:36): [True: 0, False: 385k]
  |  |  ------------------
  |  | 2091|   385k|	error(_("bad restart")); \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("bad restart")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2092|   385k|} while (0)
  |  |  ------------------
  |  |  |  Branch (2092:10): [Folded, False: 385k]
  |  |  ------------------
  ------------------
 2098|   385k|    R_RestartStack = CONS(CAR(args), R_RestartStack);
  ------------------
  |  |  309|   385k|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 2099|   385k|    return R_NilValue;
 2100|   385k|}
do_invokeRestart:
 2129|  1.14k|{
 2130|  1.14k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.14k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2131|       |    CHECK_RESTART(CAR(args));
  ------------------
  |  | 2088|  1.14k|#define CHECK_RESTART(r) do { \
  |  | 2089|  1.14k|    SEXP __r__ = (r); \
  |  | 2090|  1.14k|    if (TYPEOF(__r__) != VECSXP || LENGTH(__r__) < 2) \
  |  |  ------------------
  |  |  |  |  131|  2.29k|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (2090:9): [True: 0, False: 1.14k]
  |  |  |  Branch (2090:36): [True: 0, False: 1.14k]
  |  |  ------------------
  |  | 2091|  1.14k|	error(_("bad restart")); \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("bad restart")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2092|  1.14k|} while (0)
  |  |  ------------------
  |  |  |  Branch (2092:10): [Folded, False: 1.14k]
  |  |  ------------------
  ------------------
 2132|  1.14k|    invokeRestart(CAR(args), CADR(args));
 2133|  1.14k|}
R_signalErrorConditionEx:
 2689|  1.90k|{
 2690|       |    /* caller must make sure that 'cond' and 'call' are protected. */
 2691|  1.90k|    R_signalCondition(cond, call, TRUE, exitOnly);
 2692|       |
 2693|       |    /* the first element of 'cond' must be a scalar string to be used
 2694|       |       as the error message in default error processing. */
 2695|  1.90k|    if (TYPEOF(cond) != VECSXP || LENGTH(cond) == 0)
  ------------------
  |  |  131|  3.81k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2695:9): [True: 0, False: 1.90k]
  |  Branch (2695:35): [True: 0, False: 1.90k]
  ------------------
 2696|      0|	error(_("condition object must be a VECSXP of length at least one"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("condition object must be a VECSXP of length at least one"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2697|  1.90k|    SEXP elt = VECTOR_ELT(cond, 0);
 2698|  1.90k|    if (TYPEOF(elt) != STRSXP || LENGTH(elt) != 1)
  ------------------
  |  |  911|  1.90k|#define elt			Rf_elt
  ------------------
                  if (TYPEOF(elt) != STRSXP || LENGTH(elt) != 1)
  ------------------
  |  |  126|  3.81k|#define STRSXP	    16	  /* string vectors */
  ------------------
                  if (TYPEOF(elt) != STRSXP || LENGTH(elt) != 1)
  ------------------
  |  |  911|  1.90k|#define elt			Rf_elt
  ------------------
  |  Branch (2698:9): [True: 0, False: 1.90k]
  |  Branch (2698:34): [True: 0, False: 1.90k]
  ------------------
 2699|      0|	error(_("first element of condition object must be a scalar string"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("first element of condition object must be a scalar string"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2700|       |
 2701|  1.90k|    errorcall_dflt(call, "%s", translateChar(STRING_ELT(elt, 0)));
  ------------------
  |  | 1037|  1.90k|#define translateChar		Rf_translateChar
  ------------------
                  errorcall_dflt(call, "%s", translateChar(STRING_ELT(elt, 0)));
  ------------------
  |  |  911|  1.90k|#define elt			Rf_elt
  ------------------
 2702|  1.90k|}
R_signalErrorCondition:
 2706|  1.90k|{
 2707|  1.90k|    R_signalErrorConditionEx(cond, call, FALSE);
 2708|  1.90k|}
R_vmakeErrorCondition:
 2737|  1.91k|{
 2738|  1.91k|    if (call == R_CurrentExpression)
  ------------------
  |  Branch (2738:9): [True: 0, False: 1.91k]
  ------------------
 2739|       |	/* behave like error() */
 2740|      0|	call = getCurrentCall();
 2741|  1.91k|    PROTECT(call);
  ------------------
  |  |  357|  1.91k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2742|  1.91k|    int nelem = nextra + 2;
 2743|  1.91k|    SEXP cond = PROTECT(allocVector(VECSXP, nelem));
  ------------------
  |  |  357|  1.91k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2744|       |
 2745|  1.91k|    Rvsnprintf_mbcs(emsg_buf, BUFSIZE, format, ap);
  ------------------
  |  |  368|  1.91k|#define BUFSIZE 8192
  ------------------
 2746|  1.91k|    SET_VECTOR_ELT(cond, 0, mkString(emsg_buf));
  ------------------
  |  | 1003|  1.91k|#define mkString		Rf_mkString
  ------------------
 2747|  1.91k|    SET_VECTOR_ELT(cond, 1, call);
 2748|       |
 2749|  1.91k|    SEXP names = allocVector(STRSXP, nelem);
  ------------------
  |  |  875|  1.91k|#define allocVector		Rf_allocVector
  ------------------
                  SEXP names = allocVector(STRSXP, nelem);
  ------------------
  |  |  126|  1.91k|#define STRSXP	    16	  /* string vectors */
  ------------------
 2750|  1.91k|    setAttrib(cond, R_NamesSymbol, names);
  ------------------
  |  | 1027|  1.91k|#define setAttrib		Rf_setAttrib
  ------------------
 2751|  1.91k|    SET_STRING_ELT(names, 0, mkChar("message"));
  ------------------
  |  |  998|  1.91k|#define mkChar			Rf_mkChar
  ------------------
 2752|  1.91k|    SET_STRING_ELT(names, 1, mkChar("call"));
  ------------------
  |  |  998|  1.91k|#define mkChar			Rf_mkChar
  ------------------
 2753|       |
 2754|  1.91k|    SEXP klass = allocVector(STRSXP, subclassname == NULL ? 3 : 4);
  ------------------
  |  |  875|  1.91k|#define allocVector		Rf_allocVector
  ------------------
                  SEXP klass = allocVector(STRSXP, subclassname == NULL ? 3 : 4);
  ------------------
  |  |  126|  1.91k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2754:38): [True: 0, False: 1.91k]
  ------------------
 2755|  1.91k|    setAttrib(cond, R_ClassSymbol, klass);
  ------------------
  |  | 1027|  1.91k|#define setAttrib		Rf_setAttrib
  ------------------
 2756|  1.91k|    if (subclassname == NULL) {
  ------------------
  |  Branch (2756:9): [True: 0, False: 1.91k]
  ------------------
 2757|      0|	SET_STRING_ELT(klass, 0, mkChar(classname));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 2758|      0|	SET_STRING_ELT(klass, 1, mkChar("error"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 2759|      0|	SET_STRING_ELT(klass, 2, mkChar("condition"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 2760|      0|    }
 2761|  1.91k|    else {
 2762|  1.91k|	SET_STRING_ELT(klass, 0, mkChar(subclassname));
  ------------------
  |  |  998|  1.91k|#define mkChar			Rf_mkChar
  ------------------
 2763|  1.91k|	SET_STRING_ELT(klass, 1, mkChar(classname));
  ------------------
  |  |  998|  1.91k|#define mkChar			Rf_mkChar
  ------------------
 2764|  1.91k|	SET_STRING_ELT(klass, 2, mkChar("error"));
  ------------------
  |  |  998|  1.91k|#define mkChar			Rf_mkChar
  ------------------
 2765|  1.91k|	SET_STRING_ELT(klass, 3, mkChar("condition"));
  ------------------
  |  |  998|  1.91k|#define mkChar			Rf_mkChar
  ------------------
 2766|  1.91k|    }
 2767|       |
 2768|  1.91k|    UNPROTECT(2); /* cond, call */
  ------------------
  |  |  358|  1.91k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2769|       |
 2770|  1.91k|    return cond;
 2771|  1.91k|}
R_makeErrorCondition:
 2777|  1.91k|{
 2778|  1.91k|    va_list(ap);
 2779|  1.91k|    va_start(ap, format);
 2780|  1.91k|    SEXP cond = R_vmakeErrorCondition(call, classname, subclassname,
 2781|  1.91k|				      nextra, format, ap);
 2782|       |    va_end(ap);
 2783|  1.91k|    return cond;
 2784|  1.91k|}
R_FunctionNotFoundError:
 2844|  1.90k|{
 2845|  1.90k|    if (TYPEOF(sym) != SYMSXP)
  ------------------
  |  |  112|  1.90k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (2845:9): [True: 0, False: 1.90k]
  ------------------
 2846|      0|	error(_("not a symbol"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not a symbol"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2847|  1.90k|    if (call == R_CurrentExpression)
  ------------------
  |  Branch (2847:9): [True: 1.00k, False: 908]
  ------------------
 2848|  1.00k|	call = getCurrentCall();
 2849|  1.90k|    PROTECT(call);
  ------------------
  |  |  357|  1.90k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2850|  1.90k|    SEXP cond = R_makeErrorCondition(call,
 2851|  1.90k|				     "objectNotFoundError",
 2852|  1.90k|				     "functionNotFoundError",
 2853|  1.90k|				     2,
 2854|  1.90k|				     _("could not find function \"%s\""),
  ------------------
  |  | 2531|  1.90k|#   define _(String) gettext (String)
  ------------------
 2855|  1.90k|				     EncodeChar(PRINTNAME(sym)));
  ------------------
  |  | 1890|  1.90k|# define EncodeChar             Rf_EncodeChar
  ------------------
 2856|  1.90k|    PROTECT(cond);
  ------------------
  |  |  357|  1.90k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2857|  1.90k|    R_setConditionField(cond, 2, "name", sym);
 2858|  1.90k|    R_setConditionField(cond, 3, "mode", mkString("function"));
  ------------------
  |  | 1003|  1.90k|#define mkString		Rf_mkString
  ------------------
 2859|  1.90k|    R_signalErrorCondition(cond, call);
 2860|  1.90k|    UNPROTECT(2); // not reached
  ------------------
  |  |  358|  1.90k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2861|  1.90k|}
R_setConditionField:
 2865|  3.81k|{
 2866|  3.81k|    PROTECT(cond);
  ------------------
  |  |  357|  3.81k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2867|  3.81k|    PROTECT(val);
  ------------------
  |  |  357|  3.81k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2868|       |    /**** maybe this should be a general set named vector elt */
 2869|       |    /**** or maybe it should check that cond inherits from "condition" */
 2870|       |    /**** or maybe just fill in the next empty slot and not take an index */
 2871|  3.81k|    if (TYPEOF(cond) != VECSXP)
  ------------------
  |  |  131|  3.81k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2871:9): [True: 0, False: 3.81k]
  ------------------
 2872|      0|	error("bad condition argument");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 2873|  3.81k|    if (idx < 0 || idx >= XLENGTH(cond))
  ------------------
  |  Branch (2873:9): [True: 0, False: 3.81k]
  |  Branch (2873:20): [True: 0, False: 3.81k]
  ------------------
 2874|      0|	error("bad field index");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 2875|  3.81k|    SEXP names = getAttrib(cond, R_NamesSymbol);
  ------------------
  |  |  924|  3.81k|#define getAttrib		Rf_getAttrib
  ------------------
 2876|  3.81k|    if (TYPEOF(names) != STRSXP || XLENGTH(names) != XLENGTH(cond))
  ------------------
  |  |  126|  7.63k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2876:9): [True: 0, False: 3.81k]
  |  Branch (2876:36): [True: 0, False: 3.81k]
  ------------------
 2877|      0|	error("bad names attribute on condition object");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 2878|  3.81k|    SET_VECTOR_ELT(cond, idx, val);
 2879|  3.81k|    SET_STRING_ELT(names, idx, mkChar(name));
  ------------------
  |  |  998|  3.81k|#define mkChar			Rf_mkChar
  ------------------
 2880|  3.81k|    UNPROTECT(2); /* cond, val */
  ------------------
  |  |  358|  3.81k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2881|  3.81k|}
R_InitConditions:
 3074|      2|{
 3075|      2|    R_protectStackOverflowError =
 3076|      2|	R_makeErrorCondition(R_NilValue, "stackOverflowError",
 3077|      2|			     "protectStackOverflowError", 0, PROT_SO_MSG);
  ------------------
  |  | 3068|      2|#define PROT_SO_MSG _("protect(): protection stack overflow")
  |  |  ------------------
  |  |  |  | 2531|      2|#   define _(String) gettext (String)
  |  |  ------------------
  ------------------
 3078|      2|    MARK_NOT_MUTABLE(R_protectStackOverflowError);
 3079|      2|    R_PreserveObject(R_protectStackOverflowError);
 3080|       |
 3081|      2|    R_expressionStackOverflowError =
 3082|      2|	R_makeErrorCondition(R_NilValue, "stackOverflowError",
 3083|      2|			     "expressionStackOverflowError", 0, EXPR_SO_MSG);
  ------------------
  |  | 3069|      2|#define EXPR_SO_MSG _("evaluation nested too deeply: infinite recursion / options(expressions=)?")
  |  |  ------------------
  |  |  |  | 2531|      2|#   define _(String) gettext (String)
  |  |  ------------------
  ------------------
 3084|      2|    MARK_NOT_MUTABLE(R_expressionStackOverflowError);
 3085|      2|    R_PreserveObject(R_expressionStackOverflowError);
 3086|       |
 3087|      2|    R_nodeStackOverflowError =
 3088|      2|	R_makeErrorCondition(R_NilValue, "stackOverflowError",
 3089|       |			     "nodeStackOverflowError", 0, NODE_SO_MSG);
  ------------------
  |  | 3070|      2|#define NODE_SO_MSG _("node stack overflow")
  |  |  ------------------
  |  |  |  | 2531|      2|#   define _(String) gettext (String)
  |  |  ------------------
  ------------------
 3090|      2|    MARK_NOT_MUTABLE(R_nodeStackOverflowError);
 3091|      2|    R_PreserveObject(R_nodeStackOverflowError);
 3092|      2|}
errors.c:RprintTrunc:
  370|   385k|{
  371|   385k|    if (truncated) {
  ------------------
  |  Branch (371:9): [True: 0, False: 385k]
  ------------------
  372|      0|	char *msg = _("[... truncated]");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  373|      0|	if (strlen(buf) + 1 + strlen(msg) < BUFSIZE) {
  ------------------
  |  |  368|      0|#define BUFSIZE 8192
  ------------------
  |  Branch (373:6): [True: 0, False: 0]
  ------------------
  374|      0|	    strcat(buf, " ");
  375|      0|	    strcat(buf, msg);
  376|      0|	}
  377|      0|    }
  378|   385k|}
errors.c:getCurrentCall:
  381|   386k|{
  382|   386k|    RCNTXT *c = R_GlobalContext;
  383|       |
  384|       |    /* This can be called before R_GlobalContext is defined, so... */
  385|       |    /* If profiling is on, this can be a CTXT_BUILTIN */
  386|       |
  387|   386k|    if (c && (c->callflag & CTXT_BUILTIN)) c = c->nextcontext;
  ------------------
  |  Branch (387:9): [True: 386k, False: 0]
  |  Branch (387:14): [True: 0, False: 386k]
  ------------------
  388|   386k|    if (c == R_GlobalContext && R_BCIntActive)
  ------------------
  |  Branch (388:9): [True: 386k, False: 0]
  |  Branch (388:33): [True: 385k, False: 440]
  ------------------
  389|   385k|	return R_getBCInterpreterExpression();
  390|    440|    else
  391|    440|	return c ? c->call : R_NilValue;
  ------------------
  |  Branch (391:9): [True: 440, False: 0]
  ------------------
  392|   386k|}
errors.c:verrorcall_dflt:
  758|  1.90k|{
  759|  1.90k|    if (allowedConstsChecks > 0) {
  ------------------
  |  Branch (759:9): [True: 1.01k, False: 891]
  ------------------
  760|  1.01k|	allowedConstsChecks--;
  761|  1.01k|	R_checkConstants(TRUE);
  762|  1.01k|    }
  763|       |
  764|  1.90k|    if (inError) {
  ------------------
  |  Branch (764:9): [True: 0, False: 1.90k]
  ------------------
  765|       |	/* fail-safe handler for recursive errors */
  766|      0|	if(inError == 3) {
  ------------------
  |  Branch (766:5): [True: 0, False: 0]
  ------------------
  767|       |	     /* Can REprintf generate an error? If so we should guard for it */
  768|      0|	    REprintf(_("Error during wrapup: "));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  769|       |	    /* this does NOT try to print the call since that could
  770|       |	       cause a cascade of error calls */
  771|      0|	    Rvsnprintf_mbcs(errbuf, sizeof(errbuf), format, ap);
  772|      0|	    REprintf("%s\n", errbuf);
  773|      0|	}
  774|      0|	if (R_Warnings != R_NilValue) {
  ------------------
  |  Branch (774:6): [True: 0, False: 0]
  ------------------
  775|      0|	    R_CollectWarnings = 0;
  776|      0|	    R_Warnings = R_NilValue;
  777|      0|	    REprintf(_("Lost warning messages\n"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  778|      0|	}
  779|      0|	REprintf(_("Error: no more error handlers available "
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  780|      0|		   "(recursive errors?); invoking 'abort' restart\n"));
  781|      0|	R_Expressions = R_Expressions_keep;
  782|      0|	jump_to_top_ex(FALSE, FALSE, FALSE, FALSE, FALSE);
  783|      0|    }
  784|       |
  785|       |    /* set up a context to restore inError value on exit */
  786|  1.90k|    RCNTXT cntxt;
  787|  1.90k|    begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
  ------------------
  |  | 1864|  1.90k|# define begincontext		Rf_begincontext
  ------------------
  788|  1.90k|		 R_NilValue, R_NilValue);
  789|  1.90k|    int oldInError;
  790|  1.90k|    cntxt.cend = &restore_inError;
  791|  1.90k|    cntxt.cenddata = &oldInError;
  792|  1.90k|    oldInError = inError;
  793|  1.90k|    inError = 1;
  794|       |
  795|       |    // For use with Rv?snprintf, which truncates at size - 1, hence the + 1
  796|  1.90k|    size_t msg_len = min(BUFSIZE, R_WarnLength) + 1;
  ------------------
  |  |   49|  1.90k|#define min(a, b) (a<b?a:b)
  |  |  ------------------
  |  |  |  Branch (49:20): [True: 0, False: 1.90k]
  |  |  ------------------
  ------------------
  797|       |
  798|  1.90k|    if(call != R_NilValue) {
  ------------------
  |  Branch (798:8): [True: 1.90k, False: 0]
  ------------------
  799|  1.90k|	char tmp[BUFSIZE], tmp2[BUFSIZE];
  800|  1.90k|	char *head = _("Error in "), *tail = "\n  ";
  ------------------
  |  | 2531|  1.90k|#   define _(String) gettext (String)
  ------------------
  801|  1.90k|	SEXP srcloc = R_NilValue; // -Wall
  802|  1.90k|	size_t len = 0;	// indicates if srcloc has been set
  803|  1.90k|	int protected = 0, show = 0;
  804|  1.90k|	SEXP opt = GetOption1(install("show.error.locations"));
  ------------------
  |  |  928|  1.90k|#define GetOption1		Rf_GetOption1
  ------------------
              	SEXP opt = GetOption1(install("show.error.locations"));
  ------------------
  |  |  934|  1.90k|#define install			Rf_install
  ------------------
  805|  1.90k|	if (length(opt) == 1 &&
  ------------------
  |  |  987|  1.90k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (805:6): [True: 0, False: 1.90k]
  ------------------
  806|      0|	    (asLogical(opt) == 1 ||
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
  |  Branch (806:7): [True: 0, False: 0]
  ------------------
  807|      0|	     (TYPEOF(opt) == STRSXP &&
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (807:8): [True: 0, False: 0]
  ------------------
  808|      0|	      pmatch(ScalarString(mkChar("top")), opt, 0))))
  ------------------
  |  | 1011|      0|#define pmatch			Rf_pmatch
  ------------------
              	      pmatch(ScalarString(mkChar("top")), opt, 0))))
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              	      pmatch(ScalarString(mkChar("top")), opt, 0))))
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  |  Branch (808:8): [True: 0, False: 0]
  ------------------
  809|      0|	    	show = 1;
  810|       |
  811|  1.90k|	const char *dcall = CHAR(STRING_ELT(deparse1s(call), 0));
  ------------------
  |  |  203|  1.90k|#define CHAR(x) R_CHAR(x)
  ------------------
  812|  1.90k|	Rsnprintf_mbcs(tmp2, BUFSIZE,  "%s", head);
  ------------------
  |  |  368|  1.90k|#define BUFSIZE 8192
  ------------------
  813|  1.90k|	if (show) {
  ------------------
  |  Branch (813:6): [True: 0, False: 1.90k]
  ------------------
  814|      0|	    PROTECT(srcloc = GetSrcLoc(R_GetCurrentSrcref(NA_INTEGER)));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  815|      0|	    protected++;
  816|      0|	    len = strlen(CHAR(STRING_ELT(srcloc, 0)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  817|      0|	    if (len)
  ------------------
  |  Branch (817:10): [True: 0, False: 0]
  ------------------
  818|      0|		Rsnprintf_mbcs(tmp2, BUFSIZE,  _("Error in %s (from %s) : "),
  ------------------
  |  |  368|      0|#define BUFSIZE 8192
  ------------------
              		Rsnprintf_mbcs(tmp2, BUFSIZE,  _("Error in %s (from %s) : "),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  819|      0|			       dcall, CHAR(STRING_ELT(srcloc, 0)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  820|      0|	}
  821|       |
  822|  1.90k|	Rvsnprintf_mbcs(tmp, max(msg_len - strlen(head), 0), format, ap);
  ------------------
  |  |   52|  1.90k|#define max(a, b) (a>b?a:b)
  |  |  ------------------
  |  |  |  Branch (52:20): [True: 1.90k, False: 0]
  |  |  ------------------
  ------------------
  823|  1.90k|	if (strlen(tmp2) + strlen(tail) + strlen(tmp) < BUFSIZE) {
  ------------------
  |  |  368|  1.90k|#define BUFSIZE 8192
  ------------------
  |  Branch (823:6): [True: 1.90k, False: 0]
  ------------------
  824|  1.90k|	    if(len) Rsnprintf_mbcs(errbuf, BUFSIZE,
  ------------------
  |  |  368|      0|#define BUFSIZE 8192
  ------------------
  |  Branch (824:9): [True: 0, False: 1.90k]
  ------------------
  825|      0|				   _("Error in %s (from %s) : "),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  826|      0|				   dcall, CHAR(STRING_ELT(srcloc, 0)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  827|  1.90k|	    else Rsnprintf_mbcs(errbuf, BUFSIZE,  _("Error in %s : "), dcall);
  ------------------
  |  |  368|  1.90k|#define BUFSIZE 8192
  ------------------
              	    else Rsnprintf_mbcs(errbuf, BUFSIZE,  _("Error in %s : "), dcall);
  ------------------
  |  | 2531|  1.90k|#   define _(String) gettext (String)
  ------------------
  828|  1.90k|	    if (mbcslocale) {
  ------------------
  |  Branch (828:10): [True: 0, False: 1.90k]
  ------------------
  829|      0|		int msgline1;
  830|       |		// tmp is local array, so OK to temporaily edit in place
  831|      0|		char *p = strchr(tmp, '\n');
  832|      0|		if (p) {
  ------------------
  |  Branch (832:7): [True: 0, False: 0]
  ------------------
  833|      0|		    *p = '\0';
  834|      0|		    msgline1 = wd(tmp);
  835|      0|		    *p = '\n';
  836|      0|		} else msgline1 = wd(tmp);
  837|       |		// gcc 8 warns here
  838|       |		// 'output may be truncated copying between 0 and 8191 bytes from a string of length 8191'
  839|       |		// but truncation is intentional.
  840|      0|		if (14 + wd(dcall) + msgline1 > LONGWARN)
  ------------------
  |  |   56|      0|#define LONGWARN 75
  ------------------
  |  Branch (840:7): [True: 0, False: 0]
  ------------------
  841|      0|		    ERRBUFCAT(tail);
  ------------------
  |  |  734|      0|#define ERRBUFCAT(txt) Rstrncat(errbuf, txt, BUFSIZE - strlen(errbuf))
  |  |  ------------------
  |  |  |  |  368|      0|#define BUFSIZE 8192
  |  |  ------------------
  ------------------
  842|  1.90k|	    } else {
  843|  1.90k|		size_t msgline1 = strlen(tmp);
  844|  1.90k|		const char *p = strchr(tmp, '\n');
  845|  1.90k|		if (p) msgline1 = (int)(p - tmp);
  ------------------
  |  Branch (845:7): [True: 0, False: 1.90k]
  ------------------
  846|  1.90k|		if (14 + strlen(dcall) + msgline1 > LONGWARN)
  ------------------
  |  |   56|  1.90k|#define LONGWARN 75
  ------------------
  |  Branch (846:7): [True: 1.37k, False: 539]
  ------------------
  847|  1.37k|		    ERRBUFCAT(tail);
  ------------------
  |  |  734|  1.37k|#define ERRBUFCAT(txt) Rstrncat(errbuf, txt, BUFSIZE - strlen(errbuf))
  |  |  ------------------
  |  |  |  |  368|  1.37k|#define BUFSIZE 8192
  |  |  ------------------
  ------------------
  848|  1.90k|	    }
  849|  1.90k|	    ERRBUFCAT(tmp);
  ------------------
  |  |  734|  1.90k|#define ERRBUFCAT(txt) Rstrncat(errbuf, txt, BUFSIZE - strlen(errbuf))
  |  |  ------------------
  |  |  |  |  368|  1.90k|#define BUFSIZE 8192
  |  |  ------------------
  ------------------
  850|  1.90k|	} else {
  851|      0|	    Rsnprintf_mbcs(errbuf, BUFSIZE, _("Error: "));
  ------------------
  |  |  368|      0|#define BUFSIZE 8192
  ------------------
              	    Rsnprintf_mbcs(errbuf, BUFSIZE, _("Error: "));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  852|      0|	    ERRBUFCAT(tmp);
  ------------------
  |  |  734|      0|#define ERRBUFCAT(txt) Rstrncat(errbuf, txt, BUFSIZE - strlen(errbuf))
  |  |  ------------------
  |  |  |  |  368|      0|#define BUFSIZE 8192
  |  |  ------------------
  ------------------
  853|      0|	}
  854|  1.90k|	UNPROTECT(protected);
  ------------------
  |  |  358|  1.90k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  855|  1.90k|    }
  856|      0|    else {
  857|      0|	Rsnprintf_mbcs(errbuf, BUFSIZE, _("Error: "));
  ------------------
  |  |  368|      0|#define BUFSIZE 8192
  ------------------
              	Rsnprintf_mbcs(errbuf, BUFSIZE, _("Error: "));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  858|      0|	char *p = errbuf + strlen(errbuf);
  859|      0|	Rvsnprintf_mbcs(p, max(msg_len - strlen(errbuf), 0), format, ap);
  ------------------
  |  |   52|      0|#define max(a, b) (a>b?a:b)
  |  |  ------------------
  |  |  |  Branch (52:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  860|      0|    }
  861|       |    /* Approximate truncation detection, may produce false positives.  Assumes
  862|       |       R_MB_CUR_MAX > 0. Note: approximation is fine, as the string may include
  863|       |       dots, anyway */
  864|  1.90k|    size_t nc = strlen(errbuf); // > 0, ignoring possibility of failure
  865|  1.90k|    if (nc > BUFSIZE - 1 - (R_MB_CUR_MAX - 1)) {
  ------------------
  |  |  368|  1.90k|#define BUFSIZE 8192
  ------------------
  |  Branch (865:9): [True: 0, False: 1.90k]
  ------------------
  866|      0|	size_t end = min(nc + 1, (BUFSIZE + 1) - 4); // room for "...\n\0"
  ------------------
  |  |   49|      0|#define min(a, b) (a<b?a:b)
  |  |  ------------------
  |  |  |  Branch (49:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  867|      0|	for(size_t i = end; i <= BUFSIZE + 1; ++i) errbuf[i - 1] = '\0';
  ------------------
  |  |  368|      0|#define BUFSIZE 8192
  ------------------
  |  Branch (867:22): [True: 0, False: 0]
  ------------------
  868|      0|	mbcsTruncateToValid(errbuf);
  869|      0|	ERRBUFCAT("...\n");
  ------------------
  |  |  734|      0|#define ERRBUFCAT(txt) Rstrncat(errbuf, txt, BUFSIZE - strlen(errbuf))
  |  |  ------------------
  |  |  |  |  368|      0|#define BUFSIZE 8192
  |  |  ------------------
  ------------------
  870|  1.90k|    } else {
  871|  1.90k|	char *p = errbuf + nc - 1;
  872|  1.90k|	if(*p != '\n') {
  ------------------
  |  Branch (872:5): [True: 1.90k, False: 0]
  ------------------
  873|  1.90k|	    ERRBUFCAT("\n");  // guaranteed to have room for this
  ------------------
  |  |  734|  1.90k|#define ERRBUFCAT(txt) Rstrncat(errbuf, txt, BUFSIZE - strlen(errbuf))
  |  |  ------------------
  |  |  |  |  368|  1.90k|#define BUFSIZE 8192
  |  |  ------------------
  ------------------
  874|  1.90k|	    ++nc;
  875|  1.90k|	}
  876|  1.90k|	if(R_ShowErrorCalls && call != R_NilValue) {  /* assume we want to avoid deparse */
  ------------------
  |  Branch (876:5): [True: 0, False: 1.90k]
  |  Branch (876:25): [True: 0, False: 0]
  ------------------
  877|      0|	    char *tr = R_ConciseTraceback(call, 0);
  878|      0|	    size_t nc_tr = strlen(tr);
  879|      0|	    if (nc_tr) {
  ------------------
  |  Branch (879:10): [True: 0, False: 0]
  ------------------
  880|      0|		char * call_trans = _("Calls:");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  881|      0|		if (nc_tr + nc + strlen(call_trans) + 2 < BUFSIZE + 1) {
  ------------------
  |  |  368|      0|#define BUFSIZE 8192
  ------------------
  |  Branch (881:7): [True: 0, False: 0]
  ------------------
  882|      0|		    ERRBUFCAT(call_trans);
  ------------------
  |  |  734|      0|#define ERRBUFCAT(txt) Rstrncat(errbuf, txt, BUFSIZE - strlen(errbuf))
  |  |  ------------------
  |  |  |  |  368|      0|#define BUFSIZE 8192
  |  |  ------------------
  ------------------
  883|      0|		    ERRBUFCAT(" ");
  ------------------
  |  |  734|      0|#define ERRBUFCAT(txt) Rstrncat(errbuf, txt, BUFSIZE - strlen(errbuf))
  |  |  ------------------
  |  |  |  |  368|      0|#define BUFSIZE 8192
  |  |  ------------------
  ------------------
  884|      0|		    ERRBUFCAT(tr);
  ------------------
  |  |  734|      0|#define ERRBUFCAT(txt) Rstrncat(errbuf, txt, BUFSIZE - strlen(errbuf))
  |  |  ------------------
  |  |  |  |  368|      0|#define BUFSIZE 8192
  |  |  ------------------
  ------------------
  885|      0|		    ERRBUFCAT("\n");
  ------------------
  |  |  734|      0|#define ERRBUFCAT(txt) Rstrncat(errbuf, txt, BUFSIZE - strlen(errbuf))
  |  |  ------------------
  |  |  |  |  368|      0|#define BUFSIZE 8192
  |  |  ------------------
  ------------------
  886|      0|		}
  887|      0|	    }
  888|      0|	}
  889|  1.90k|    }
  890|  1.90k|    if (R_ShowErrorMessages) REprintf("%s", errbuf);
  ------------------
  |  Branch (890:9): [True: 0, False: 1.90k]
  ------------------
  891|       |
  892|  1.90k|    if( R_ShowErrorMessages && R_CollectWarnings ) {
  ------------------
  |  Branch (892:9): [True: 0, False: 1.90k]
  |  Branch (892:32): [True: 0, False: 0]
  ------------------
  893|      0|	REprintf(_("In addition: "));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  894|      0|	PrintWarnings();
  ------------------
  |  | 1977|      0|# define PrintWarnings		Rf_PrintWarnings
  ------------------
  895|      0|    }
  896|       |
  897|  1.90k|    jump_to_top_ex(TRUE, TRUE, TRUE, TRUE, FALSE);
  898|       |
  899|       |    /* not reached */
  900|  1.90k|    endcontext(&cntxt);
  ------------------
  |  | 1895|  1.90k|# define endcontext		Rf_endcontext
  ------------------
  901|  1.90k|    inError = oldInError;
  902|  1.90k|}
errors.c:restore_inError:
  741|  3.81k|{
  742|  3.81k|    int *poldval = (int *) data;
  743|  3.81k|    inError = *poldval;
  744|  3.81k|    R_Expressions = R_Expressions_keep;
  745|  3.81k|}
errors.c:Rstrncat:
  341|  5.18k|{
  342|  5.18k|    size_t after;
  343|  5.18k|    size_t before = strlen(dest);
  344|       |
  345|  5.18k|    strncat(dest, src, n);
  346|       |
  347|  5.18k|    after = strlen(dest);
  348|  5.18k|    if (after - before == n)
  ------------------
  |  Branch (348:9): [True: 0, False: 5.18k]
  ------------------
  349|       |	/* the string may have been truncated, but we cannot know for sure
  350|       |	   because str may not be null terminated */
  351|      0|	mbcsTruncateToValid(dest + before);
  352|       |
  353|  5.18k|    return dest;
  354|  5.18k|}
errors.c:jump_to_top_ex:
  995|  1.90k|{
  996|  1.90k|    RCNTXT cntxt;
  997|  1.90k|    SEXP s;
  998|  1.90k|    int haveHandler, oldInError;
  999|       |
 1000|       |    /* set up a context to restore inError value on exit */
 1001|  1.90k|    begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
  ------------------
  |  | 1864|  1.90k|# define begincontext		Rf_begincontext
  ------------------
 1002|  1.90k|		 R_NilValue, R_NilValue);
 1003|  1.90k|    cntxt.cend = &restore_inError;
 1004|  1.90k|    cntxt.cenddata = &oldInError;
 1005|       |
 1006|  1.90k|    oldInError = inError;
 1007|       |
 1008|  1.90k|    haveHandler = FALSE;
 1009|       |
 1010|       |    /* don't use options("error") when handling a C stack overflow */
 1011|  1.90k|    if (R_OldCStackLimit == 0 && tryUserHandler && inError < 3) {
  ------------------
  |  Branch (1011:9): [True: 1.90k, False: 0]
  |  Branch (1011:34): [True: 1.90k, False: 0]
  |  Branch (1011:52): [True: 1.90k, False: 0]
  ------------------
 1012|  1.90k|	if (! inError)
  ------------------
  |  Branch (1012:6): [True: 0, False: 1.90k]
  ------------------
 1013|      0|	    inError = 1;
 1014|       |
 1015|       |	/* now see if options("error") is set */
 1016|  1.90k|	s = GetOption1(install("error"));
  ------------------
  |  |  928|  1.90k|#define GetOption1		Rf_GetOption1
  ------------------
              	s = GetOption1(install("error"));
  ------------------
  |  |  934|  1.90k|#define install			Rf_install
  ------------------
 1017|  1.90k|	haveHandler = ( s != R_NilValue );
 1018|  1.90k|	if (haveHandler) {
  ------------------
  |  Branch (1018:6): [True: 0, False: 1.90k]
  ------------------
 1019|      0|	    if( !isLanguage(s) &&  ! isExpression(s) )  /* shouldn't happen */
  ------------------
  |  |  950|      0|#define isLanguage		Rf_isLanguage
  ------------------
              	    if( !isLanguage(s) &&  ! isExpression(s) )  /* shouldn't happen */
  ------------------
  |  |  945|      0|#define isExpression		Rf_isExpression
  ------------------
  |  Branch (1019:10): [True: 0, False: 0]
  |  Branch (1019:29): [True: 0, False: 0]
  ------------------
 1020|      0|		REprintf(_("invalid option \"error\"\n"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1021|      0|	    else {
 1022|      0|		R_CheckStack();
 1023|      0|		inError = 3;
 1024|      0|		if (isLanguage(s))
  ------------------
  |  |  950|      0|#define isLanguage		Rf_isLanguage
  ------------------
  |  Branch (1024:7): [True: 0, False: 0]
  ------------------
 1025|      0|		    eval(s, R_GlobalEnv);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 1026|      0|		else /* expression */
 1027|      0|		    {
 1028|      0|			int i, n = LENGTH(s);
 1029|      0|			for (i = 0 ; i < n ; i++)
  ------------------
  |  Branch (1029:17): [True: 0, False: 0]
  ------------------
 1030|      0|			    eval(VECTOR_ELT(s, i), R_GlobalEnv);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 1031|      0|		    }
 1032|      0|		inError = oldInError;
 1033|      0|	    }
 1034|      0|	}
 1035|  1.90k|	inError = oldInError;
 1036|  1.90k|    }
 1037|       |
 1038|       |    /* print warnings if there are any left to be printed */
 1039|  1.90k|    if( processWarnings && R_CollectWarnings )
  ------------------
  |  Branch (1039:9): [True: 1.90k, False: 0]
  |  Branch (1039:28): [True: 0, False: 1.90k]
  ------------------
 1040|      0|	PrintWarnings();
  ------------------
  |  | 1977|      0|# define PrintWarnings		Rf_PrintWarnings
  ------------------
 1041|       |
 1042|       |    /* reset some stuff--not sure (all) this belongs here */
 1043|  1.90k|    if (resetConsole) {
  ------------------
  |  Branch (1043:9): [True: 1.90k, False: 0]
  ------------------
 1044|  1.90k|	R_ResetConsole();
 1045|  1.90k|	R_FlushConsole();
 1046|  1.90k|	R_ClearerrConsole();
 1047|  1.90k|	R_ParseError = 0;
 1048|  1.90k|	R_ParseErrorFile = NULL;
 1049|  1.90k|	R_ParseErrorMsg[0] = '\0';
 1050|  1.90k|    }
 1051|       |
 1052|       |    /*
 1053|       |     * Reset graphics state
 1054|       |     */
 1055|  1.90k|    GEonExit();
 1056|       |
 1057|       |    /* WARNING: If oldInError > 0 ABSOLUTELY NO ALLOCATION can be
 1058|       |       triggered after this point except whatever happens in writing
 1059|       |       the traceback.  The error could be an out of memory error and
 1060|       |       any allocation could result in an infinite-loop condition. All
 1061|       |       you can do is reset things and exit.  */
 1062|       |
 1063|       |    /* jump to a browser/try if one is on the stack */
 1064|  1.90k|    if (! ignoreRestartContexts)
  ------------------
  |  Branch (1064:9): [True: 1.90k, False: 0]
  ------------------
 1065|  1.90k|	try_jump_to_restart();
 1066|       |    /* at this point, i.e. if we have not exited in
 1067|       |       try_jump_to_restart, we are heading for R_ToplevelContext */
 1068|       |
 1069|       |    /* only run traceback if we are not going to bail out of a
 1070|       |       non-interactive session */
 1071|       |
 1072|  1.90k|    if (R_Interactive || haveHandler || R_isTRUE(GetOption1(install("catch.script.errors")))) {
  ------------------
  |  |  928|      0|#define GetOption1		Rf_GetOption1
  ------------------
                  if (R_Interactive || haveHandler || R_isTRUE(GetOption1(install("catch.script.errors")))) {
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
  |  Branch (1072:9): [True: 1.90k, False: 0]
  |  Branch (1072:26): [True: 0, False: 0]
  |  Branch (1072:41): [True: 0, False: 0]
  ------------------
 1073|       |	/* write traceback if requested, unless we're already doing it
 1074|       |	   or there is an inconsistency between inError and oldInError
 1075|       |	   (which should not happen) */
 1076|  1.90k|	if (traceback && inError < 2 && inError == oldInError) {
  ------------------
  |  Branch (1076:6): [True: 1.90k, False: 0]
  |  Branch (1076:19): [True: 1.90k, False: 0]
  |  Branch (1076:34): [True: 1.90k, False: 0]
  ------------------
 1077|  1.90k|	    inError = 2;
 1078|  1.90k|	    PROTECT(s = R_GetTracebackOnly(0));
  ------------------
  |  |  357|  1.90k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1079|  1.90k|	    SET_SYMVALUE(install(".Traceback"), s);
  ------------------
  |  |  934|  1.90k|#define install			Rf_install
  ------------------
 1080|       |	    /* should have been defineVar
 1081|       |	       setVar(install(".Traceback"), s, R_GlobalEnv); */
 1082|  1.90k|	    UNPROTECT(1);
  ------------------
  |  |  358|  1.90k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1083|  1.90k|	    inError = oldInError;
 1084|  1.90k|	}
 1085|  1.90k|    }
 1086|       |
 1087|       |    R_jumpctxt(R_ToplevelContext, 0, NULL);
 1088|  1.90k|}
errors.c:try_jump_to_restart:
  968|  1.90k|{
  969|  1.90k|    SEXP list;
  970|       |
  971|  1.90k|    for (list = R_RestartStack; list != R_NilValue; list = CDR(list)) {
  ------------------
  |  Branch (971:33): [True: 0, False: 1.90k]
  ------------------
  972|      0|	SEXP restart = CAR(list);
  973|      0|	if (TYPEOF(restart) == VECSXP && LENGTH(restart) > 1) {
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (973:6): [True: 0, False: 0]
  |  Branch (973:35): [True: 0, False: 0]
  ------------------
  974|      0|	    SEXP name = VECTOR_ELT(restart, 0);
  975|      0|	    if (TYPEOF(name) == STRSXP && LENGTH(name) == 1) {
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (975:10): [True: 0, False: 0]
  |  Branch (975:36): [True: 0, False: 0]
  ------------------
  976|      0|		const char *cname = CHAR(STRING_ELT(name, 0));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  977|      0|		if (! strcmp(cname, "browser") ||
  ------------------
  |  Branch (977:7): [True: 0, False: 0]
  ------------------
  978|      0|		    ! strcmp(cname, "tryRestart") ||
  ------------------
  |  Branch (978:7): [True: 0, False: 0]
  ------------------
  979|      0|		    ! strcmp(cname, "abort")) /**** move abort eventually? */
  ------------------
  |  Branch (979:7): [True: 0, False: 0]
  ------------------
  980|      0|		    invokeRestart(restart, R_NilValue);
  981|      0|	    }
  982|      0|	}
  983|      0|    }
  984|  1.90k|}
errors.c:determine_domain_gettext:
 1111|      8|{
 1112|      8|    const char *domain = "";
 1113|      8|    char *buf; // will be returned
 1114|       |
 1115|       |    /* If TYPEOF(cptr->callfun) == CLOSXP (not .Primitive("eval")),
 1116|       |     * ENCLOS(cptr->cloenv) is CLOENV(cptr->callfun) */
 1117|       |    /* R_findParentContext(cptr, 1)->cloenv == cptr->sysparent */
 1118|      8|    if(isNull(domain_)) {
  ------------------
  |  |  956|      8|#define isNull			Rf_isNull
  ------------------
  |  Branch (1118:8): [True: 8, False: 0]
  ------------------
 1119|      8|	RCNTXT *cptr;
 1120|      8|	GETT_PRINT(">> determine_domain_gettext(), first rho=%s\n", EncodeEnvironment(rho));
  ------------------
  |  | 1105|      8|# define GETT_PRINT(...) do {} while(0)
  |  |  ------------------
  |  |  |  Branch (1105:38): [Folded, False: 8]
  |  |  ------------------
  ------------------
 1121|       |
 1122|       |	/* stop() etc have internal call to .makeMessage */
 1123|       |	/* gettextf calls gettext */
 1124|       |
 1125|      8|	SEXP rho = R_EmptyEnv;
 1126|      8|	if(R_GlobalContext->callflag & CTXT_FUNCTION) {
  ------------------
  |  Branch (1126:5): [True: 8, False: 0]
  ------------------
 1127|      8|	    if(up) {
  ------------------
  |  Branch (1127:9): [True: 8, False: 0]
  ------------------
 1128|      8|		SEXP call = R_GlobalContext->call;
 1129|       |		/* The call is of the form
 1130|       |		   <symbol>(<symbol>, domain = domain [possible other argument]) */
 1131|      8|		rho =
 1132|      8|		    (isSymbol(CAR(call)) && (call = CDR(call)) != R_NilValue &&
  ------------------
  |  |  953|      8|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1132:8): [True: 8, False: 0]
  |  Branch (1132:31): [True: 8, False: 0]
  ------------------
 1133|      8|		     TAG(call) == R_NilValue && isSymbol(CAR(call)) &&
  ------------------
  |  |  953|      8|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1133:8): [True: 8, False: 0]
  |  Branch (1133:35): [True: 0, False: 8]
  ------------------
 1134|      0|		     (call = CDR(call)) != R_NilValue &&
  ------------------
  |  Branch (1134:8): [True: 0, False: 0]
  ------------------
 1135|      0|		     isSymbol(TAG(call)) && streql(CHAR(PRINTNAME(TAG(call))), "domain") &&
  ------------------
  |  |  953|      0|#define isSymbol		Rf_isSymbol
  ------------------
              		     isSymbol(TAG(call)) && streql(CHAR(PRINTNAME(TAG(call))), "domain") &&
  ------------------
  |  | 1498|      8|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1135:8): [True: 0, False: 0]
  ------------------
 1136|      0|		     isSymbol(CAR(call)) && streql(CHAR(PRINTNAME(CAR(call))), "domain") &&
  ------------------
  |  |  953|      0|#define isSymbol		Rf_isSymbol
  ------------------
              		     isSymbol(CAR(call)) && streql(CHAR(PRINTNAME(CAR(call))), "domain") &&
  ------------------
  |  | 1498|      8|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1136:8): [True: 0, False: 0]
  ------------------
 1137|      0|		     (cptr = R_findParentContext(R_GlobalContext, 1)))
  ------------------
  |  Branch (1137:8): [True: 0, False: 0]
  ------------------
 1138|      8|		    ? cptr->sysparent
 1139|      8|		    : R_GlobalContext->sysparent;
 1140|      8|	    }
 1141|      0|	    else
 1142|      0|		rho = R_GlobalContext->sysparent;
 1143|      8|	}
 1144|      8|	GETT_PRINT(" .. rho1_domain_ => rho=%s\n", EncodeEnvironment(rho));
  ------------------
  |  | 1105|      8|# define GETT_PRINT(...) do {} while(0)
  |  |  ------------------
  |  |  |  Branch (1105:38): [Folded, False: 8]
  |  |  ------------------
  ------------------
 1145|       |
 1146|      8|	SEXP ns = R_NilValue;
 1147|      8|	int cnt = 0;
 1148|     16|	    while(rho != R_EmptyEnv) {
  ------------------
  |  Branch (1148:12): [True: 16, False: 0]
  ------------------
 1149|     16|		if (rho == R_GlobalEnv) break;
  ------------------
  |  Branch (1149:7): [True: 0, False: 16]
  ------------------
 1150|     16|		else if (R_IsNamespaceEnv(rho)) {
  ------------------
  |  Branch (1150:12): [True: 8, False: 8]
  ------------------
 1151|      8|		    ns = R_NamespaceEnvSpec(rho);
 1152|      8|		    break;
 1153|      8|		}
 1154|      8|		if(++cnt <= 5 || cnt > 99) { // diagnose "inf." loop
  ------------------
  |  Branch (1154:6): [True: 8, False: 0]
  |  Branch (1154:20): [True: 0, False: 0]
  ------------------
 1155|      8|		    GETT_PRINT("  cnt=%4d, rho=%s\n", cnt, EncodeEnvironment(rho));
  ------------------
  |  | 1105|      8|# define GETT_PRINT(...) do {} while(0)
  |  |  ------------------
  |  |  |  Branch (1105:38): [Folded, False: 8]
  |  |  ------------------
  ------------------
 1156|      8|		    if(cnt > 111) break;
  ------------------
  |  Branch (1156:10): [True: 0, False: 8]
  ------------------
 1157|      8|		}
 1158|      8|		if(rho == ENCLOS(rho)) break; // *did* happen; now keep for safety
  ------------------
  |  Branch (1158:6): [True: 0, False: 8]
  ------------------
 1159|      8|		rho = ENCLOS(rho);
 1160|      8|	    }
 1161|      8|	if (!isNull(ns)) {
  ------------------
  |  |  956|      8|#define isNull			Rf_isNull
  ------------------
  |  Branch (1161:6): [True: 8, False: 0]
  ------------------
 1162|      8|	    PROTECT(ns);
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1163|      8|	    domain = translateChar(STRING_ELT(ns, 0));
  ------------------
  |  | 1037|      8|#define translateChar		Rf_translateChar
  ------------------
 1164|      8|	    if (strlen(domain)) {
  ------------------
  |  Branch (1164:10): [True: 8, False: 0]
  ------------------
 1165|      8|		size_t len = strlen(domain)+3;
 1166|      8|		buf = R_alloc(len, sizeof(char));
 1167|      8|		Rsnprintf_mbcs(buf, len, "R-%s", domain);
 1168|      8|		UNPROTECT(1); /* ns */
  ------------------
  |  |  358|      8|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1169|      8|		GETT_PRINT("Managed to determine 'domain' from environment as: '%s'\n", buf);
  ------------------
  |  | 1105|      8|# define GETT_PRINT(...) do {} while(0)
  |  |  ------------------
  |  |  |  Branch (1105:38): [Folded, False: 8]
  |  |  ------------------
  ------------------
 1170|      8|		return (const char*) buf;
 1171|      8|	    }
 1172|      0|	    UNPROTECT(1); /* ns */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1173|      0|	}
 1174|      0|	return NULL;
 1175|       |
 1176|      8|    } else if(isString(domain_)) {
  ------------------
  |  |  966|      0|#define isString		Rf_isString
  ------------------
  |  Branch (1176:15): [True: 0, False: 0]
  ------------------
 1177|      0|	domain = translateChar(STRING_ELT(domain_, 0));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
 1178|      0|	if (!strlen(domain))
  ------------------
  |  Branch (1178:6): [True: 0, False: 0]
  ------------------
 1179|      0|	    return NULL;
 1180|      0|	return domain;
 1181|       |
 1182|      0|    } else if(isLogical(domain_) && LENGTH(domain_) == 1 && LOGICAL(domain_)[0] == NA_LOGICAL)
  ------------------
  |  |  952|      0|#define isLogical		Rf_isLogical
  ------------------
                  } else if(isLogical(domain_) && LENGTH(domain_) == 1 && LOGICAL(domain_)[0] == NA_LOGICAL)
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1182:15): [True: 0, False: 0]
  |  Branch (1182:37): [True: 0, False: 0]
  |  Branch (1182:61): [True: 0, False: 0]
  ------------------
 1183|      0|	return NULL;
 1184|      0|    else error(_("invalid '%s' value"), "domain");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  else error(_("invalid '%s' value"), "domain");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1185|      8|}
errors.c:mkHandlerEntry:
 1665|  2.33k|{
 1666|  2.33k|    SEXP entry = allocVector(VECSXP, 5);
  ------------------
  |  |  875|  2.33k|#define allocVector		Rf_allocVector
  ------------------
                  SEXP entry = allocVector(VECSXP, 5);
  ------------------
  |  |  131|  2.33k|#define VECSXP	    19	  /* generic vectors */
  ------------------
 1667|  2.33k|    SET_VECTOR_ELT(entry, 0, klass);
 1668|  2.33k|    SET_VECTOR_ELT(entry, 1, parentenv);
 1669|  2.33k|    SET_VECTOR_ELT(entry, 2, handler);
 1670|  2.33k|    SET_VECTOR_ELT(entry, 3, rho);
 1671|  2.33k|    SET_VECTOR_ELT(entry, 4, result);
 1672|  2.33k|    SETLEVELS(entry, calling);
 1673|  2.33k|    return entry;
 1674|  2.33k|}
errors.c:vsignalWarning:
 1801|   385k|{
 1802|   385k|    char buf[BUFSIZE];
 1803|   385k|    SEXP hooksym, hcall, qcall, qfun;
 1804|       |
 1805|   385k|    hooksym = install(".signalSimpleWarning");
  ------------------
  |  |  934|   385k|#define install			Rf_install
  ------------------
 1806|   385k|    if (SYMVALUE(hooksym) != R_UnboundValue &&
  ------------------
  |  Branch (1806:9): [True: 385k, False: 0]
  ------------------
 1807|   385k|	SYMVALUE(R_QuoteSymbol) != R_UnboundValue) {
  ------------------
  |  Branch (1807:2): [True: 385k, False: 0]
  ------------------
 1808|   385k|	qfun = lang3(R_DoubleColonSymbol, R_BaseSymbol, R_QuoteSymbol);
  ------------------
  |  |  980|   385k|#define lang3			Rf_lang3
  ------------------
 1809|   385k|	PROTECT(qfun);
  ------------------
  |  |  357|   385k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1810|   385k|	PROTECT(qcall = LCONS(qfun, LCONS(call, R_NilValue)));
  ------------------
  |  |  357|   385k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1811|   385k|	PROTECT(hcall = LCONS(qcall, R_NilValue));
  ------------------
  |  |  357|   385k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1812|   385k|	Rvsnprintf_mbcs(buf, BUFSIZE - 1, format, ap);
  ------------------
  |  |  368|   385k|#define BUFSIZE 8192
  ------------------
 1813|   385k|	hcall = LCONS(mkString(buf), hcall);
  ------------------
  |  |  310|   385k|#define LCONS(a, b)	Rf_lcons((a), (b))		/* language lists */
  ------------------
 1814|   385k|	PROTECT(hcall = LCONS(hooksym, hcall));
  ------------------
  |  |  357|   385k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1815|   385k|	evalKeepVis(hcall, R_BaseEnv);
 1816|   385k|	UNPROTECT(4);
  ------------------
  |  |  358|   385k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1817|   385k|    }
 1818|      0|    else vwarningcall_dflt(call, format, ap);
 1819|   385k|}
errors.c:vwarningcall_dflt:
  445|   384k|{
  446|   384k|    int w;
  447|   384k|    SEXP names, s;
  448|   384k|    const char *dcall;
  449|   384k|    char buf[BUFSIZE];
  450|   384k|    RCNTXT *cptr;
  451|   384k|    RCNTXT cntxt;
  452|   384k|    size_t psize;
  453|   384k|    int pval;
  454|       |
  455|   384k|    if (inWarning)
  ------------------
  |  Branch (455:9): [True: 0, False: 384k]
  ------------------
  456|      0|	return;
  457|       |
  458|   384k|    s = GetOption1(install("warning.expression"));
  ------------------
  |  |  928|   384k|#define GetOption1		Rf_GetOption1
  ------------------
                  s = GetOption1(install("warning.expression"));
  ------------------
  |  |  934|   384k|#define install			Rf_install
  ------------------
  459|   384k|    if( s != R_NilValue ) {
  ------------------
  |  Branch (459:9): [True: 0, False: 384k]
  ------------------
  460|      0|	if( !isLanguage(s) &&  ! isExpression(s) )
  ------------------
  |  |  950|      0|#define isLanguage		Rf_isLanguage
  ------------------
              	if( !isLanguage(s) &&  ! isExpression(s) )
  ------------------
  |  |  945|      0|#define isExpression		Rf_isExpression
  ------------------
  |  Branch (460:6): [True: 0, False: 0]
  |  Branch (460:25): [True: 0, False: 0]
  ------------------
  461|      0|	    error(_("invalid option \"warning.expression\""));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid option \"warning.expression\""));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  462|      0|	cptr = R_GlobalContext;
  463|      0|	while ( !(cptr->callflag & CTXT_FUNCTION) && cptr->callflag )
  ------------------
  |  Branch (463:10): [True: 0, False: 0]
  |  Branch (463:47): [True: 0, False: 0]
  ------------------
  464|      0|	    cptr = cptr->nextcontext;
  465|      0|	evalKeepVis(s, cptr->cloenv);
  466|      0|	return;
  467|      0|    }
  468|       |
  469|   384k|    w = asInteger(GetOption1(install("warn")));
  ------------------
  |  |  885|   384k|#define asInteger		Rf_asInteger
  ------------------
                  w = asInteger(GetOption1(install("warn")));
  ------------------
  |  |  928|   384k|#define GetOption1		Rf_GetOption1
  ------------------
                  w = asInteger(GetOption1(install("warn")));
  ------------------
  |  |  934|   384k|#define install			Rf_install
  ------------------
  470|       |
  471|   384k|    if( w == NA_INTEGER ) /* set to a sensible value */
  ------------------
  |  |   56|   384k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (471:9): [True: 0, False: 384k]
  ------------------
  472|      0|	w = 0;
  473|       |
  474|   384k|    if( w <= 0 && immediateWarning ) w = 1;
  ------------------
  |  Branch (474:9): [True: 384k, False: 0]
  |  Branch (474:19): [True: 0, False: 384k]
  ------------------
  475|       |
  476|   384k|    if( w < 0 || inWarning || inError) /* ignore if w<0 or already in here*/
  ------------------
  |  Branch (476:9): [True: 384k, False: 0]
  |  Branch (476:18): [True: 0, False: 0]
  |  Branch (476:31): [True: 0, False: 0]
  ------------------
  477|   384k|	return;
  478|       |
  479|       |    /* set up a context which will restore inWarning if there is an exit */
  480|      0|    begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
  ------------------
  |  | 1864|      0|# define begincontext		Rf_begincontext
  ------------------
  481|      0|		 R_NilValue, R_NilValue);
  482|      0|    cntxt.cend = &reset_inWarning;
  483|       |
  484|      0|    inWarning = 1;
  485|       |
  486|      0|    if(w >= 2) { /* make it an error */
  ------------------
  |  Branch (486:8): [True: 0, False: 0]
  ------------------
  487|      0|	psize = min(BUFSIZE, R_WarnLength+1);
  ------------------
  |  |   49|      0|#define min(a, b) (a<b?a:b)
  |  |  ------------------
  |  |  |  Branch (49:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  488|      0|	pval = Rvsnprintf_mbcs(buf, psize, format, ap);
  489|      0|	RprintTrunc(buf, pval >= psize);
  490|      0|	inWarning = 0; /* PR#1570 */
  491|      0|	errorcall(call, _("(converted from warning) %s"), buf);
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("(converted from warning) %s"), buf);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  492|      0|    }
  493|      0|    else if(w == 1) {	/* print as they happen */
  ------------------
  |  Branch (493:13): [True: 0, False: 0]
  ------------------
  494|      0|	char *tr;
  495|      0|	if( call != R_NilValue ) {
  ------------------
  |  Branch (495:6): [True: 0, False: 0]
  ------------------
  496|      0|	    dcall = CHAR(STRING_ELT(deparse1s(call), false));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  497|      0|	} else dcall = "";
  498|      0|	psize = min(BUFSIZE, R_WarnLength+1);
  ------------------
  |  |   49|      0|#define min(a, b) (a<b?a:b)
  |  |  ------------------
  |  |  |  Branch (49:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  499|      0|	pval = Rvsnprintf_mbcs(buf, psize, format, ap);
  500|      0|	RprintTrunc(buf, pval >= psize);
  501|       |
  502|      0|	if(dcall[0] == '\0') REprintf(_("Warning:"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (502:5): [True: 0, False: 0]
  ------------------
  503|      0|	else {
  504|      0|	    REprintf(_("Warning in %s :"), dcall);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  505|       |	    // This did not allow for buf containing line breaks
  506|       |	    // We can put the first line on the same line as the warning
  507|       |	    // if it fits within LONGWARN.
  508|      0|	    char buf1[BUFSIZE];
  509|      0|	    strncpy(buf1, buf, BUFSIZE);
  ------------------
  |  |  368|      0|#define BUFSIZE 8192
  ------------------
  510|      0|	    char *p = strstr(buf1, "\n");
  511|      0|	    if(p) *p = '\0';
  ------------------
  |  Branch (511:9): [True: 0, False: 0]
  ------------------
  512|      0|	    if(!(noBreakWarning ||
  ------------------
  |  Branch (512:11): [True: 0, False: 0]
  ------------------
  513|      0|		 ( mbcslocale && (18 + wd(dcall) + wd(buf1) <= LONGWARN)) ||
  ------------------
  |  |   56|      0|#define LONGWARN 75
  ------------------
  |  Branch (513:6): [True: 0, False: 0]
  |  Branch (513:20): [True: 0, False: 0]
  ------------------
  514|      0|		 (!mbcslocale && (18 + strlen(dcall) + strlen(buf1) <= LONGWARN))))
  ------------------
  |  |   56|      0|#define LONGWARN 75
  ------------------
  |  Branch (514:5): [True: 0, False: 0]
  |  Branch (514:20): [True: 0, False: 0]
  ------------------
  515|      0|		REprintf("\n ");
  516|      0|	}
  517|      0|	REprintf(" %s\n", buf);
  518|      0|	if(R_ShowWarnCalls && call != R_NilValue) {
  ------------------
  |  Branch (518:5): [True: 0, False: 0]
  |  Branch (518:24): [True: 0, False: 0]
  ------------------
  519|      0|	    tr = R_ConciseTraceback(call, 0);
  520|      0|	    if (strlen(tr)) {REprintf(_("Calls:")); REprintf(" %s\n", tr);}
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (520:10): [True: 0, False: 0]
  ------------------
  521|      0|	}
  522|      0|    }
  523|      0|    else if(w == 0) {	/* collect them */
  ------------------
  |  Branch (523:13): [True: 0, False: 0]
  ------------------
  524|      0|	if(!R_CollectWarnings) setupwarnings();
  ------------------
  |  Branch (524:5): [True: 0, False: 0]
  ------------------
  525|      0|	if(R_CollectWarnings < R_nwarnings) {
  ------------------
  |  Branch (525:5): [True: 0, False: 0]
  ------------------
  526|      0|	    SET_VECTOR_ELT(R_Warnings, R_CollectWarnings, call);
  527|      0|	    psize = min(BUFSIZE, R_WarnLength+1);
  ------------------
  |  |   49|      0|#define min(a, b) (a<b?a:b)
  |  |  ------------------
  |  |  |  Branch (49:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  528|      0|	    pval = Rvsnprintf_mbcs(buf, psize, format, ap);
  529|      0|	    RprintTrunc(buf, pval >= psize);
  530|      0|	    if(R_ShowWarnCalls && call != R_NilValue) {
  ------------------
  |  Branch (530:9): [True: 0, False: 0]
  |  Branch (530:28): [True: 0, False: 0]
  ------------------
  531|      0|		char *tr =  R_ConciseTraceback(call, 0);
  532|      0|		size_t nc = strlen(tr);
  533|      0|		if (nc && nc + (int)strlen(buf) + 8 < BUFSIZE) {
  ------------------
  |  |  368|      0|#define BUFSIZE 8192
  ------------------
  |  Branch (533:7): [True: 0, False: 0]
  |  Branch (533:13): [True: 0, False: 0]
  ------------------
  534|      0|		    strcat(buf, "\n");
  535|      0|		    strcat(buf, _("Calls:"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  536|      0|		    strcat(buf, " ");
  537|      0|		    strcat(buf, tr);
  538|      0|		}
  539|      0|	    }
  540|      0|	    names = CAR(ATTRIB(R_Warnings));
  541|      0|	    SET_STRING_ELT(names, R_CollectWarnings++, mkChar(buf));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  542|      0|	}
  543|      0|    }
  544|       |    /* else:  w <= -1 */
  545|      0|    endcontext(&cntxt);
  ------------------
  |  | 1895|      0|# define endcontext		Rf_endcontext
  ------------------
  546|      0|    inWarning = 0;
  547|      0|}
errors.c:findConditionHandler:
 1876|   387k|{
 1877|   387k|    int i;
 1878|   387k|    SEXP list;
 1879|   387k|    SEXP classes = getAttrib(cond, R_ClassSymbol);
  ------------------
  |  |  924|   387k|#define getAttrib		Rf_getAttrib
  ------------------
 1880|       |
 1881|   387k|    if (TYPEOF(classes) != STRSXP)
  ------------------
  |  |  126|   387k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1881:9): [True: 0, False: 387k]
  ------------------
 1882|      0|	return R_NilValue;
 1883|       |
 1884|       |    /**** need some changes here to allow conditions to be S4 classes */
 1885|   387k|    for (list = R_HandlerStack; list != R_NilValue; list = CDR(list)) {
  ------------------
  |  Branch (1885:33): [True: 1.14k, False: 386k]
  ------------------
 1886|  1.14k|	SEXP entry = CAR(list);
 1887|  2.29k|	for (i = 0; i < LENGTH(classes); i++)
  ------------------
  |  Branch (1887:14): [True: 2.29k, False: 0]
  ------------------
 1888|  2.29k|	    if (! strcmp(CHAR(ENTRY_CLASS(entry)),
  ------------------
  |  |  203|  2.29k|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1888:10): [True: 1.14k, False: 1.14k]
  ------------------
 1889|  2.29k|			 CHAR(STRING_ELT(classes, i))))
  ------------------
  |  |  203|  2.29k|#define CHAR(x) R_CHAR(x)
  ------------------
 1890|  1.14k|		return list;
 1891|  1.14k|    }
 1892|   386k|    return R_NilValue;
 1893|   387k|}
errors.c:errorcall_dflt:
  905|  1.90k|{
  906|  1.90k|    va_list(ap);
  907|       |
  908|  1.90k|    va_start(ap, format);
  909|  1.90k|    verrorcall_dflt(call, format, ap);
  910|       |    va_end(ap);
  911|  1.90k|}
errors.c:warningcall_dflt:
  550|   384k|{
  551|   384k|    va_list(ap);
  552|       |
  553|   384k|    va_start(ap, format);
  554|   384k|    vwarningcall_dflt(call, format, ap);
  555|       |    va_end(ap);
  556|   384k|}
errors.c:invokeRestart:
 2105|  1.14k|{
 2106|  1.14k|    SEXP exit = RESTART_EXIT(r);
  ------------------
  |  | 2102|  1.14k|#define RESTART_EXIT(r) VECTOR_ELT(r, 1)
  ------------------
 2107|       |
 2108|  1.14k|    if (exit == R_NilValue) {
  ------------------
  |  Branch (2108:9): [True: 0, False: 1.14k]
  ------------------
 2109|      0|	R_RestartStack = R_NilValue;
 2110|      0|	jump_to_toplevel();
  ------------------
  |  |  110|      0|# define jump_to_toplevel	Rf_jump_to_toplevel
  ------------------
 2111|      0|    }
 2112|  1.14k|    else {
 2113|  2.29k|	for (; R_RestartStack != R_NilValue;
  ------------------
  |  Branch (2113:9): [True: 1.14k, False: 1.14k]
  ------------------
 2114|  1.14k|	     R_RestartStack = CDR(R_RestartStack))
 2115|  1.14k|	    if (exit == RESTART_EXIT(CAR(R_RestartStack))) {
  ------------------
  |  | 2102|  1.14k|#define RESTART_EXIT(r) VECTOR_ELT(r, 1)
  ------------------
  |  Branch (2115:10): [True: 1.14k, False: 0]
  ------------------
 2116|  1.14k|		R_RestartStack = CDR(R_RestartStack);
 2117|  1.14k|		if (TYPEOF(exit) == EXTPTRSXP) {
  ------------------
  |  |  134|  1.14k|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (2117:7): [True: 0, False: 1.14k]
  ------------------
 2118|      0|		    RCNTXT *c = (RCNTXT *) R_ExternalPtrAddr(exit);
 2119|      0|		    R_JumpToContext(c, CTXT_RESTART, R_RestartToken);
 2120|      0|		}
 2121|  1.14k|		else findcontext(CTXT_FUNCTION, exit, arglist);
  ------------------
  |  | 1901|  1.14k|# define findcontext		Rf_findcontext
  ------------------
 2122|  1.14k|	    }
 2123|  1.14k|	error(_("restart not on stack"));
  ------------------
  |  |   88|  1.14k|#define error Rf_error
  ------------------
              	error(_("restart not on stack"));
  ------------------
  |  | 2531|  1.14k|#   define _(String) gettext (String)
  ------------------
 2124|  1.14k|    }
 2125|  1.14k|}
errors.c:evalKeepVis:
   41|   385k|{
   42|   385k|    Rboolean oldvis = R_Visible;
   43|   385k|    SEXP val = eval(e, rho);
  ------------------
  |  |  913|   385k|#define eval			Rf_eval
  ------------------
   44|   385k|    R_Visible = oldvis;
   45|   385k|    return val;
   46|   385k|}
errors.c:R_signalCondition:
 2657|  3.81k|{
 2658|  3.81k|    if (restoreHandlerStack) {
  ------------------
  |  Branch (2658:9): [True: 1.90k, False: 1.90k]
  ------------------
 2659|  1.90k|	SEXP oldstack = R_HandlerStack;
 2660|  1.90k|	PROTECT(oldstack);
  ------------------
  |  |  357|  1.90k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2661|  1.90k|	R_signalCondition(cond, call, FALSE, exitOnly);
 2662|  1.90k|	R_HandlerStack = oldstack;
 2663|  1.90k|	UNPROTECT(1); /* oldstack */
  ------------------
  |  |  358|  1.90k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2664|  1.90k|    }
 2665|  1.90k|    else {
 2666|  1.90k|	SEXP list;
 2667|  1.90k|	while ((list = findConditionHandler(cond)) != R_NilValue) {
  ------------------
  |  Branch (2667:9): [True: 0, False: 1.90k]
  ------------------
 2668|      0|	    SEXP entry = CAR(list);
 2669|      0|	    R_HandlerStack = CDR(list);
 2670|      0|	    if (IS_CALLING_ENTRY(entry)) {
  ------------------
  |  | 1677|      0|#define IS_CALLING_ENTRY(e) LEVELS(e)
  |  |  ------------------
  |  |  |  Branch (1677:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2671|      0|		SEXP h = ENTRY_HANDLER(entry);
  ------------------
  |  | 1680|      0|#define ENTRY_HANDLER(e) VECTOR_ELT(e, 2)
  ------------------
 2672|      0|		if (h == R_RestartToken)
  ------------------
  |  Branch (2672:7): [True: 0, False: 0]
  ------------------
 2673|      0|		    break;
 2674|      0|		else if (! exitOnly) {
  ------------------
  |  Branch (2674:12): [True: 0, False: 0]
  ------------------
 2675|      0|		    R_CheckStack();
 2676|      0|		    SEXP hcall = LCONS(h, LCONS(cond, R_NilValue));
  ------------------
  |  |  310|      0|#define LCONS(a, b)	Rf_lcons((a), (b))		/* language lists */
  ------------------
 2677|      0|		    PROTECT(hcall);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2678|      0|		    eval(hcall, R_GlobalEnv);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 2679|      0|		    UNPROTECT(1); /* hcall */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2680|      0|		}
 2681|      0|	    }
 2682|      0|	    else gotoExitingHandler(cond, call, entry);
 2683|      0|	}
 2684|  1.90k|    }
 2685|  3.81k|}

Rf_check_stack_balance:
  940|  1.17M|{
  941|  1.17M|    if(save == R_PPStackTop) return;
  ------------------
  |  Branch (941:8): [True: 1.17M, False: 0]
  ------------------
  942|      0|    REprintf("Warning: stack imbalance in '%s', %d then %d\n",
  943|      0|	     PRIMNAME(op), save, R_PPStackTop);
  ------------------
  |  | 1346|      0|#define PRIMNAME(x)	(R_FunTab[PRIMOFFSET(x)].name)
  ------------------
  944|      0|}
R_BCProtReset:
 1053|   388k|{
 1054|   388k|    DECLNK_stack(ptop);
 1055|   388k|}
Rf_eval:
 1093|  9.40M|{
 1094|  9.40M|    SEXP op, tmp;
 1095|  9.40M|    static int evalcount = 0;
 1096|       |
 1097|  9.40M|    R_Visible = TRUE;
 1098|       |
 1099|       |    /* this is needed even for self-evaluating objects or something like
 1100|       |       'while (TRUE) NULL' will not be interruptable */
 1101|  9.40M|    if (++evalcount > EVAL_COUNT_DELTA) { /* was 100 before 2.8.0 */
  ------------------
  |  |   44|  9.40M|#define EVAL_COUNT_DELTA 10
  ------------------
  |  Branch (1101:9): [True: 854k, False: 8.54M]
  ------------------
 1102|   854k|	R_CheckUserInterrupt();
 1103|   854k|#ifndef IMMEDIATE_FINALIZERS
 1104|       |	/* finalizers are run here since this should only be called at
 1105|       |	   points where running arbitrary code should be safe */
 1106|   854k|	R_RunPendingFinalizers();
 1107|   854k|#endif
 1108|   854k|	evalcount = 0 ;
 1109|   854k|    }
 1110|       |
 1111|       |    /* handle self-evaluating objects with minimal overhead */
 1112|  9.40M|    switch (TYPEOF(e)) {
 1113|   774k|    case NILSXP:
  ------------------
  |  |  111|   774k|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1113:5): [True: 774k, False: 8.62M]
  ------------------
 1114|   774k|    case LISTSXP:
  ------------------
  |  |  113|   774k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1114:5): [True: 0, False: 9.40M]
  ------------------
 1115|   788k|    case LGLSXP:
  ------------------
  |  |  121|   788k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1115:5): [True: 13.4k, False: 9.38M]
  ------------------
 1116|   800k|    case INTSXP:
  ------------------
  |  |  123|   800k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1116:5): [True: 12.0k, False: 9.38M]
  ------------------
 1117|   807k|    case REALSXP:
  ------------------
  |  |  124|   807k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1117:5): [True: 7.05k, False: 9.39M]
  ------------------
 1118|  2.35M|    case STRSXP:
  ------------------
  |  |  126|  2.35M|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1118:5): [True: 1.55M, False: 7.84M]
  ------------------
 1119|  2.35M|    case CPLXSXP:
  ------------------
  |  |  125|  2.35M|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1119:5): [True: 0, False: 9.40M]
  ------------------
 1120|  2.35M|    case RAWSXP:
  ------------------
  |  |  136|  2.35M|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1120:5): [True: 0, False: 9.40M]
  ------------------
 1121|  2.35M|    case OBJSXP:
  ------------------
  |  |  137|  2.35M|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (1121:5): [True: 0, False: 9.40M]
  ------------------
 1122|  2.35M|    case SPECIALSXP:
  ------------------
  |  |  118|  2.35M|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (1122:5): [True: 0, False: 9.40M]
  ------------------
 1123|  2.35M|    case BUILTINSXP:
  ------------------
  |  |  119|  2.35M|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (1123:5): [True: 0, False: 9.40M]
  ------------------
 1124|  2.35M|    case ENVSXP:
  ------------------
  |  |  115|  2.35M|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (1124:5): [True: 0, False: 9.40M]
  ------------------
 1125|  2.36M|    case CLOSXP:
  ------------------
  |  |  114|  2.36M|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1125:5): [True: 4.40k, False: 9.39M]
  ------------------
 1126|  2.36M|    case VECSXP:
  ------------------
  |  |  131|  2.36M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1126:5): [True: 1.24k, False: 9.40M]
  ------------------
 1127|  2.36M|    case EXTPTRSXP:
  ------------------
  |  |  134|  2.36M|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (1127:5): [True: 0, False: 9.40M]
  ------------------
 1128|  2.36M|    case WEAKREFSXP:
  ------------------
  |  |  135|  2.36M|#define WEAKREFSXP  23    /* weak reference */
  ------------------
  |  Branch (1128:5): [True: 0, False: 9.40M]
  ------------------
 1129|  2.36M|    case EXPRSXP:
  ------------------
  |  |  132|  2.36M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1129:5): [True: 0, False: 9.40M]
  ------------------
 1130|       |	/* Make sure constants in expressions are NAMED before being
 1131|       |	   used as values.  Setting NAMED to NAMEDMAX makes sure weird calls
 1132|       |	   to replacement functions won't modify constants in
 1133|       |	   expressions.  */
 1134|  2.36M|	ENSURE_NAMEDMAX(e);
 1135|  2.36M|	return e;
 1136|  7.03M|    default: break;
  ------------------
  |  Branch (1136:5): [True: 7.03M, False: 2.36M]
  ------------------
 1137|  9.40M|    }
 1138|       |
 1139|  7.03M|    int bcintactivesave = R_BCIntActive;
 1140|  7.03M|    R_BCIntActive = 0;
 1141|       |
 1142|  7.03M|    if (!rho)
  ------------------
  |  Branch (1142:9): [True: 0, False: 7.03M]
  ------------------
 1143|      0|	error("'rho' cannot be C NULL: detected in C-level eval");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 1144|  7.03M|    if (!isEnvironment(rho))
  ------------------
  |  |  944|  7.03M|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (1144:9): [True: 0, False: 7.03M]
  ------------------
 1145|      0|	error("'rho' must be an environment not %s: detected in C-level eval",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 1146|      0|	      R_typeToChar(rho));
 1147|       |
 1148|       |    /* Save the current srcref context. */
 1149|       |
 1150|  7.03M|    SEXP srcrefsave = R_Srcref;
 1151|       |
 1152|       |    /* The use of depthsave below is necessary because of the
 1153|       |       possibility of non-local returns from evaluation.  Without this
 1154|       |       an "expression too complex error" is quite likely. */
 1155|       |
 1156|  7.03M|    int depthsave = R_EvalDepth;
 1157|  7.03M|    INCREMENT_EVAL_DEPTH();
  ------------------
  |  | 1067|  7.03M|#define INCREMENT_EVAL_DEPTH() do {		\
  |  | 1068|  7.03M|	R_EvalDepth++;				\
  |  | 1069|  7.03M|	if (R_EvalDepth > R_Expressions)	\
  |  |  ------------------
  |  |  |  Branch (1069:6): [True: 0, False: 7.03M]
  |  |  ------------------
  |  | 1070|  7.03M|	    handle_eval_depth_overflow();	\
  |  | 1071|  7.03M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (1071:14): [Folded, False: 7.03M]
  |  |  ------------------
  ------------------
 1158|  7.03M|    R_CheckStack();
 1159|       |
 1160|  7.03M|    tmp = R_NilValue;		/* -Wall */
 1161|       |#ifdef Win32
 1162|       |    /* This is an inlined version of Rwin_fpreset (src/gnuwin/extra.c)
 1163|       |       and resets the precision, rounding and exception modes of a ix86
 1164|       |       fpu.
 1165|       |     */
 1166|       |# if (defined(__i386) || defined(__x86_64))
 1167|       |    __asm__ ( "fninit" );
 1168|       |# elif defined(__aarch64__)
 1169|       |    __asm__ volatile("msr fpcr, %0" : : "r"(0LL));
 1170|       |# else
 1171|       |    _fpreset();
 1172|       |# endif
 1173|       |#endif
 1174|       |
 1175|  7.03M|    switch (TYPEOF(e)) {
 1176|  1.56M|    case BCODESXP:
  ------------------
  |  |  133|  1.56M|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (1176:5): [True: 1.56M, False: 5.47M]
  ------------------
 1177|  1.56M|	tmp = bcEval(e, rho);
 1178|  1.56M|	    break;
 1179|  1.17M|    case SYMSXP:
  ------------------
  |  |  112|  1.17M|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1179:5): [True: 1.17M, False: 5.85M]
  ------------------
 1180|  1.17M|	if (e == R_DotsSymbol)
  ------------------
  |  Branch (1180:6): [True: 0, False: 1.17M]
  ------------------
 1181|      0|	    error(_("'...' used in an incorrect context"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("'...' used in an incorrect context"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1182|  1.17M|	if( DDVAL(e) )
  ------------------
  |  Branch (1182:6): [True: 0, False: 1.17M]
  ------------------
 1183|      0|	    tmp = ddfindVar(e,rho);
  ------------------
  |  | 1880|      0|# define ddfindVar		Rf_ddfindVar
  ------------------
 1184|  1.17M|	else
 1185|  1.17M|	    tmp = R_findVar(e, rho);
 1186|  1.17M|	if (tmp == R_UnboundValue)
  ------------------
  |  Branch (1186:6): [True: 0, False: 1.17M]
  ------------------
 1187|      0|	    R_ObjectNotFoundError(e, getLexicalCall(rho), NULL);
 1188|  1.17M|	else if (tmp == R_MissingArg) {
  ------------------
  |  Branch (1188:11): [True: 0, False: 1.17M]
  ------------------
 1189|       |	    /* the error signaled here for a missing ..d matches the one
 1190|       |	       signaled in getvar() for byte compiled code, but ...elt()
 1191|       |	       signals a slightly different error (see PR18661) */
 1192|      0|	    R_MissingArgError(e, getLexicalCall(rho), "evalError");
 1193|      0|	}
 1194|  1.17M|	else if (TYPEOF(tmp) == PROMSXP) {
  ------------------
  |  |  116|  1.17M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (1194:11): [True: 1.16M, False: 14.1k]
  ------------------
 1195|  1.16M|	    ENSURE_PROMISE_IS_EVALUATED(tmp);
  ------------------
  |  |  946|  1.16M|#define ENSURE_PROMISE_IS_EVALUATED(x) do {	\
  |  |  947|  1.16M|	SEXP __x__ = (x);			\
  |  |  948|  1.16M|	if (! PROMISE_IS_EVALUATED(__x__))	\
  |  |  ------------------
  |  |  |  Branch (948:6): [True: 390k, False: 774k]
  |  |  ------------------
  |  |  949|  1.16M|	    forcePromise(__x__);		\
  |  |  950|  1.16M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (950:14): [Folded, False: 1.16M]
  |  |  ------------------
  ------------------
 1196|  1.16M|	    tmp = PRVALUE(tmp);
 1197|  1.16M|	}
 1198|  14.1k|	else ENSURE_NAMED(tmp); /* needed for .Last.value - LT */
 1199|  1.17M|	break;
 1200|  2.72M|    case PROMSXP:
  ------------------
  |  |  116|  2.72M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (1200:5): [True: 2.72M, False: 4.31M]
  ------------------
 1201|  2.72M|	ENSURE_PROMISE_IS_EVALUATED(e);
  ------------------
  |  |  946|  2.72M|#define ENSURE_PROMISE_IS_EVALUATED(x) do {	\
  |  |  947|  2.72M|	SEXP __x__ = (x);			\
  |  |  948|  2.72M|	if (! PROMISE_IS_EVALUATED(__x__))	\
  |  |  ------------------
  |  |  |  Branch (948:6): [True: 1.16M, False: 1.55M]
  |  |  ------------------
  |  |  949|  2.72M|	    forcePromise(__x__);		\
  |  |  950|  2.72M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (950:14): [Folded, False: 2.72M]
  |  |  ------------------
  ------------------
 1202|  2.72M|	tmp = PRVALUE(e);
 1203|       |	/* This does _not_ change the value of NAMED on the value tmp,
 1204|       |	   in contrast to the handling of promises bound to symbols in
 1205|       |	   the SYMSXP case above.  The reason is that one (typically
 1206|       |	   the only) place promises appear in source code is as
 1207|       |	   wrappers for the RHS value in replacement function calls for
 1208|       |	   complex assignment expression created in applydefine().  If
 1209|       |	   the RHS value is freshly created it will have NAMED = 0 and
 1210|       |	   we want it to stay that way or a BUILTIN or SPECIAL
 1211|       |	   replacement function might have to duplicate the value
 1212|       |	   before inserting it to avoid creating cycles.  (Closure
 1213|       |	   replacement functions will get the value via the SYMSXP case
 1214|       |	   from evaluating their 'value' argument so the value will
 1215|       |	   end up getting duplicated if NAMED > 1.) LT */
 1216|  2.72M|	break;
 1217|  1.57M|    case LANGSXP:
  ------------------
  |  |  117|  1.57M|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (1217:5): [True: 1.57M, False: 5.46M]
  ------------------
 1218|  1.57M|	if (TYPEOF(CAR(e)) == SYMSXP) {
  ------------------
  |  |  112|  1.57M|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1218:6): [True: 1.18M, False: 389k]
  ------------------
 1219|       |	    /* This will throw an error if the function is not found */
 1220|  1.18M|	    SEXP ecall = e;
 1221|       |
 1222|       |	    /* This picks the correct/better error expression for
 1223|       |	       replacement calls running in the AST interpreter. */
 1224|  1.18M|	    if (R_GlobalContext != NULL &&
  ------------------
  |  Branch (1224:10): [True: 1.18M, False: 0]
  ------------------
 1225|  1.18M|		    (R_GlobalContext->callflag == CTXT_CCODE))
  ------------------
  |  Branch (1225:7): [True: 902, False: 1.18M]
  ------------------
 1226|    902|		ecall = R_GlobalContext->call;
 1227|  1.18M|	    PROTECT(op = findFun3(CAR(e), rho, ecall));
  ------------------
  |  |  357|  1.18M|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1228|  1.18M|	} else
 1229|   389k|	    PROTECT(op = eval(CAR(e), rho));
  ------------------
  |  |  357|   389k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1230|       |
 1231|  1.57M|	if(RTRACE(op) && R_current_trace_state()) {
  ------------------
  |  Branch (1231:5): [True: 0, False: 1.57M]
  |  Branch (1231:19): [True: 0, False: 0]
  ------------------
 1232|      0|	    Rprintf("trace: ");
 1233|      0|	    PrintValue(e);
  ------------------
  |  | 1013|      0|#define PrintValue		Rf_PrintValue
  ------------------
 1234|      0|	}
 1235|  1.57M|	if (TYPEOF(op) == SPECIALSXP) {
  ------------------
  |  |  118|  1.57M|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (1235:6): [True: 1.16M, False: 404k]
  ------------------
 1236|  1.16M|	    int save = R_PPStackTop, flag = PRIMPRINT(op);
  ------------------
  |  | 1350|  1.16M|#define PRIMPRINT(x)	(((R_FunTab[PRIMOFFSET(x)].eval)/100)%10)
  |  |  ------------------
  |  |  |  |  913|  1.16M|#define eval			Rf_eval
  |  |  ------------------
  ------------------
 1237|  1.16M|	    const void *vmax = vmaxget();
 1238|  1.16M|	    PROTECT(e);
  ------------------
  |  |  357|  1.16M|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1239|  1.16M|	    R_Visible = flag != 1;
 1240|  1.16M|	    tmp = PRIMFUN(op) (e, op, CDR(e), rho);
  ------------------
  |  | 1345|  1.16M|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 1241|       |#ifdef CHECK_VISIBILITY
 1242|       |	    if(flag < 2 && R_Visible == flag) {
 1243|       |		char *nm = PRIMNAME(op);
 1244|       |		if(strcmp(nm, "for")
 1245|       |		   && strcmp(nm, "repeat") && strcmp(nm, "while")
 1246|       |		   && strcmp(nm, "[[<-") && strcmp(nm, "on.exit"))
 1247|       |		    printf("vis: special %s\n", nm);
 1248|       |	    }
 1249|       |#endif
 1250|  1.16M|	    if (flag < 2) R_Visible = flag != 1;
  ------------------
  |  Branch (1250:10): [True: 778k, False: 387k]
  ------------------
 1251|  1.16M|	    UNPROTECT(1);
  ------------------
  |  |  358|  1.16M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1252|  1.16M|	    check_stack_balance(op, save);
  ------------------
  |  | 1866|  1.16M|# define check_stack_balance	Rf_check_stack_balance
  ------------------
 1253|  1.16M|	    vmaxset(vmax);
 1254|  1.16M|	}
 1255|   404k|	else if (TYPEOF(op) == BUILTINSXP) {
  ------------------
  |  |  119|   404k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (1255:11): [True: 5.43k, False: 399k]
  ------------------
 1256|  5.43k|	    int save = R_PPStackTop, flag = PRIMPRINT(op);
  ------------------
  |  | 1350|  5.43k|#define PRIMPRINT(x)	(((R_FunTab[PRIMOFFSET(x)].eval)/100)%10)
  |  |  ------------------
  |  |  |  |  913|  5.43k|#define eval			Rf_eval
  |  |  ------------------
  ------------------
 1257|  5.43k|	    const void *vmax = vmaxget();
 1258|  5.43k|	    RCNTXT cntxt;
 1259|  5.43k|	    PROTECT(tmp = evalList(CDR(e), rho, e, 0));
  ------------------
  |  |  357|  5.43k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1260|  5.43k|	    if (flag < 2) R_Visible = flag != 1;
  ------------------
  |  Branch (1260:10): [True: 4.63k, False: 803]
  ------------------
 1261|       |	    /* We used to insert a context only if profiling,
 1262|       |	       but helps for tracebacks on .C etc. */
 1263|  5.43k|	    if (R_Profiling || (PPINFO(op).kind == PP_FOREIGN)) {
  ------------------
  |  | 1349|  4.63k|#define PPINFO(x)	(R_FunTab[PRIMOFFSET(x)].gram)
  ------------------
  |  Branch (1263:10): [True: 803, False: 4.63k]
  |  Branch (1263:25): [True: 0, False: 4.63k]
  ------------------
 1264|      0|		SEXP oldref = R_Srcref;
 1265|      0|		begincontext(&cntxt, CTXT_BUILTIN, e,
  ------------------
  |  | 1864|      0|# define begincontext		Rf_begincontext
  ------------------
 1266|      0|			     R_BaseEnv, R_BaseEnv, R_NilValue, R_NilValue);
 1267|      0|		R_Srcref = NULL;
 1268|      0|		tmp = PRIMFUN(op) (e, op, tmp, rho);
  ------------------
  |  | 1345|      0|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 1269|      0|		R_Srcref = oldref;
 1270|      0|		endcontext(&cntxt);
  ------------------
  |  | 1895|      0|# define endcontext		Rf_endcontext
  ------------------
 1271|  5.43k|	    } else {
 1272|  5.43k|		tmp = PRIMFUN(op) (e, op, tmp, rho);
  ------------------
  |  | 1345|  5.43k|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 1273|  5.43k|	    }
 1274|       |#ifdef CHECK_VISIBILITY
 1275|       |	    if(flag < 2 && R_Visible == flag) {
 1276|       |		char *nm = PRIMNAME(op);
 1277|       |		printf("vis: builtin %s\n", nm);
 1278|       |	    }
 1279|       |#endif
 1280|  5.43k|	    if (flag < 2) R_Visible = flag != 1;
  ------------------
  |  Branch (1280:10): [True: 4.63k, False: 803]
  ------------------
 1281|  5.43k|	    UNPROTECT(1);
  ------------------
  |  |  358|  5.43k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1282|  5.43k|	    check_stack_balance(op, save);
  ------------------
  |  | 1866|  5.43k|# define check_stack_balance	Rf_check_stack_balance
  ------------------
 1283|  5.43k|	    vmaxset(vmax);
 1284|  5.43k|	}
 1285|   399k|	else if (TYPEOF(op) == CLOSXP) {
  ------------------
  |  |  114|   399k|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1285:11): [True: 398k, False: 911]
  ------------------
 1286|   398k|	    SEXP pargs = promiseArgs(CDR(e), rho);
  ------------------
  |  | 1978|   398k|# define promiseArgs		Rf_promiseArgs
  ------------------
 1287|   398k|	    PROTECT(pargs);
  ------------------
  |  |  357|   398k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1288|   398k|	    tmp = applyClosure(e, op, pargs, rho, R_NilValue, TRUE);
  ------------------
  |  |  879|   398k|#define applyClosure		Rf_applyClosure
  ------------------
 1289|   398k|	    UNPROTECT(1);
  ------------------
  |  |  358|   398k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1290|   398k|	}
 1291|    911|	else
 1292|    911|	    error(_("attempt to apply non-function"));
  ------------------
  |  |   88|    911|#define error Rf_error
  ------------------
              	    error(_("attempt to apply non-function"));
  ------------------
  |  | 2531|    911|#   define _(String) gettext (String)
  ------------------
 1293|  1.57M|	UNPROTECT(1);
  ------------------
  |  |  358|  1.57M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1294|  1.57M|	break;
 1295|      0|    case DOTSXP:
  ------------------
  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (1295:5): [True: 0, False: 7.03M]
  ------------------
 1296|      0|	error(_("'...' used in an incorrect context"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'...' used in an incorrect context"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1297|      0|    default:
  ------------------
  |  Branch (1297:5): [True: 0, False: 7.03M]
  ------------------
 1298|      0|	UNIMPLEMENTED_TYPE("eval", e);
 1299|  7.03M|    }
 1300|  7.02M|    R_EvalDepth = depthsave;
 1301|  7.02M|    R_Srcref = srcrefsave;
 1302|  7.02M|    R_BCIntActive = bcintactivesave;
 1303|  7.02M|    return (tmp);
 1304|  7.03M|}
R_init_jit_enabled:
 1462|      2|{
 1463|       |    /* Need to force the lazy loading promise to avoid recursive
 1464|       |       promise evaluation when JIT is enabled. Might be better to do
 1465|       |       this in baseloader.R. */
 1466|      2|    eval(install(".ArgsEnv"), R_BaseEnv);
  ------------------
  |  |  913|      2|#define eval			Rf_eval
  ------------------
                  eval(install(".ArgsEnv"), R_BaseEnv);
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1467|       |
 1468|      2|    int val = 3; /* turn JIT on by default */
 1469|      2|    char *enable = getenv("R_ENABLE_JIT");
 1470|      2|    if (enable != NULL)
  ------------------
  |  Branch (1470:9): [True: 0, False: 2]
  ------------------
 1471|      0|	val = atoi(enable);
 1472|      2|    if (val) {
  ------------------
  |  Branch (1472:9): [True: 2, False: 0]
  ------------------
 1473|      2|	loadCompilerNamespace();
 1474|      2|	checkCompilerOptions(val);
 1475|      2|    }
 1476|      2|    R_jit_enabled = val;
 1477|       |
 1478|      2|    if (R_compile_pkgs <= 0) {
  ------------------
  |  Branch (1478:9): [True: 2, False: 0]
  ------------------
 1479|      2|	char *compile = getenv("_R_COMPILE_PKGS_");
 1480|      2|	if (compile != NULL) {
  ------------------
  |  Branch (1480:6): [True: 0, False: 2]
  ------------------
 1481|      0|	    int val = atoi(compile);
 1482|      0|	    if (val > 0)
  ------------------
  |  Branch (1482:10): [True: 0, False: 0]
  ------------------
 1483|      0|		R_compile_pkgs = TRUE;
 1484|      0|	    else
 1485|      0|		R_compile_pkgs = FALSE;
 1486|      0|	}
 1487|      2|    }
 1488|       |
 1489|      2|    if (R_disable_bytecode <= 0) {
  ------------------
  |  Branch (1489:9): [True: 2, False: 0]
  ------------------
 1490|      2|	char *disable = getenv("R_DISABLE_BYTECODE");
 1491|      2|	if (disable != NULL) {
  ------------------
  |  Branch (1491:6): [True: 0, False: 2]
  ------------------
 1492|      0|	    int val = atoi(disable);
 1493|      0|	    if (val > 0)
  ------------------
  |  Branch (1493:10): [True: 0, False: 0]
  ------------------
 1494|      0|		R_disable_bytecode = TRUE;
 1495|      0|	    else
 1496|      0|		R_disable_bytecode = FALSE;
 1497|      0|	}
 1498|      2|    }
 1499|       |
 1500|       |    /* -1 ... duplicate constants on LDCONST and PUSHCONSTARG, no checking
 1501|       |        0 ... no checking (no duplication for >= 0) [DEFAULT]
 1502|       |	1 ... check at error, session exit and reclamation
 1503|       |	2 ... check also at full GC
 1504|       |	3 ... check also at partial GC
 1505|       |	4 ... check also at .Call
 1506|       |	5 ... (very) verbose report on modified constants
 1507|       |    */
 1508|      2|    if (R_check_constants <= 1) {
  ------------------
  |  Branch (1508:9): [True: 2, False: 0]
  ------------------
 1509|      2|	char *check = getenv("R_CHECK_CONSTANTS");
 1510|      2|	if (check != NULL)
  ------------------
  |  Branch (1510:6): [True: 0, False: 2]
  ------------------
 1511|      0|	    R_check_constants = atoi(check);
 1512|      2|    }
 1513|       |
 1514|       |    /* initialize JIT variables */
 1515|      2|    R_IfSymbol = install("if");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1516|      2|    R_ForSymbol = install("for");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1517|      2|    R_WhileSymbol = install("while");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1518|      2|    R_RepeatSymbol = install("repeat");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1519|       |
 1520|      2|    R_PreserveObject(JIT_cache = allocVector(VECSXP, JIT_CACHE_SIZE));
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
                  R_PreserveObject(JIT_cache = allocVector(VECSXP, JIT_CACHE_SIZE));
  ------------------
  |  |  131|      2|#define VECSXP	    19	  /* generic vectors */
  ------------------
                  R_PreserveObject(JIT_cache = allocVector(VECSXP, JIT_CACHE_SIZE));
  ------------------
  |  | 1451|      2|#define JIT_CACHE_SIZE 1024
  ------------------
 1521|      2|}
R_cmpfun1:
 1831|      1|{
 1832|      1|    Rboolean old_visible = R_Visible;
 1833|      1|    SEXP packsym, funsym, call, fcall, val;
 1834|       |
 1835|      1|    packsym = install("compiler");
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
 1836|      1|    funsym = install("tryCmpfun");
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
 1837|       |
 1838|      1|    PROTECT(fcall = lang3(R_TripleColonSymbol, packsym, funsym));
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1839|      1|    PROTECT(call = lang2(fcall, fun));
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1840|      1|    PROTECT(val = eval(call, R_BaseEnv));
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1841|      1|    if (TYPEOF(BODY(val)) != BCODESXP)
  ------------------
  |  |  133|      1|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (1841:9): [True: 0, False: 1]
  ------------------
 1842|       |	/* Compilation may have failed because R allocator could not malloc
 1843|       |	   memory to extend the R heap, so we run GC to release some pages.
 1844|       |	   This problem has been observed while byte-compiling packages on
 1845|       |	   installation: serialization uses malloc to allocate buffers and
 1846|       |	   fails when the compiler makes R allocator exhaust malloc memory.
 1847|       |	   A more general solution might be to run the GC conditionally inside
 1848|       |	   error handling. */
 1849|      0|	R_gc();
 1850|      1|    UNPROTECT(3); /* fcall, call, val */
  ------------------
  |  |  358|      1|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1851|       |
 1852|      1|    R_Visible = old_visible;
 1853|      1|    return val;
 1854|      1|}
Rf_applyClosure:
 2344|   400k|{
 2345|   400k|    SEXP val = applyClosure_core(call, op, arglist, rho,
 2346|   400k|				 suppliedvars, R_NilValue, unpromise);
 2347|   400k|#ifdef SUPPORT_TAILCALL
 2348|   400k|    val = handle_exec_continuation(val);
 2349|   400k|#endif
 2350|   400k|    return val;
 2351|   400k|}
R_forceAndCall:
 2427|  1.17k|{
 2428|  1.17k|    SEXP fun, tmp;
 2429|  1.17k|    if (TYPEOF(CAR(e)) == SYMSXP)
  ------------------
  |  |  112|  1.17k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (2429:9): [True: 1.17k, False: 0]
  ------------------
 2430|       |	/* This will throw an error if the function is not found */
 2431|  1.17k|	PROTECT(fun = findFun(CAR(e), rho));
  ------------------
  |  |  357|  1.17k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2432|      0|    else
 2433|      0|	PROTECT(fun = eval(CAR(e), rho));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2434|       |
 2435|  1.17k|    if (TYPEOF(fun) == SPECIALSXP) {
  ------------------
  |  |  118|  1.17k|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (2435:9): [True: 0, False: 1.17k]
  ------------------
 2436|      0|	int flag = PRIMPRINT(fun);
  ------------------
  |  | 1350|      0|#define PRIMPRINT(x)	(((R_FunTab[PRIMOFFSET(x)].eval)/100)%10)
  |  |  ------------------
  |  |  |  |  913|      0|#define eval			Rf_eval
  |  |  ------------------
  ------------------
 2437|      0|	PROTECT(e);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2438|      0|	R_Visible = flag != 1;
 2439|      0|	tmp = PRIMFUN(fun) (e, fun, CDR(e), rho);
  ------------------
  |  | 1345|      0|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 2440|      0|	if (flag < 2) R_Visible = flag != 1;
  ------------------
  |  Branch (2440:6): [True: 0, False: 0]
  ------------------
 2441|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2442|      0|    }
 2443|  1.17k|    else if (TYPEOF(fun) == BUILTINSXP) {
  ------------------
  |  |  119|  1.17k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (2443:14): [True: 68, False: 1.10k]
  ------------------
 2444|     68|	int flag = PRIMPRINT(fun);
  ------------------
  |  | 1350|     68|#define PRIMPRINT(x)	(((R_FunTab[PRIMOFFSET(x)].eval)/100)%10)
  |  |  ------------------
  |  |  |  |  913|     68|#define eval			Rf_eval
  |  |  ------------------
  ------------------
 2445|     68|	PROTECT(tmp = evalList(CDR(e), rho, e, 0));
  ------------------
  |  |  357|     68|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2446|     68|	if (flag < 2) R_Visible = flag != 1;
  ------------------
  |  Branch (2446:6): [True: 68, False: 0]
  ------------------
 2447|       |	/* We used to insert a context only if profiling,
 2448|       |	   but helps for tracebacks on .C etc. */
 2449|     68|	if (R_Profiling || (PPINFO(fun).kind == PP_FOREIGN)) {
  ------------------
  |  | 1349|     68|#define PPINFO(x)	(R_FunTab[PRIMOFFSET(x)].gram)
  ------------------
  |  Branch (2449:6): [True: 0, False: 68]
  |  Branch (2449:21): [True: 0, False: 68]
  ------------------
 2450|      0|	    RCNTXT cntxt;
 2451|      0|	    SEXP oldref = R_Srcref;
 2452|      0|	    begincontext(&cntxt, CTXT_BUILTIN, e,
  ------------------
  |  | 1864|      0|# define begincontext		Rf_begincontext
  ------------------
 2453|      0|			 R_BaseEnv, R_BaseEnv, R_NilValue, R_NilValue);
 2454|      0|	    R_Srcref = NULL;
 2455|      0|	    tmp = PRIMFUN(fun) (e, fun, tmp, rho);
  ------------------
  |  | 1345|      0|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 2456|      0|	    R_Srcref = oldref;
 2457|      0|	    endcontext(&cntxt);
  ------------------
  |  | 1895|      0|# define endcontext		Rf_endcontext
  ------------------
 2458|     68|	} else {
 2459|     68|	    tmp = PRIMFUN(fun) (e, fun, tmp, rho);
  ------------------
  |  | 1345|     68|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 2460|     68|	}
 2461|     68|	if (flag < 2) R_Visible = flag != 1;
  ------------------
  |  Branch (2461:6): [True: 68, False: 0]
  ------------------
 2462|     68|	UNPROTECT(1);
  ------------------
  |  |  358|     68|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2463|     68|    }
 2464|  1.10k|    else if (TYPEOF(fun) == CLOSXP) {
  ------------------
  |  |  114|  1.10k|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (2464:14): [True: 1.10k, False: 0]
  ------------------
 2465|  1.10k|	PROTECT(tmp = promiseArgs(CDR(e), rho));
  ------------------
  |  |  357|  1.10k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2466|  1.10k|	SEXP a;
 2467|  1.10k|	int i;
 2468|  2.21k|	for (a = tmp, i = 0; i < n && a != R_NilValue; a = CDR(a), i++) {
  ------------------
  |  Branch (2468:23): [True: 1.10k, False: 1.10k]
  |  Branch (2468:32): [True: 1.10k, False: 0]
  ------------------
 2469|  1.10k|	    SEXP p = CAR(a);
 2470|  1.10k|	    if (TYPEOF(p) == PROMSXP)
  ------------------
  |  |  116|  1.10k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2470:10): [True: 1.10k, False: 0]
  ------------------
 2471|  1.10k|		eval(p, rho);
  ------------------
  |  |  913|  1.10k|#define eval			Rf_eval
  ------------------
 2472|      0|	    else if (p == R_MissingArg)
  ------------------
  |  Branch (2472:15): [True: 0, False: 0]
  ------------------
 2473|      0|		errorcall(e, _("argument %d is empty"), i + 1);
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		errorcall(e, _("argument %d is empty"), i + 1);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2474|      0|	    else error("something weird happened");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 2475|  1.10k|	}
 2476|  1.10k|	SEXP pargs = tmp;
 2477|  1.10k|	tmp = applyClosure(e, fun, pargs, rho, R_NilValue, TRUE);
  ------------------
  |  |  879|  1.10k|#define applyClosure		Rf_applyClosure
  ------------------
 2478|  1.10k|	UNPROTECT(1);
  ------------------
  |  |  358|  1.10k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2479|  1.10k|    }
 2480|      0|    else {
 2481|      0|	tmp = R_NilValue; /* -Wall */
 2482|      0|	error(_("attempt to apply non-function"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt to apply non-function"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2483|      0|    }
 2484|       |
 2485|  1.17k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.17k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2486|  1.17k|    return tmp;
 2487|  1.17k|}
do_if:
 2717|    449|{
 2718|    449|    SEXP Cond, Stmt=R_NilValue;
 2719|    449|    int vis=0;
 2720|       |
 2721|    449|    PROTECT(Cond = eval(CAR(args), rho));
  ------------------
  |  |  357|    449|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2722|    449|    if (asLogicalNoNA(Cond, call))
  ------------------
  |  Branch (2722:9): [True: 215, False: 234]
  ------------------
 2723|    215|	Stmt = CADR(args);
 2724|    234|    else {
 2725|    234|	if (length(args) > 2)
  ------------------
  |  |  987|    234|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (2725:6): [True: 141, False: 93]
  ------------------
 2726|    141|	    Stmt = CADDR(args);
 2727|     93|	else
 2728|     93|	    vis = 1;
 2729|    234|    }
 2730|    449|    if( !vis && RDEBUG(rho) && !BodyHasBraces(Stmt) && !R_GlobalContext->browserfinish) {
  ------------------
  |  | 2702|    449|    ((isLanguage(body) && CAR(body) == R_BraceSymbol) ? 1 : 0)
  |  |  ------------------
  |  |  |  |  950|      0|#define isLanguage		Rf_isLanguage
  |  |  ------------------
  |  |  |  Branch (2702:7): [True: 0, False: 0]
  |  |  |  Branch (2702:27): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (2730:9): [True: 356, False: 93]
  |  Branch (2730:17): [True: 0, False: 356]
  |  Branch (2730:32): [True: 0, False: 0]
  |  Branch (2730:56): [True: 0, False: 0]
  ------------------
 2731|      0|	SrcrefPrompt("debug", R_Srcref);
  ------------------
  |  | 1987|      0|# define SrcrefPrompt		Rf_SrcrefPrompt
  ------------------
 2732|      0|	PrintValue(Stmt);
  ------------------
  |  | 1013|      0|#define PrintValue		Rf_PrintValue
  ------------------
 2733|      0|	do_browser(call, op, R_NilValue, rho);
 2734|      0|    }
 2735|    449|    UNPROTECT(1);
  ------------------
  |  |  358|    449|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2736|    449|    if( vis ) {
  ------------------
  |  Branch (2736:9): [True: 93, False: 356]
  ------------------
 2737|     93|	R_Visible = FALSE; /* case of no 'else' so return invisible NULL */
 2738|     93|	return Stmt;
 2739|     93|    }
 2740|    356|    return (eval(Stmt, rho));
  ------------------
  |  |  913|    356|#define eval			Rf_eval
  ------------------
 2741|    449|}
do_for:
 2773|      8|{
 2774|       |    /* Need to declare volatile variables whose values are relied on
 2775|       |       after for_next or for_break longjmps and might change between
 2776|       |       the setjmp and longjmp calls. Theoretically this does not
 2777|       |       include n and bgn, but gcc -O2 -Wclobbered warns about these so
 2778|       |       to be safe we declare them volatile as well. */
 2779|      8|    volatile R_xlen_t i = 0, n;
 2780|      8|    volatile int bgn;
 2781|      8|    volatile SEXP v, val, cell;
 2782|      8|    int dbg, val_type;
 2783|      8|    SEXP sym, body;
 2784|      8|    RCNTXT cntxt;
 2785|      8|    PROTECT_INDEX vpi;
 2786|       |
 2787|      8|    checkArity(op, args);
  ------------------
  |  | 1788|      8|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2788|      8|    sym = CAR(args);
 2789|      8|    val = CADR(args);
 2790|      8|    body = CADDR(args);
 2791|       |
 2792|      8|    if ( !isSymbol(sym) ) errorcall(call, _("non-symbol loop variable"));
  ------------------
  |  |  953|      8|#define isSymbol		Rf_isSymbol
  ------------------
                  if ( !isSymbol(sym) ) errorcall(call, _("non-symbol loop variable"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
                  if ( !isSymbol(sym) ) errorcall(call, _("non-symbol loop variable"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (2792:10): [True: 0, False: 8]
  ------------------
 2793|       |
 2794|      8|    dbg = RDEBUG(rho);
 2795|      8|    if (R_jit_enabled > 2 && !dbg && !R_disable_bytecode
  ------------------
  |  Branch (2795:9): [True: 0, False: 8]
  |  Branch (2795:30): [True: 0, False: 0]
  |  Branch (2795:38): [True: 0, False: 0]
  ------------------
 2796|      0|	    && rho == R_GlobalEnv
  ------------------
  |  Branch (2796:9): [True: 0, False: 0]
  ------------------
 2797|      0|	    && isUnmodifiedSpecSym(CAR(call), rho)
  ------------------
  |  |  968|      0|#define isUnmodifiedSpecSym	Rf_isUnmodifiedSpecSym
  ------------------
  |  Branch (2797:9): [True: 0, False: 0]
  ------------------
 2798|      0|	    && R_compileAndExecute(call, rho))
  ------------------
  |  Branch (2798:9): [True: 0, False: 0]
  ------------------
 2799|      0|	return R_NilValue;
 2800|       |
 2801|      8|    PROTECT(args);
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2802|      8|    PROTECT(rho);
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2803|      8|    PROTECT(val = eval(val, rho));
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2804|       |
 2805|       |    /* deal with the case where we are iterating over a factor
 2806|       |       we need to coerce to character - then iterate */
 2807|       |
 2808|      8|    if ( inherits(val, "factor") ) {
  ------------------
  |  |  933|      8|#define inherits		Rf_inherits
  ------------------
  |  Branch (2808:10): [True: 0, False: 8]
  ------------------
 2809|      0|	SEXP tmp = asCharacterFactor(val);
  ------------------
  |  |  883|      0|#define asCharacterFactor	Rf_asCharacterFactor
  ------------------
 2810|      0|	UNPROTECT(1); /* val from above */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2811|      0|	PROTECT(val = tmp);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2812|      0|    }
 2813|       |
 2814|      8|    if (isList(val) || isNull(val))
  ------------------
  |  |  951|      8|#define isList			Rf_isList
  ------------------
                  if (isList(val) || isNull(val))
  ------------------
  |  |  956|      8|#define isNull			Rf_isNull
  ------------------
  |  Branch (2814:9): [True: 0, False: 8]
  |  Branch (2814:24): [True: 0, False: 8]
  ------------------
 2815|      0|	n = length(val);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 2816|      8|    else
 2817|      8|	n = XLENGTH(val);
 2818|       |
 2819|      8|    val_type = TYPEOF(val);
 2820|       |
 2821|      8|    defineVar(sym, R_NilValue, rho);
  ------------------
  |  |  905|      8|#define defineVar		Rf_defineVar
  ------------------
 2822|      8|    PROTECT(cell = GET_BINDING_CELL(sym, rho));
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2823|      8|    bgn = BodyHasBraces(body);
  ------------------
  |  | 2702|      8|    ((isLanguage(body) && CAR(body) == R_BraceSymbol) ? 1 : 0)
  |  |  ------------------
  |  |  |  |  950|      8|#define isLanguage		Rf_isLanguage
  |  |  ------------------
  |  |  |  Branch (2702:7): [True: 8, False: 0]
  |  |  |  Branch (2702:27): [True: 2, False: 6]
  |  |  ------------------
  ------------------
 2824|       |
 2825|       |    /* bump up links count of sequence to avoid modification by loop code */
 2826|      8|    INCREMENT_LINKS(val);
  ------------------
  |  |  540|      8|#define INCREMENT_LINKS(x) do {			\
  |  |  541|      8|	SEXP il__x__ = (x);			\
  |  |  542|      8|	INCREMENT_NAMED(il__x__);		\
  |  |  ------------------
  |  |  |  |  222|      8|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 8]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  543|      8|	INCREMENT_REFCNT(il__x__);		\
  |  |  544|      8|    } while (0)
  |  |  ------------------
  |  |  |  Branch (544:14): [Folded, False: 8]
  |  |  ------------------
  ------------------
 2827|       |
 2828|      8|    PROTECT_WITH_INDEX(v = R_NilValue, &vpi);
  ------------------
  |  |  366|      8|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
 2829|       |
 2830|      8|    begincontext(&cntxt, CTXT_LOOP, R_NilValue, rho, R_BaseEnv, R_NilValue,
  ------------------
  |  | 1864|      8|# define begincontext		Rf_begincontext
  ------------------
 2831|      8|		 R_NilValue);
 2832|      8|    switch (SETJMP(cntxt.cjmpbuf)) {
  ------------------
  |  | 1162|      8|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (2832:13): [True: 0, False: 8]
  ------------------
 2833|      0|    case CTXT_BREAK: goto for_break;
  ------------------
  |  Branch (2833:5): [True: 0, False: 8]
  ------------------
 2834|      0|    case CTXT_NEXT: goto for_next;
  ------------------
  |  Branch (2834:5): [True: 0, False: 8]
  ------------------
 2835|      8|    }
 2836|       |
 2837|    834|    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (2837:17): [True: 826, False: 8]
  ------------------
 2838|       |
 2839|    826|	switch (val_type) {
 2840|       |
 2841|      0|	case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (2841:2): [True: 0, False: 826]
  ------------------
 2842|      0|	case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2842:2): [True: 0, False: 826]
  ------------------
 2843|       |	    /* make sure loop variable is not modified via other vars */
 2844|      0|	    ENSURE_NAMEDMAX(VECTOR_ELT(val, i));
 2845|       |	    /* defineVar is used here and below rather than setVar in
 2846|       |	       case the loop code removes the variable. */
 2847|      0|	    defineVar(sym, VECTOR_ELT(val, i), rho);
  ------------------
  |  |  905|      0|#define defineVar		Rf_defineVar
  ------------------
 2848|      0|	    break;
 2849|       |
 2850|      0|	case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2850:2): [True: 0, False: 826]
  ------------------
 2851|       |	    /* make sure loop variable is not modified via other vars */
 2852|      0|	    ENSURE_NAMEDMAX(CAR(val));
 2853|      0|	    defineVar(sym, CAR(val), rho);
  ------------------
  |  |  905|      0|#define defineVar		Rf_defineVar
  ------------------
 2854|      0|	    val = CDR(val);
 2855|      0|	    break;
 2856|       |
 2857|    826|	default:
  ------------------
  |  Branch (2857:2): [True: 826, False: 0]
  ------------------
 2858|       |
 2859|    826|	    switch (val_type) {
 2860|      0|	    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2860:6): [True: 0, False: 826]
  ------------------
 2861|      0|		ALLOC_LOOP_VAR(v, val_type, vpi);
  ------------------
  |  | 2708|      0|#define ALLOC_LOOP_VAR(v, val_type, vpi) do {			\
  |  | 2709|      0|	if (v == R_NilValue || MAYBE_SHARED(v) ||		\
  |  |  ------------------
  |  |  |  Branch (2709:6): [True: 0, False: 0]
  |  |  |  Branch (2709:25): [True: 0, False: 0]
  |  |  ------------------
  |  | 2710|      0|	    ATTRIB(v) != R_NilValue || (v) != CAR(cell)) {	\
  |  |  ------------------
  |  |  |  Branch (2710:6): [True: 0, False: 0]
  |  |  |  Branch (2710:33): [True: 0, False: 0]
  |  |  ------------------
  |  | 2711|      0|	    REPROTECT(v = allocVector(val_type, 1), vpi);	\
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  | 2712|      0|	    INCREMENT_NAMED(v);					\
  |  |  ------------------
  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2713|      0|	}							\
  |  | 2714|      0|    } while(0)
  |  |  ------------------
  |  |  |  Branch (2714:13): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2862|      0|		SET_SCALAR_LVAL(v, LOGICAL_ELT(val, i));
 2863|      0|		break;
 2864|      4|	    case INTSXP:
  ------------------
  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2864:6): [True: 4, False: 822]
  ------------------
 2865|      4|		ALLOC_LOOP_VAR(v, val_type, vpi);
  ------------------
  |  | 2708|      4|#define ALLOC_LOOP_VAR(v, val_type, vpi) do {			\
  |  | 2709|      4|	if (v == R_NilValue || MAYBE_SHARED(v) ||		\
  |  |  ------------------
  |  |  |  Branch (2709:6): [True: 2, False: 2]
  |  |  |  Branch (2709:25): [True: 0, False: 2]
  |  |  ------------------
  |  | 2710|      4|	    ATTRIB(v) != R_NilValue || (v) != CAR(cell)) {	\
  |  |  ------------------
  |  |  |  Branch (2710:6): [True: 0, False: 2]
  |  |  |  Branch (2710:33): [True: 0, False: 2]
  |  |  ------------------
  |  | 2711|      2|	    REPROTECT(v = allocVector(val_type, 1), vpi);	\
  |  |  ------------------
  |  |  |  |  367|      2|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  | 2712|      2|	    INCREMENT_NAMED(v);					\
  |  |  ------------------
  |  |  |  |  222|      2|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2713|      2|	}							\
  |  | 2714|      4|    } while(0)
  |  |  ------------------
  |  |  |  Branch (2714:13): [Folded, False: 4]
  |  |  ------------------
  ------------------
 2866|      4|		SET_SCALAR_IVAL(v, INTEGER_ELT(val, i));
 2867|      4|		break;
 2868|      0|	    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (2868:6): [True: 0, False: 826]
  ------------------
 2869|      0|		ALLOC_LOOP_VAR(v, val_type, vpi);
  ------------------
  |  | 2708|      0|#define ALLOC_LOOP_VAR(v, val_type, vpi) do {			\
  |  | 2709|      0|	if (v == R_NilValue || MAYBE_SHARED(v) ||		\
  |  |  ------------------
  |  |  |  Branch (2709:6): [True: 0, False: 0]
  |  |  |  Branch (2709:25): [True: 0, False: 0]
  |  |  ------------------
  |  | 2710|      0|	    ATTRIB(v) != R_NilValue || (v) != CAR(cell)) {	\
  |  |  ------------------
  |  |  |  Branch (2710:6): [True: 0, False: 0]
  |  |  |  Branch (2710:33): [True: 0, False: 0]
  |  |  ------------------
  |  | 2711|      0|	    REPROTECT(v = allocVector(val_type, 1), vpi);	\
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  | 2712|      0|	    INCREMENT_NAMED(v);					\
  |  |  ------------------
  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2713|      0|	}							\
  |  | 2714|      0|    } while(0)
  |  |  ------------------
  |  |  |  Branch (2714:13): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2870|      0|		SET_SCALAR_DVAL(v, REAL_ELT(val, i));
 2871|      0|		break;
 2872|      0|	    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (2872:6): [True: 0, False: 826]
  ------------------
 2873|      0|		ALLOC_LOOP_VAR(v, val_type, vpi);
  ------------------
  |  | 2708|      0|#define ALLOC_LOOP_VAR(v, val_type, vpi) do {			\
  |  | 2709|      0|	if (v == R_NilValue || MAYBE_SHARED(v) ||		\
  |  |  ------------------
  |  |  |  Branch (2709:6): [True: 0, False: 0]
  |  |  |  Branch (2709:25): [True: 0, False: 0]
  |  |  ------------------
  |  | 2710|      0|	    ATTRIB(v) != R_NilValue || (v) != CAR(cell)) {	\
  |  |  ------------------
  |  |  |  Branch (2710:6): [True: 0, False: 0]
  |  |  |  Branch (2710:33): [True: 0, False: 0]
  |  |  ------------------
  |  | 2711|      0|	    REPROTECT(v = allocVector(val_type, 1), vpi);	\
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  | 2712|      0|	    INCREMENT_NAMED(v);					\
  |  |  ------------------
  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2713|      0|	}							\
  |  | 2714|      0|    } while(0)
  |  |  ------------------
  |  |  |  Branch (2714:13): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2874|      0|		SET_SCALAR_CVAL(v, COMPLEX_ELT(val, i));
 2875|      0|		break;
 2876|    822|	    case STRSXP:
  ------------------
  |  |  126|    822|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2876:6): [True: 822, False: 4]
  ------------------
 2877|    822|		ALLOC_LOOP_VAR(v, val_type, vpi);
  ------------------
  |  | 2708|    822|#define ALLOC_LOOP_VAR(v, val_type, vpi) do {			\
  |  | 2709|    822|	if (v == R_NilValue || MAYBE_SHARED(v) ||		\
  |  |  ------------------
  |  |  |  Branch (2709:6): [True: 6, False: 816]
  |  |  |  Branch (2709:25): [True: 816, False: 0]
  |  |  ------------------
  |  | 2710|    822|	    ATTRIB(v) != R_NilValue || (v) != CAR(cell)) {	\
  |  |  ------------------
  |  |  |  Branch (2710:6): [True: 0, False: 0]
  |  |  |  Branch (2710:33): [True: 0, False: 0]
  |  |  ------------------
  |  | 2711|    822|	    REPROTECT(v = allocVector(val_type, 1), vpi);	\
  |  |  ------------------
  |  |  |  |  367|    822|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  | 2712|    822|	    INCREMENT_NAMED(v);					\
  |  |  ------------------
  |  |  |  |  222|    822|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 822]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2713|    822|	}							\
  |  | 2714|    822|    } while(0)
  |  |  ------------------
  |  |  |  Branch (2714:13): [Folded, False: 822]
  |  |  ------------------
  ------------------
 2878|    822|		SET_STRING_ELT(v, 0, STRING_ELT(val, i));
 2879|    822|		break;
 2880|      0|	    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (2880:6): [True: 0, False: 826]
  ------------------
 2881|      0|		ALLOC_LOOP_VAR(v, val_type, vpi);
  ------------------
  |  | 2708|      0|#define ALLOC_LOOP_VAR(v, val_type, vpi) do {			\
  |  | 2709|      0|	if (v == R_NilValue || MAYBE_SHARED(v) ||		\
  |  |  ------------------
  |  |  |  Branch (2709:6): [True: 0, False: 0]
  |  |  |  Branch (2709:25): [True: 0, False: 0]
  |  |  ------------------
  |  | 2710|      0|	    ATTRIB(v) != R_NilValue || (v) != CAR(cell)) {	\
  |  |  ------------------
  |  |  |  Branch (2710:6): [True: 0, False: 0]
  |  |  |  Branch (2710:33): [True: 0, False: 0]
  |  |  ------------------
  |  | 2711|      0|	    REPROTECT(v = allocVector(val_type, 1), vpi);	\
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  | 2712|      0|	    INCREMENT_NAMED(v);					\
  |  |  ------------------
  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 2713|      0|	}							\
  |  | 2714|      0|    } while(0)
  |  |  ------------------
  |  |  |  Branch (2714:13): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2882|      0|		SET_SCALAR_BVAL(v, RAW(val)[i]);
 2883|      0|		break;
 2884|      0|	    default:
  ------------------
  |  Branch (2884:6): [True: 0, False: 826]
  ------------------
 2885|      0|		errorcall(call, _("invalid for() loop sequence"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		errorcall(call, _("invalid for() loop sequence"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2886|    826|	    }
 2887|    826|	    if (CAR(cell) == R_UnboundValue || ! SET_BINDING_VALUE(cell, v))
  ------------------
  |  Branch (2887:10): [True: 0, False: 826]
  |  Branch (2887:41): [True: 0, False: 826]
  ------------------
 2888|      0|		defineVar(sym, v, rho);
  ------------------
  |  |  905|      0|#define defineVar		Rf_defineVar
  ------------------
 2889|    826|	}
 2890|    826|	if (!bgn && RDEBUG(rho) && !R_GlobalContext->browserfinish) {
  ------------------
  |  Branch (2890:6): [True: 814, False: 12]
  |  Branch (2890:14): [True: 0, False: 814]
  |  Branch (2890:29): [True: 0, False: 0]
  ------------------
 2891|      0|	    SrcrefPrompt("debug", R_Srcref);
  ------------------
  |  | 1987|      0|# define SrcrefPrompt		Rf_SrcrefPrompt
  ------------------
 2892|      0|	    PrintValue(body);
  ------------------
  |  | 1013|      0|#define PrintValue		Rf_PrintValue
  ------------------
 2893|      0|	    do_browser(call, op, R_NilValue, rho);
 2894|      0|	}
 2895|    826|	eval(body, rho);
  ------------------
  |  |  913|    826|#define eval			Rf_eval
  ------------------
 2896|       |
 2897|    826|    for_next:
 2898|    826|	; /* needed for strict ISO C compliance, according to gcc 2.95.2 */
 2899|    826|    }
 2900|      8| for_break:
 2901|      8|    endcontext(&cntxt);
  ------------------
  |  | 1895|      8|# define endcontext		Rf_endcontext
  ------------------
 2902|      8|    DECREMENT_LINKS(val);
  ------------------
  |  |  545|      8|#define DECREMENT_LINKS(x) do {			\
  |  |  546|      8|	SEXP dl__x__ = (x);			\
  |  |  547|      8|	DECREMENT_NAMED(dl__x__);		\
  |  |  ------------------
  |  |  |  |  223|      8|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (223:43): [Folded, False: 8]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  548|      8|	DECREMENT_REFCNT(dl__x__);		\
  |  |  549|      8|    } while (0)
  |  |  ------------------
  |  |  |  Branch (549:14): [Folded, False: 8]
  |  |  ------------------
  ------------------
 2903|      8|    UNPROTECT(5);
  ------------------
  |  |  358|      8|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2904|      8|    SET_RDEBUG(rho, dbg);
 2905|      8|    return R_NilValue;
 2906|      8|}
do_begin:
 3000|  1.78k|{
 3001|  1.78k|    SEXP s = R_NilValue;
 3002|  1.78k|    if (args != R_NilValue) {
  ------------------
  |  Branch (3002:9): [True: 1.78k, False: 0]
  ------------------
 3003|  1.78k|	SEXP srcrefs = getBlockSrcrefs(call);
 3004|  1.78k|	PROTECT(srcrefs);
  ------------------
  |  |  357|  1.78k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3005|  1.78k|	int i = 1;
 3006|  7.95k|	while (args != R_NilValue) {
  ------------------
  |  Branch (3006:9): [True: 6.17k, False: 1.78k]
  ------------------
 3007|  6.17k|	    PROTECT(R_Srcref = getSrcref(srcrefs, i++));
  ------------------
  |  |  357|  6.17k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3008|  6.17k|	    if (RDEBUG(rho) && !R_GlobalContext->browserfinish) {
  ------------------
  |  Branch (3008:10): [True: 0, False: 6.17k]
  |  Branch (3008:25): [True: 0, False: 0]
  ------------------
 3009|      0|		SrcrefPrompt("debug", R_Srcref);
  ------------------
  |  | 1987|      0|# define SrcrefPrompt		Rf_SrcrefPrompt
  ------------------
 3010|      0|		PrintValue(CAR(args));
  ------------------
  |  | 1013|      0|#define PrintValue		Rf_PrintValue
  ------------------
 3011|      0|		do_browser(call, op, R_NilValue, rho);
 3012|      0|	    }
 3013|  6.17k|	    s = eval(CAR(args), rho);
  ------------------
  |  |  913|  6.17k|#define eval			Rf_eval
  ------------------
 3014|  6.17k|	    UNPROTECT(1);
  ------------------
  |  |  358|  6.17k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3015|  6.17k|	    args = CDR(args);
 3016|  6.17k|	}
 3017|  1.78k|	R_Srcref = R_NilValue;
 3018|  1.78k|	UNPROTECT(1); /* srcrefs */
  ------------------
  |  |  358|  1.78k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3019|  1.78k|    }
 3020|  1.78k|    return s;
 3021|  1.78k|}
do_function:
 3150|   385k|{
 3151|   385k|    SEXP rval, srcref;
 3152|       |
 3153|   385k|    if (TYPEOF(op) == PROMSXP) {
  ------------------
  |  |  116|   385k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (3153:9): [True: 0, False: 385k]
  ------------------
 3154|      0|	ENSURE_PROMISE_IS_EVALUATED(op);
  ------------------
  |  |  946|      0|#define ENSURE_PROMISE_IS_EVALUATED(x) do {	\
  |  |  947|      0|	SEXP __x__ = (x);			\
  |  |  948|      0|	if (! PROMISE_IS_EVALUATED(__x__))	\
  |  |  ------------------
  |  |  |  Branch (948:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|	    forcePromise(__x__);		\
  |  |  950|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (950:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3155|      0|	op = PRVALUE(op);
 3156|      0|    }
 3157|   385k|    if (length(args) < 2) WrongArgCount("function");
  ------------------
  |  |  987|   385k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (3157:9): [True: 0, False: 385k]
  ------------------
 3158|   385k|    CheckFormals(CAR(args), "function");
  ------------------
  |  | 1868|   385k|# define CheckFormals		Rf_CheckFormals
  ------------------
 3159|   385k|    rval = mkCLOSXP(CAR(args), CADR(args), rho);
  ------------------
  |  | 1955|   385k|# define mkCLOSXP		Rf_mkCLOSXP
  ------------------
 3160|   385k|    srcref = CADDR(args);
 3161|   385k|    if (!isNull(srcref)) setAttrib(rval, R_SrcrefSymbol, srcref);
  ------------------
  |  |  956|   385k|#define isNull			Rf_isNull
  ------------------
                  if (!isNull(srcref)) setAttrib(rval, R_SrcrefSymbol, srcref);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  |  Branch (3161:9): [True: 0, False: 385k]
  ------------------
 3162|   385k|    return rval;
 3163|   385k|}
R_initEvalSymbols:
 3251|      2|{
 3252|     10|    for (int i = 0; i < NUM_ASYM; i++)
  ------------------
  |  | 3239|     10|#define NUM_ASYM (sizeof(asym) / sizeof(char *))
  ------------------
  |  Branch (3252:21): [True: 8, False: 2]
  ------------------
 3253|      8|	asymSymbol[i] = install(asym[i]);
  ------------------
  |  |  934|      8|#define install			Rf_install
  ------------------
 3254|       |
 3255|      2|    R_ReplaceFunsTable = R_NewHashedEnv(R_EmptyEnv, 1099);
 3256|      2|    R_PreserveObject(R_ReplaceFunsTable);
 3257|       |
 3258|      2|    R_SubsetSym = install("[");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 3259|      2|    R_SubassignSym = install("[<-");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 3260|      2|    R_Subset2Sym = install("[[");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 3261|      2|    R_Subassign2Sym = install("[[<-");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 3262|      2|    R_DollarGetsSymbol = install("$<-");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 3263|      2|    R_valueSym = install("value");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 3264|      2|    R_AssignSym = install("<-");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 3265|       |
 3266|      2|#ifdef SUPPORT_TAILCALL
 3267|      2|    R_exec_token = CONS(install(".__EXEC__."), R_NilValue);
  ------------------
  |  |  309|      2|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3268|      2|    R_PreserveObject(R_exec_token);
 3269|      2|#endif
 3270|      2|}
do_set:
 3582|  4.30k|{
 3583|  4.30k|    SEXP lhs, rhs;
 3584|       |
 3585|  4.30k|    if (args == R_NilValue ||
  ------------------
  |  Branch (3585:9): [True: 0, False: 4.30k]
  ------------------
 3586|  4.30k|	CDR(args) == R_NilValue ||
  ------------------
  |  Branch (3586:2): [True: 0, False: 4.30k]
  ------------------
 3587|  4.30k|	CDDR(args) != R_NilValue)
  ------------------
  |  Branch (3587:2): [True: 0, False: 4.30k]
  ------------------
 3588|      0|	WrongArgCount(asym[PRIMVAL(op)]);
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
 3589|       |
 3590|  4.30k|    lhs = CAR(args);
 3591|       |
 3592|  4.30k|    switch (TYPEOF(lhs)) {
 3593|      0|    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (3593:5): [True: 0, False: 4.30k]
  ------------------
 3594|      0|	lhs = installTrChar(STRING_ELT(lhs, 0));
  ------------------
  |  |  937|      0|#define installTrChar		Rf_installTrChar
  ------------------
 3595|       |	/* fall through */
 3596|  4.27k|    case SYMSXP:
  ------------------
  |  |  112|  4.27k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (3596:5): [True: 4.27k, False: 32]
  ------------------
 3597|  4.27k|	rhs = eval(CADR(args), rho);
  ------------------
  |  |  913|  4.27k|#define eval			Rf_eval
  ------------------
 3598|  4.27k|	INCREMENT_NAMED(rhs);
  ------------------
  |  |  222|  4.27k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 4.27k]
  |  |  ------------------
  ------------------
 3599|  4.27k|	if (PRIMVAL(op) == 2)                       /* <<- */
  ------------------
  |  | 1347|  4.27k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (3599:6): [True: 6, False: 4.26k]
  ------------------
 3600|      6|	    setVar(lhs, rhs, ENCLOS(rho));
  ------------------
  |  | 1029|      6|#define setVar			Rf_setVar
  ------------------
 3601|  4.26k|	else                                        /* <-, = */
 3602|  4.26k|	    defineVar(lhs, rhs, rho);
  ------------------
  |  |  905|  4.26k|#define defineVar		Rf_defineVar
  ------------------
 3603|  4.27k|	R_Visible = FALSE;
 3604|  4.27k|	return rhs;
 3605|     32|    case LANGSXP:
  ------------------
  |  |  117|     32|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (3605:5): [True: 32, False: 4.27k]
  ------------------
 3606|     32|	R_Visible = FALSE;
 3607|     32|	return applydefine(call, op, args, rho);
 3608|      0|    default:
  ------------------
  |  Branch (3608:5): [True: 0, False: 4.30k]
  ------------------
 3609|      0|	errorcall(call, _("invalid (do_set) left-hand side to assignment"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid (do_set) left-hand side to assignment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3610|  4.30k|    }
 3611|       |
 3612|      0|    return R_NilValue;/*NOTREACHED*/
 3613|  4.30k|}
Rf_evalList:
 3635|  5.74k|{
 3636|  5.74k|    SEXP head, tail, ev, h, val;
 3637|       |
 3638|  5.74k|    head = R_NilValue;
 3639|  5.74k|    tail = R_NilValue; /* to prevent uninitialized variable warnings */
 3640|       |
 3641|  15.1k|    while (el != R_NilValue) {
  ------------------
  |  Branch (3641:12): [True: 9.36k, False: 5.74k]
  ------------------
 3642|  9.36k|	n++;
 3643|       |
 3644|  9.36k|	if (CAR(el) == R_DotsSymbol) {
  ------------------
  |  Branch (3644:6): [True: 222, False: 9.14k]
  ------------------
 3645|       |	    /* If we have a ... symbol, we look to see what it is bound to.
 3646|       |	     * If its binding is Null (i.e. zero length)
 3647|       |	     *	we just ignore it and return the cdr with all its expressions evaluated;
 3648|       |	     * if it is bound to a ... list of promises,
 3649|       |	     *	we force all the promises and then splice
 3650|       |	     *	the list of resulting values into the return value.
 3651|       |	     * Anything else bound to a ... symbol is an error
 3652|       |	     */
 3653|    222|	    PROTECT(h = R_findVar(CAR(el), rho));
  ------------------
  |  |  357|    222|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3654|    222|	    if (TYPEOF(h) == DOTSXP || h == R_NilValue) {
  ------------------
  |  |  127|    444|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (3654:10): [True: 154, False: 68]
  |  Branch (3654:33): [True: 0, False: 68]
  ------------------
 3655|    358|		while (h != R_NilValue) {
  ------------------
  |  Branch (3655:10): [True: 204, False: 154]
  ------------------
 3656|    204|		    val = eval(CAR(h), rho);
  ------------------
  |  |  913|    204|#define eval			Rf_eval
  ------------------
 3657|    204|		    INCREMENT_LINKS(val);
  ------------------
  |  |  540|    204|#define INCREMENT_LINKS(x) do {			\
  |  |  541|    204|	SEXP il__x__ = (x);			\
  |  |  542|    204|	INCREMENT_NAMED(il__x__);		\
  |  |  ------------------
  |  |  |  |  222|    204|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 204]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  543|    204|	INCREMENT_REFCNT(il__x__);		\
  |  |  544|    204|    } while (0)
  |  |  ------------------
  |  |  |  Branch (544:14): [Folded, False: 204]
  |  |  ------------------
  ------------------
 3658|    204|		    ev = CONS_NR(val, R_NilValue);
 3659|    204|		    if (head == R_NilValue) {
  ------------------
  |  Branch (3659:11): [True: 84, False: 120]
  ------------------
 3660|     84|			UNPROTECT(1); /* h */
  ------------------
  |  |  358|     84|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3661|     84|			PROTECT(head = ev);
  ------------------
  |  |  357|     84|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3662|     84|			PROTECT(h); /* put current h on top of protect stack */
  ------------------
  |  |  357|     84|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3663|     84|		    }
 3664|    120|		    else
 3665|    120|			SETCDR(tail, ev);
 3666|    204|		    COPY_TAG(ev, h);
  ------------------
  |  | 3622|    204|#define COPY_TAG(to, from) do { \
  |  | 3623|    204|  SEXP __tag__ = TAG(from); \
  |  | 3624|    204|  if (__tag__ != R_NilValue) SET_TAG(to, __tag__); \
  |  |  ------------------
  |  |  |  Branch (3624:7): [True: 86, False: 118]
  |  |  ------------------
  |  | 3625|    204|} while (0)
  |  |  ------------------
  |  |  |  Branch (3625:10): [Folded, False: 204]
  |  |  ------------------
  ------------------
 3667|    204|		    tail = ev;
 3668|    204|		    h = CDR(h);
 3669|    204|		}
 3670|    154|	    }
 3671|     68|	    else if (h != R_MissingArg)
  ------------------
  |  Branch (3671:15): [True: 0, False: 68]
  ------------------
 3672|      0|		error(_("'...' used in an incorrect context"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("'...' used in an incorrect context"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3673|    222|	    UNPROTECT(1); /* h */
  ------------------
  |  |  358|    222|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3674|  9.14k|	} else if (CAR(el) == R_MissingArg) {
  ------------------
  |  Branch (3674:13): [True: 0, False: 9.14k]
  ------------------
 3675|       |	    /* It was an empty element: most likely get here from evalArgs
 3676|       |	       which may have been called on part of the args. */
 3677|      0|	    errorcall(call, _("argument %d is empty"), n);
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("argument %d is empty"), n);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3678|       |#ifdef CHECK_IS_MISSING_IN_evalList
 3679|       |	    /* Radford Neal drops this R_isMissing check in pqR in
 3680|       |	       03-zap-isMissing (but it seems to creep in again later
 3681|       |	       with helper thread stuff?)  as it takes quite a bit of
 3682|       |	       time (essentially the equivalent of evaluating the
 3683|       |	       symbol, but maybe not as efficiently as eval) and only
 3684|       |	       serves to change the error message, not always for the
 3685|       |	       better. Also, the byte code interpreter does not do
 3686|       |	       this, so dropping this makes compiled and interpreted
 3687|       |	       code more consistent. */
 3688|       |	} else if (isSymbol(CAR(el)) && R_isMissing(CAR(el), rho)) {
 3689|       |	    /* It was missing */
 3690|       |	    errorcall_cpy(call,
 3691|       |	                  _("'%s' is missing"),
 3692|       |	                  EncodeChar(PRINTNAME(CAR(el))));
 3693|       |#endif
 3694|  9.14k|	} else {
 3695|  9.14k|	    val = eval(CAR(el), rho);
  ------------------
  |  |  913|  9.14k|#define eval			Rf_eval
  ------------------
 3696|  9.14k|	    INCREMENT_LINKS(val);
  ------------------
  |  |  540|  9.14k|#define INCREMENT_LINKS(x) do {			\
  |  |  541|  9.14k|	SEXP il__x__ = (x);			\
  |  |  542|  9.14k|	INCREMENT_NAMED(il__x__);		\
  |  |  ------------------
  |  |  |  |  222|  9.14k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 9.14k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  543|  9.14k|	INCREMENT_REFCNT(il__x__);		\
  |  |  544|  9.14k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (544:14): [Folded, False: 9.14k]
  |  |  ------------------
  ------------------
 3697|  9.14k|	    ev = CONS_NR(val, R_NilValue);
 3698|  9.14k|	    if (head == R_NilValue)
  ------------------
  |  Branch (3698:10): [True: 4.70k, False: 4.44k]
  ------------------
 3699|  4.70k|		PROTECT(head = ev);
  ------------------
  |  |  357|  4.70k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3700|  4.44k|	    else
 3701|  4.44k|		SETCDR(tail, ev);
 3702|  9.14k|	    COPY_TAG(ev, el);
  ------------------
  |  | 3622|  9.14k|#define COPY_TAG(to, from) do { \
  |  | 3623|  9.14k|  SEXP __tag__ = TAG(from); \
  |  | 3624|  9.14k|  if (__tag__ != R_NilValue) SET_TAG(to, __tag__); \
  |  |  ------------------
  |  |  |  Branch (3624:7): [True: 2, False: 9.14k]
  |  |  ------------------
  |  | 3625|  9.14k|} while (0)
  |  |  ------------------
  |  |  |  Branch (3625:10): [Folded, False: 9.14k]
  |  |  ------------------
  ------------------
 3703|  9.14k|	    tail = ev;
 3704|  9.14k|	}
 3705|  9.36k|	el = CDR(el);
 3706|  9.36k|    }
 3707|       |
 3708|  14.2k|    for(el = head; el != R_NilValue; el = CDR(el))
  ------------------
  |  Branch (3708:20): [True: 8.54k, False: 5.74k]
  ------------------
 3709|  8.54k|	DECREMENT_LINKS(CAR(el));
  ------------------
  |  |  545|  8.54k|#define DECREMENT_LINKS(x) do {			\
  |  |  546|  8.54k|	SEXP dl__x__ = (x);			\
  |  |  547|  8.54k|	DECREMENT_NAMED(dl__x__);		\
  |  |  ------------------
  |  |  |  |  223|  8.54k|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (223:43): [Folded, False: 8.54k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  548|  8.54k|	DECREMENT_REFCNT(dl__x__);		\
  |  |  549|  8.54k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (549:14): [Folded, False: 8.54k]
  |  |  ------------------
  ------------------
 3710|       |
 3711|  5.74k|    if (head != R_NilValue)
  ------------------
  |  Branch (3711:9): [True: 4.78k, False: 961]
  ------------------
 3712|  4.78k|	UNPROTECT(1);
  ------------------
  |  |  358|  4.78k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3713|       |
 3714|  5.74k|    return head;
 3715|       |
 3716|  5.74k|} /* evalList() */
Rf_evalListKeepMissing:
 3723|  4.38k|{
 3724|  4.38k|    SEXP head, tail, ev, h, val;
 3725|       |
 3726|  4.38k|    head = R_NilValue;
 3727|  4.38k|    tail = R_NilValue; /* to prevent uninitialized variable warnings */
 3728|       |
 3729|  8.79k|    while (el != R_NilValue) {
  ------------------
  |  Branch (3729:12): [True: 4.40k, False: 4.38k]
  ------------------
 3730|       |
 3731|       |	/* If we have a ... symbol, we look to see what it is bound to.
 3732|       |	 * If its binding is Null (i.e. zero length)
 3733|       |	 *	we just ignore it and return the cdr with all its expressions evaluated;
 3734|       |	 * if it is bound to a ... list of promises,
 3735|       |	 *	we force all the promises and then splice
 3736|       |	 *	the list of resulting values into the return value.
 3737|       |	 * Anything else bound to a ... symbol is an error
 3738|       |	*/
 3739|  4.40k|	if (CAR(el) == R_DotsSymbol) {
  ------------------
  |  Branch (3739:6): [True: 0, False: 4.40k]
  ------------------
 3740|      0|	    PROTECT(h = R_findVar(CAR(el), rho));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3741|      0|	    if (TYPEOF(h) == DOTSXP || h == R_NilValue) {
  ------------------
  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (3741:10): [True: 0, False: 0]
  |  Branch (3741:33): [True: 0, False: 0]
  ------------------
 3742|      0|		while (h != R_NilValue) {
  ------------------
  |  Branch (3742:10): [True: 0, False: 0]
  ------------------
 3743|      0|		    if (CAR(h) == R_MissingArg)
  ------------------
  |  Branch (3743:11): [True: 0, False: 0]
  ------------------
 3744|      0|			val = R_MissingArg;
 3745|      0|		    else
 3746|      0|			val = eval(CAR(h), rho);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 3747|      0|		    INCREMENT_LINKS(val);
  ------------------
  |  |  540|      0|#define INCREMENT_LINKS(x) do {			\
  |  |  541|      0|	SEXP il__x__ = (x);			\
  |  |  542|      0|	INCREMENT_NAMED(il__x__);		\
  |  |  ------------------
  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  543|      0|	INCREMENT_REFCNT(il__x__);		\
  |  |  544|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (544:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3748|      0|		    ev = CONS_NR(val, R_NilValue);
 3749|      0|		    if (head == R_NilValue) {
  ------------------
  |  Branch (3749:11): [True: 0, False: 0]
  ------------------
 3750|      0|			UNPROTECT(1); /* h */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3751|      0|			PROTECT(head = ev);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3752|      0|			PROTECT(h);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3753|      0|		    } else
 3754|      0|			SETCDR(tail, ev);
 3755|      0|		    COPY_TAG(ev, h);
  ------------------
  |  | 3622|      0|#define COPY_TAG(to, from) do { \
  |  | 3623|      0|  SEXP __tag__ = TAG(from); \
  |  | 3624|      0|  if (__tag__ != R_NilValue) SET_TAG(to, __tag__); \
  |  |  ------------------
  |  |  |  Branch (3624:7): [True: 0, False: 0]
  |  |  ------------------
  |  | 3625|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (3625:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3756|      0|		    tail = ev;
 3757|      0|		    h = CDR(h);
 3758|      0|		}
 3759|      0|	    }
 3760|      0|	    else if(h != R_MissingArg)
  ------------------
  |  Branch (3760:14): [True: 0, False: 0]
  ------------------
 3761|      0|		error(_("'...' used in an incorrect context"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("'...' used in an incorrect context"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3762|      0|	    UNPROTECT(1); /* h */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3763|      0|	}
 3764|  4.40k|	else {
 3765|  4.40k|	    if (CAR(el) == R_MissingArg ||
  ------------------
  |  Branch (3765:10): [True: 4, False: 4.40k]
  ------------------
 3766|  4.40k|		(isSymbol(CAR(el)) && R_isMissing(CAR(el), rho)))
  ------------------
  |  |  953|  4.40k|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (3766:4): [True: 1.24k, False: 3.16k]
  |  Branch (3766:25): [True: 0, False: 1.24k]
  ------------------
 3767|      4|		val = R_MissingArg;
 3768|  4.40k|	    else
 3769|  4.40k|		val = eval(CAR(el), rho);
  ------------------
  |  |  913|  4.40k|#define eval			Rf_eval
  ------------------
 3770|  4.40k|	    INCREMENT_LINKS(val);
  ------------------
  |  |  540|  4.40k|#define INCREMENT_LINKS(x) do {			\
  |  |  541|  4.40k|	SEXP il__x__ = (x);			\
  |  |  542|  4.40k|	INCREMENT_NAMED(il__x__);		\
  |  |  ------------------
  |  |  |  |  222|  4.40k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 4.40k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  543|  4.40k|	INCREMENT_REFCNT(il__x__);		\
  |  |  544|  4.40k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (544:14): [Folded, False: 4.40k]
  |  |  ------------------
  ------------------
 3771|  4.40k|	    ev = CONS_NR(val, R_NilValue);
 3772|  4.40k|	    if (head==R_NilValue)
  ------------------
  |  Branch (3772:10): [True: 4.38k, False: 20]
  ------------------
 3773|  4.38k|		PROTECT(head = ev);
  ------------------
  |  |  357|  4.38k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3774|     20|	    else
 3775|     20|		SETCDR(tail, ev);
 3776|  4.40k|	    COPY_TAG(ev, el);
  ------------------
  |  | 3622|  4.40k|#define COPY_TAG(to, from) do { \
  |  | 3623|  4.40k|  SEXP __tag__ = TAG(from); \
  |  | 3624|  4.40k|  if (__tag__ != R_NilValue) SET_TAG(to, __tag__); \
  |  |  ------------------
  |  |  |  Branch (3624:7): [True: 16, False: 4.39k]
  |  |  ------------------
  |  | 3625|  4.40k|} while (0)
  |  |  ------------------
  |  |  |  Branch (3625:10): [Folded, False: 4.40k]
  |  |  ------------------
  ------------------
 3777|  4.40k|	    tail = ev;
 3778|  4.40k|	}
 3779|  4.40k|	el = CDR(el);
 3780|  4.40k|    }
 3781|       |
 3782|  8.79k|    for(el = head; el != R_NilValue; el = CDR(el))
  ------------------
  |  Branch (3782:20): [True: 4.40k, False: 4.38k]
  ------------------
 3783|  4.40k|	DECREMENT_LINKS(CAR(el));
  ------------------
  |  |  545|  4.40k|#define DECREMENT_LINKS(x) do {			\
  |  |  546|  4.40k|	SEXP dl__x__ = (x);			\
  |  |  547|  4.40k|	DECREMENT_NAMED(dl__x__);		\
  |  |  ------------------
  |  |  |  |  223|  4.40k|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (223:43): [Folded, False: 4.40k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  548|  4.40k|	DECREMENT_REFCNT(dl__x__);		\
  |  |  549|  4.40k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (549:14): [Folded, False: 4.40k]
  |  |  ------------------
  ------------------
 3784|       |
 3785|  4.38k|    if (head!=R_NilValue)
  ------------------
  |  Branch (3785:9): [True: 4.38k, False: 0]
  ------------------
 3786|  4.38k|	UNPROTECT(1);
  ------------------
  |  |  358|  4.38k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3787|       |
 3788|  4.38k|    return head;
 3789|  4.38k|}
Rf_promiseArgs:
 3865|  1.17M|{
 3866|  1.17M|    return promiseArgsEx(el, rho, FALSE);
 3867|  1.17M|}
Rf_CheckFormals:
 3874|   385k|{
 3875|   385k|    if (isList(ls)) {
  ------------------
  |  |  951|   385k|#define isList			Rf_isList
  ------------------
  |  Branch (3875:9): [True: 385k, False: 0]
  ------------------
 3876|   770k|	for (; ls != R_NilValue; ls = CDR(ls))
  ------------------
  |  Branch (3876:9): [True: 385k, False: 385k]
  ------------------
 3877|   385k|	    if (TYPEOF(TAG(ls)) != SYMSXP)
  ------------------
  |  |  112|   385k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (3877:10): [True: 0, False: 385k]
  ------------------
 3878|      0|		goto err;
 3879|   385k|	return;
 3880|   385k|    }
 3881|      0| err:
 3882|      0|    error(_("invalid formal argument list for \"%s\""), name);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  error(_("invalid formal argument list for \"%s\""), name);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3883|      0|}
do_eval:
 3922|    120|{
 3923|    120|    SEXP encl, x;
 3924|    120|    volatile SEXP expr, env, tmp;
 3925|       |
 3926|    120|    int frame;
 3927|    120|    RCNTXT cntxt;
 3928|       |
 3929|    120|    checkArity(op, args);
  ------------------
  |  | 1788|    120|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 3930|    120|    expr = CAR(args);
 3931|    120|    env = CADR(args);
 3932|    120|    encl = CADDR(args);
 3933|    120|    if (isNull(encl)) {
  ------------------
  |  |  956|    120|#define isNull			Rf_isNull
  ------------------
  |  Branch (3933:9): [True: 0, False: 120]
  ------------------
 3934|       |	/* This is supposed to be defunct, but has been kept here
 3935|       |	   (and documented as such) */
 3936|      0|	encl = R_BaseEnv;
 3937|    120|    } else if ( !isEnvironment(encl) &&
  ------------------
  |  |  944|    120|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (3937:17): [True: 0, False: 120]
  ------------------
 3938|      0|		!isEnvironment((encl = simple_as_environment(encl))) ) {
  ------------------
  |  |  944|      0|#define isEnvironment		Rf_isEnvironment
  ------------------
              		!isEnvironment((encl = simple_as_environment(encl))) ) {
  ------------------
  |  | 3916|      0|#define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  ------------------
  |  |               #define simple_as_environment(arg) (IS_S4_OBJECT(arg) && (TYPEOF(arg) == OBJSXP) ? R_getS4DataSlot(arg, ENVSXP) : R_NilValue)
  |  |  ------------------
  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (3916:37): [True: 0, False: 0]
  |  |  |  Branch (3916:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (3938:3): [True: 0, False: 0]
  ------------------
 3939|      0|	error(_("invalid '%s' argument of type '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument of type '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3940|      0|	      "enclos", R_typeToChar(encl));
 3941|      0|    }
 3942|    120|    if(IS_S4_OBJECT(env) && (TYPEOF(env) == OBJSXP))
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (3942:8): [True: 0, False: 120]
  |  Branch (3942:29): [True: 0, False: 0]
  ------------------
 3943|      0|	env = R_getS4DataSlot(env, ANYSXP); /* usually an ENVSXP */
  ------------------
  |  |  128|      0|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
 3944|    120|    switch(TYPEOF(env)) {
 3945|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (3945:5): [True: 0, False: 120]
  ------------------
 3946|      0|	env = encl;     /* so eval(expr, NULL, encl) works */
 3947|       |	/* falls through */
 3948|    120|    case ENVSXP:
  ------------------
  |  |  115|    120|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (3948:5): [True: 120, False: 0]
  ------------------
 3949|    120|	PROTECT(env);	/* so we can unprotect 2 at the end */
  ------------------
  |  |  357|    120|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3950|    120|	break;
 3951|      0|    case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (3951:5): [True: 0, False: 120]
  ------------------
 3952|       |	/* This usage requires all the pairlist to be named */
 3953|      0|	env = NewEnvironment(R_NilValue, duplicate(CADR(args)), encl);
  ------------------
  |  | 1961|      0|# define NewEnvironment		Rf_NewEnvironment
  ------------------
              	env = NewEnvironment(R_NilValue, duplicate(CADR(args)), encl);
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 3954|      0|	PROTECT(env);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3955|      0|	break;
 3956|      0|    case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (3956:5): [True: 0, False: 120]
  ------------------
 3957|       |	/* PR#14035 */
 3958|      0|	x = VectorToPairListNamed(CADR(args));
 3959|      0|	for (SEXP xptr = x ; xptr != R_NilValue ; xptr = CDR(xptr))
  ------------------
  |  Branch (3959:23): [True: 0, False: 0]
  ------------------
 3960|      0|	    ENSURE_NAMEDMAX(CAR(xptr));
 3961|      0|	env = NewEnvironment(R_NilValue, x, encl);
  ------------------
  |  | 1961|      0|# define NewEnvironment		Rf_NewEnvironment
  ------------------
 3962|      0|	PROTECT(env);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3963|      0|	break;
 3964|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (3964:5): [True: 0, False: 120]
  ------------------
 3965|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (3965:5): [True: 0, False: 120]
  ------------------
 3966|      0|	if (length(env) != 1)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (3966:6): [True: 0, False: 0]
  ------------------
 3967|      0|	    error(_("numeric 'envir' arg not of length one"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("numeric 'envir' arg not of length one"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3968|      0|	frame = asInteger(env);
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
 3969|      0|	if (frame == NA_INTEGER)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (3969:6): [True: 0, False: 0]
  ------------------
 3970|      0|	    error(_("invalid '%s' argument of type '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' argument of type '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3971|      0|		  "envir", R_typeToChar(env));
 3972|      0|	PROTECT(env = R_sysframe(frame, R_GlobalContext));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3973|      0|	break;
 3974|      0|    default:
  ------------------
  |  Branch (3974:5): [True: 0, False: 120]
  ------------------
 3975|      0|	error(_("invalid '%s' argument of type '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument of type '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3976|      0|	      "envir", R_typeToChar(env));
 3977|    120|    }
 3978|       |
 3979|       |    /* isLanguage include NILSXP, and that does not need to be
 3980|       |       evaluated
 3981|       |    if (isLanguage(expr) || isSymbol(expr) || isByteCode(expr)) { */
 3982|    120|    if (TYPEOF(expr) == LANGSXP || TYPEOF(expr) == SYMSXP || isByteCode(expr)) {
  ------------------
  |  |  117|    240|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
                  if (TYPEOF(expr) == LANGSXP || TYPEOF(expr) == SYMSXP || isByteCode(expr)) {
  ------------------
  |  |  112|    132|#define SYMSXP	     1	  /* symbols */
  ------------------
                  if (TYPEOF(expr) == LANGSXP || TYPEOF(expr) == SYMSXP || isByteCode(expr)) {
  ------------------
  |  |  739|     12|#define isByteCode(x)	(TYPEOF(x)==BCODESXP)
  |  |  ------------------
  |  |  |  |  133|     12|#define BCODESXP    21    /* byte code */
  |  |  ------------------
  |  |  |  Branch (739:23): [True: 0, False: 12]
  |  |  ------------------
  ------------------
  |  Branch (3982:9): [True: 108, False: 12]
  |  Branch (3982:36): [True: 0, False: 12]
  ------------------
 3983|    108|	PROTECT(expr);
  ------------------
  |  |  357|    108|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3984|    108|	begincontext(&cntxt, CTXT_RETURN, R_GlobalContext->call,
  ------------------
  |  | 1864|    108|# define begincontext		Rf_begincontext
  ------------------
 3985|    108|	             env, rho, args, op);
 3986|    108|	if (!SETJMP(cntxt.cjmpbuf))
  ------------------
  |  | 1162|    108|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (3986:6): [True: 108, False: 0]
  ------------------
 3987|    108|	    expr = eval(expr, env);
  ------------------
  |  |  913|    108|#define eval			Rf_eval
  ------------------
 3988|      0|	else
 3989|      0|	    expr = R_ReturnedValue;
 3990|    108|	UNPROTECT(1);
  ------------------
  |  |  358|    108|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3991|    108|	PROTECT(expr);
  ------------------
  |  |  357|    108|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3992|    108|	endcontext(&cntxt);
  ------------------
  |  | 1895|    108|# define endcontext		Rf_endcontext
  ------------------
 3993|    108|	UNPROTECT(1);
  ------------------
  |  |  358|    108|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3994|    108|    }
 3995|     12|    else if (TYPEOF(expr) == EXPRSXP) {
  ------------------
  |  |  132|     12|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (3995:14): [True: 12, False: 0]
  ------------------
 3996|     12|	volatile SEXP srcrefs = getBlockSrcrefs(expr);
 3997|     12|	PROTECT(expr);
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3998|     12|	tmp = R_NilValue;
 3999|     12|	begincontext(&cntxt, CTXT_RETURN, R_GlobalContext->call,
  ------------------
  |  | 1864|     12|# define begincontext		Rf_begincontext
  ------------------
 4000|     12|	             env, rho, args, op);
 4001|     12|	if (!SETJMP(cntxt.cjmpbuf)) {
  ------------------
  |  | 1162|     12|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (4001:6): [True: 12, False: 0]
  ------------------
 4002|     12|	    int n = LENGTH(expr);
 4003|     24|	    for(int i = 0 ; i < n ; i++) {
  ------------------
  |  Branch (4003:22): [True: 12, False: 12]
  ------------------
 4004|     12|		R_Srcref = getSrcref(srcrefs, i);
 4005|     12|		tmp = eval(VECTOR_ELT(expr, i), env);
  ------------------
  |  |  913|     12|#define eval			Rf_eval
  ------------------
 4006|     12|	    }
 4007|     12|	}
 4008|      0|	else
 4009|      0|	    tmp = R_ReturnedValue;
 4010|     12|	UNPROTECT(1);
  ------------------
  |  |  358|     12|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4011|     12|	PROTECT(tmp);
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4012|     12|	endcontext(&cntxt);
  ------------------
  |  | 1895|     12|# define endcontext		Rf_endcontext
  ------------------
 4013|     12|	UNPROTECT(1);
  ------------------
  |  |  358|     12|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4014|     12|	expr = tmp;
 4015|     12|    }
 4016|      0|    else if( TYPEOF(expr) == PROMSXP ) {
  ------------------
  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (4016:14): [True: 0, False: 0]
  ------------------
 4017|      0|	expr = eval(expr, rho);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 4018|      0|    } /* else expr is returned unchanged */
 4019|    120|    UNPROTECT(1);
  ------------------
  |  |  358|    120|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4020|    120|    return expr;
 4021|    120|}
Rf_DispatchAnyOrEval:
 4102|   773k|{
 4103|   773k|    if(R_has_methods(op)) {
  ------------------
  |  Branch (4103:8): [True: 0, False: 773k]
  ------------------
 4104|      0|	SEXP argValue, el,  value;
 4105|       |	/* Rboolean hasS4 = FALSE; */
 4106|      0|	int nprotect = 0, dispatch;
 4107|      0|	if(!argsevald) {
  ------------------
  |  Branch (4107:5): [True: 0, False: 0]
  ------------------
 4108|      0|	    PROTECT(argValue = evalArgs(args, rho, dropmissing, call, 0));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4109|      0|	    nprotect++;
 4110|      0|	    argsevald = TRUE;
 4111|      0|	}
 4112|      0|	else argValue = args;
 4113|      0|	for(el = argValue; el != R_NilValue; el = CDR(el)) {
  ------------------
  |  Branch (4113:21): [True: 0, False: 0]
  ------------------
 4114|      0|	    if(IS_S4_OBJECT(CAR(el))) {
  ------------------
  |  Branch (4114:9): [True: 0, False: 0]
  ------------------
 4115|      0|		value = R_possible_dispatch(call, op, argValue, rho, TRUE);
 4116|      0|		if(value) {
  ------------------
  |  Branch (4116:6): [True: 0, False: 0]
  ------------------
 4117|      0|		    *ans = value;
 4118|      0|		    UNPROTECT(nprotect);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4119|      0|		    return 1;
 4120|      0|		}
 4121|      0|		else break;
 4122|      0|	    }
 4123|      0|	}
 4124|       |	 /* else, use the regular DispatchOrEval, but now with evaluated args */
 4125|      0|	dispatch = DispatchOrEval(call, op, generic, argValue, rho, ans, dropmissing, argsevald);
  ------------------
  |  | 1887|      0|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
 4126|      0|	UNPROTECT(nprotect);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4127|      0|	return dispatch;
 4128|      0|    }
 4129|   773k|    return DispatchOrEval(call, op, generic, args, rho, ans, dropmissing, argsevald);
  ------------------
  |  | 1887|   773k|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
 4130|   773k|}
Rf_DispatchOrEval:
 4145|  3.09M|{
 4146|       |/* DispatchOrEval is called very frequently, most often in cases where
 4147|       |   no dispatching is needed and the isObject or the string-based
 4148|       |   pre-test fail.  To avoid degrading performance it is therefore
 4149|       |   necessary to avoid creating promises in these cases.  The pre-test
 4150|       |   does require that we look at the first argument, so that needs to
 4151|       |   be evaluated.  The complicating factor is that the first argument
 4152|       |   might come in with a "..." and that there might be other arguments
 4153|       |   in the "..." as well.  LT */
 4154|       |
 4155|  3.09M|    SEXP x = R_NilValue;
 4156|  3.09M|    int dots = FALSE, nprotect = 0;;
 4157|       |
 4158|  3.09M|    if( argsevald )
  ------------------
  |  Branch (4158:9): [True: 3.09M, False: 1.93k]
  ------------------
 4159|  3.09M|	{PROTECT(x = CAR(args)); nprotect++;}
  ------------------
  |  |  357|  3.09M|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4160|  1.93k|    else {
 4161|       |	/* Find the object to dispatch on, dropping any leading
 4162|       |	   ... arguments with missing or empty values.  If there are no
 4163|       |	   arguments, R_NilValue is used. */
 4164|  1.93k|	for (; args != R_NilValue; args = CDR(args)) {
  ------------------
  |  Branch (4164:9): [True: 1.93k, False: 0]
  ------------------
 4165|  1.93k|	    if (CAR(args) == R_DotsSymbol) {
  ------------------
  |  Branch (4165:10): [True: 0, False: 1.93k]
  ------------------
 4166|      0|		SEXP h = R_findVar(R_DotsSymbol, rho);
 4167|      0|		if (TYPEOF(h) == DOTSXP) {
  ------------------
  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (4167:7): [True: 0, False: 0]
  ------------------
 4168|       |#ifdef DODO
 4169|       |		    /**** any self-evaluating value should be OK; this
 4170|       |			  is used in byte compiled code. LT */
 4171|       |		    /* just a consistency check */
 4172|       |		    if (TYPEOF(CAR(h)) != PROMSXP)
 4173|       |			error(_("value in '...' is not a promise"));
 4174|       |#endif
 4175|      0|		    dots = TRUE;
 4176|      0|		    x = eval(CAR(h), rho);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 4177|      0|		    break;
 4178|      0|		}
 4179|      0|		else if (h != R_NilValue && h != R_MissingArg)
  ------------------
  |  Branch (4179:12): [True: 0, False: 0]
  |  Branch (4179:31): [True: 0, False: 0]
  ------------------
 4180|      0|		    error(_("'...' used in an incorrect context"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("'...' used in an incorrect context"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4181|      0|	    }
 4182|  1.93k|	    else {
 4183|  1.93k|		dots = FALSE;
 4184|  1.93k|		x = eval(CAR(args), rho);
  ------------------
  |  |  913|  1.93k|#define eval			Rf_eval
  ------------------
 4185|  1.93k|		break;
 4186|  1.93k|	    }
 4187|  1.93k|	}
 4188|  1.93k|	PROTECT(x); nprotect++;
  ------------------
  |  |  357|  1.93k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4189|  1.93k|    }
 4190|       |	/* try to dispatch on the object */
 4191|  3.09M|    if( isObject(x) ) {
  ------------------
  |  |  959|  3.09M|#define isObject		Rf_isObject
  ------------------
  |  Branch (4191:9): [True: 1.05k, False: 3.09M]
  ------------------
 4192|       |	/* Try for formal method. */
 4193|  1.05k|	if(IS_S4_OBJECT(x) && R_has_methods(op)) {
  ------------------
  |  Branch (4193:5): [True: 0, False: 1.05k]
  |  Branch (4193:24): [True: 0, False: 0]
  ------------------
 4194|      0|	    SEXP value, argValue;
 4195|       |	    /* create a promise to pass down to applyClosure  */
 4196|      0|	    if(!argsevald) {
  ------------------
  |  Branch (4196:9): [True: 0, False: 0]
  ------------------
 4197|      0|		argValue = promiseArgs(args, rho);
  ------------------
  |  | 1978|      0|# define promiseArgs		Rf_promiseArgs
  ------------------
 4198|      0|		IF_PROMSXP_SET_PRVALUE(CAR(argValue), x);
 4199|      0|	    } else argValue = args;
 4200|      0|	    PROTECT(argValue); nprotect++;
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4201|       |	    /* This means S4 dispatch */
 4202|      0|	    value = R_possible_dispatch(call, op, argValue, rho, TRUE);
 4203|      0|	    if(value) {
  ------------------
  |  Branch (4203:9): [True: 0, False: 0]
  ------------------
 4204|      0|		*ans = value;
 4205|      0|		UNPROTECT(nprotect);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4206|      0|		return 1;
 4207|      0|	    }
 4208|      0|	    else {
 4209|       |		/* go on, with the evaluated args.  Not guaranteed to have
 4210|       |		   the same semantics as if the arguments were not
 4211|       |		   evaluated, in special cases (e.g., arg values that are
 4212|       |		   LANGSXP).
 4213|       |		   The use of the promiseArgs is supposed to prevent
 4214|       |		   multiple evaluation after the call to possible_dispatch.
 4215|       |		*/
 4216|      0|		if (dots)
  ------------------
  |  Branch (4216:7): [True: 0, False: 0]
  ------------------
 4217|      0|		    PROTECT(argValue = evalArgs(argValue, rho, dropmissing,
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4218|      0|						call, 0));
 4219|      0|		else {
 4220|      0|		    PROTECT(argValue = CONS_NR(x, evalArgs(CDR(argValue), rho,
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4221|      0|							   dropmissing, call, 1)));
 4222|      0|		    SET_TAG(argValue, CreateTag(TAG(args)));
  ------------------
  |  |  904|      0|#define CreateTag		Rf_CreateTag
  ------------------
 4223|      0|		}
 4224|      0|		nprotect++;
 4225|      0|		args = argValue;
 4226|      0|		argsevald = 1;
 4227|      0|	    }
 4228|      0|	}
 4229|  1.05k|	const char *pt;
 4230|  1.05k|	if (TYPEOF(CAR(call)) == SYMSXP)
  ------------------
  |  |  112|  1.05k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (4230:6): [True: 1.05k, False: 0]
  ------------------
 4231|  1.05k|	    pt = Rf_strrchr_const(CHAR(PRINTNAME(CAR(call))), '.');
  ------------------
  |  |  203|  1.05k|#define CHAR(x) R_CHAR(x)
  ------------------
 4232|      0|	else
 4233|      0|	    pt = NULL;
 4234|       |
 4235|  1.05k|	if (pt == NULL || strcmp(pt,".default")) {
  ------------------
  |  Branch (4235:6): [True: 1.00k, False: 50]
  |  Branch (4235:20): [True: 34, False: 16]
  ------------------
 4236|  1.04k|	    RCNTXT cntxt;
 4237|  1.04k|	    SEXP pargs, rho1;
 4238|  1.04k|	    PROTECT(pargs = promiseArgs(args, rho)); nprotect++;
  ------------------
  |  |  357|  1.04k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4239|       |	    /* The context set up here is needed because of the way
 4240|       |	       usemethod() is written.  DispatchGroup() repeats some
 4241|       |	       internal usemethod() code and avoids the need for a
 4242|       |	       context; perhaps the usemethod() code should be
 4243|       |	       refactored so the contexts around the usemethod() calls
 4244|       |	       in this file can be removed.
 4245|       |
 4246|       |	       Using rho for current and calling environment can be
 4247|       |	       confusing for things like sys.parent() calls captured
 4248|       |	       in promises (Gabor G had an example of this).  Also,
 4249|       |	       since the context is established without a SETJMP using
 4250|       |	       an R-accessible environment allows a segfault to be
 4251|       |	       triggered (by something very obscure, but still).
 4252|       |	       Hence here and in the other usemethod() uses below a
 4253|       |	       new environment rho1 is created and used.  LT */
 4254|  1.04k|	    PROTECT(rho1 = NewEnvironment(R_NilValue, R_NilValue, rho)); nprotect++;
  ------------------
  |  |  357|  1.04k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4255|  1.04k|	    IF_PROMSXP_SET_PRVALUE(CAR(pargs), x);
 4256|  1.04k|	    begincontext(&cntxt, CTXT_RETURN, call, rho1, rho, pargs, op);
  ------------------
  |  | 1864|  1.04k|# define begincontext		Rf_begincontext
  ------------------
 4257|  1.04k|	    if(usemethod(generic, x, call, pargs, rho1, rho, R_BaseEnv, ans))
  ------------------
  |  | 2005|  1.04k|# define usemethod		Rf_usemethod
  ------------------
  |  Branch (4257:9): [True: 18, False: 1.02k]
  ------------------
 4258|     18|	    {
 4259|     18|		endcontext(&cntxt);
  ------------------
  |  | 1895|     18|# define endcontext		Rf_endcontext
  ------------------
 4260|     18|		UNPROTECT(nprotect);
  ------------------
  |  |  358|     18|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4261|     18|#ifdef ADJUST_ENVIR_REFCNTS
 4262|     18|		R_CleanupEnvir(rho1, *ans);
 4263|     18|		unpromiseArgs(pargs);
 4264|     18|#endif
 4265|     18|		return 1;
 4266|     18|	    }
 4267|  1.02k|	    endcontext(&cntxt);
  ------------------
  |  | 1895|  1.02k|# define endcontext		Rf_endcontext
  ------------------
 4268|  1.02k|#ifdef ADJUST_ENVIR_REFCNTS
 4269|  1.02k|	    R_CleanupEnvir(rho1, R_NilValue);
 4270|  1.02k|	    unpromiseArgs(pargs);
 4271|  1.02k|#endif
 4272|  1.02k|	}
 4273|  1.05k|    }
 4274|  3.09M|    if(!argsevald) {
  ------------------
  |  Branch (4274:8): [True: 1.93k, False: 3.09M]
  ------------------
 4275|  1.93k|	if (dots)
  ------------------
  |  Branch (4275:6): [True: 0, False: 1.93k]
  ------------------
 4276|       |	    /* The first call argument was ... and may contain more than the
 4277|       |	       object, so it needs to be evaluated here.  The object should be
 4278|       |	       in a promise, so evaluating it again should be no problem. */
 4279|      0|	    *ans = evalArgs(args, rho, dropmissing, call, 0);
 4280|  1.93k|	else {
 4281|  1.93k|	    INCREMENT_LINKS(x);
  ------------------
  |  |  540|  1.93k|#define INCREMENT_LINKS(x) do {			\
  |  |  541|  1.93k|	SEXP il__x__ = (x);			\
  |  |  542|  1.93k|	INCREMENT_NAMED(il__x__);		\
  |  |  ------------------
  |  |  |  |  222|  1.93k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 1.93k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  543|  1.93k|	INCREMENT_REFCNT(il__x__);		\
  |  |  544|  1.93k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (544:14): [Folded, False: 1.93k]
  |  |  ------------------
  ------------------
 4282|  1.93k|	    PROTECT(*ans = CONS_NR(x, evalArgs(CDR(args), rho, dropmissing, call, 1)));
  ------------------
  |  |  357|  1.93k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4283|  1.93k|	    DECREMENT_LINKS(x);
  ------------------
  |  |  545|  1.93k|#define DECREMENT_LINKS(x) do {			\
  |  |  546|  1.93k|	SEXP dl__x__ = (x);			\
  |  |  547|  1.93k|	DECREMENT_NAMED(dl__x__);		\
  |  |  ------------------
  |  |  |  |  223|  1.93k|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (223:43): [Folded, False: 1.93k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  548|  1.93k|	DECREMENT_REFCNT(dl__x__);		\
  |  |  549|  1.93k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (549:14): [Folded, False: 1.93k]
  |  |  ------------------
  ------------------
 4284|  1.93k|	    SET_TAG(*ans, CreateTag(TAG(args)));
  ------------------
  |  |  904|  1.93k|#define CreateTag		Rf_CreateTag
  ------------------
 4285|  1.93k|	    UNPROTECT(1);
  ------------------
  |  |  358|  1.93k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4286|  1.93k|	}
 4287|  1.93k|    }
 4288|  3.09M|    else *ans = args;
 4289|  3.09M|    UNPROTECT(nprotect);
  ------------------
  |  |  358|  3.09M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4290|  3.09M|    return 0;
 4291|  3.09M|}
Rf_DispatchGroup:
 4387|  1.54M|{
 4388|       |    /* pre-test to avoid string computations when there is nothing to
 4389|       |       dispatch on because either there is only one argument and it
 4390|       |       isn't an object or there are two or more arguments but neither
 4391|       |       of the first two is an object -- both of these cases would be
 4392|       |       rejected by the code following the string examination code
 4393|       |       below */
 4394|  1.54M|    if (args != R_NilValue && ! isObject(CAR(args)) &&
  ------------------
  |  |  959|  1.54M|#define isObject		Rf_isObject
  ------------------
  |  Branch (4394:9): [True: 1.54M, False: 0]
  |  Branch (4394:31): [True: 1.54M, False: 38]
  ------------------
 4395|  1.54M|	(CDR(args) == R_NilValue || ! isObject(CADR(args))))
  ------------------
  |  |  959|  1.54M|#define isObject		Rf_isObject
  ------------------
  |  Branch (4395:3): [True: 2.27k, False: 1.54M]
  |  Branch (4395:30): [True: 1.54M, False: 0]
  ------------------
 4396|  1.54M|	return 0;
 4397|       |
 4398|     38|    SEXP s;
 4399|     38|    Rboolean isOps = strcmp(group, "Ops") == 0 || strcmp(group, "matrixOps") == 0;
  ------------------
  |  Branch (4399:22): [True: 38, False: 0]
  |  Branch (4399:51): [True: 0, False: 0]
  ------------------
 4400|       |
 4401|       |    /* try for formal method */
 4402|     38|    if(length(args) == 1 && !IS_S4_OBJECT(CAR(args))) {
  ------------------
  |  |  987|     38|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (4402:8): [True: 0, False: 38]
  |  Branch (4402:29): [True: 0, False: 0]
  ------------------
 4403|       |	// no S4
 4404|     38|    } else if(length(args) == 2 && !IS_S4_OBJECT(CAR(args)) && !IS_S4_OBJECT(CADR(args))) {
  ------------------
  |  |  987|     38|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (4404:15): [True: 38, False: 0]
  |  Branch (4404:36): [True: 38, False: 0]
  |  Branch (4404:64): [True: 38, False: 0]
  ------------------
 4405|       |	// no S4
 4406|     38|    } else { // try to use S4 :
 4407|       |	/* Remove argument names to ensure positional matching */
 4408|      0|	if(isOps)
  ------------------
  |  Branch (4408:5): [True: 0, False: 0]
  ------------------
 4409|      0|	    for(s = args; s != R_NilValue; s = CDR(s)) SET_TAG(s, R_NilValue);
  ------------------
  |  Branch (4409:20): [True: 0, False: 0]
  ------------------
 4410|      0|	SEXP value;
 4411|      0|	if(R_has_methods(op) &&
  ------------------
  |  Branch (4411:5): [True: 0, False: 0]
  ------------------
 4412|      0|	   (value = R_possible_dispatch(call, op, args, rho, FALSE))) {
  ------------------
  |  Branch (4412:5): [True: 0, False: 0]
  ------------------
 4413|      0|	       *ans = value;
 4414|      0|	       return 1;
 4415|      0|	}
 4416|       |	/* else go on to look for S3 methods */
 4417|      0|    }
 4418|       |
 4419|       |    /* check whether we are processing the default method */
 4420|     38|    if ( isSymbol(CAR(call)) ) {
  ------------------
  |  |  953|     38|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (4420:10): [True: 38, False: 0]
  ------------------
 4421|     38|	const char *cstr = strchr(CHAR(PRINTNAME(CAR(call))), '.');
  ------------------
  |  |  203|     38|#define CHAR(x) R_CHAR(x)
  ------------------
 4422|     38|	if (cstr && !strcmp(cstr + 1, "default"))
  ------------------
  |  Branch (4422:6): [True: 0, False: 38]
  |  Branch (4422:14): [True: 0, False: 0]
  ------------------
 4423|      0|	    return 0;
 4424|     38|    }
 4425|       |
 4426|     38|    int nargs = isOps ? length(args) : 1;
  ------------------
  |  |  987|     38|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (4426:17): [True: 38, False: 0]
  ------------------
 4427|       |
 4428|     38|    if( nargs == 1 && !isObject(CAR(args)) )
  ------------------
  |  |  959|      0|#define isObject		Rf_isObject
  ------------------
  |  Branch (4428:9): [True: 0, False: 38]
  |  Branch (4428:23): [True: 0, False: 0]
  ------------------
 4429|      0|	return 0;
 4430|       |
 4431|     38|    char *generic = PRIMNAME(op);
  ------------------
  |  | 1346|     38|#define PRIMNAME(x)	(R_FunTab[PRIMOFFSET(x)].name)
  ------------------
 4432|     38|    SEXP lclass = PROTECT(classForGroupDispatch(CAR(args))), rclass;
  ------------------
  |  |  357|     38|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4433|     38|    if( nargs == 2 )
  ------------------
  |  Branch (4433:9): [True: 38, False: 0]
  ------------------
 4434|     38|	rclass = classForGroupDispatch(CADR(args));
 4435|      0|    else
 4436|      0|	rclass = R_NilValue;
 4437|     38|    PROTECT(rclass);
  ------------------
  |  |  357|     38|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4438|       |
 4439|     38|    SEXP lmeth = R_NilValue, lsxp = R_NilValue, lgr = R_NilValue,
 4440|     38|	 rmeth = R_NilValue, rsxp = R_NilValue, rgr = R_NilValue;
 4441|     38|    int lwhich, rwhich;
 4442|     38|    findmethod(lclass, group, generic,
 4443|     38|	       &lsxp, &lgr, &lmeth, &lwhich, args, rho);
 4444|     38|    PROTECT(lgr);
  ------------------
  |  |  357|     38|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4445|       |
 4446|     38|    if( nargs == 2 )
  ------------------
  |  Branch (4446:9): [True: 38, False: 0]
  ------------------
 4447|     38|	findmethod(rclass, group, generic, &rsxp, &rgr, &rmeth,
 4448|     38|		   &rwhich, CDR(args), rho);
 4449|      0|    else
 4450|      0|	rwhich = 0;
 4451|     38|    PROTECT(rgr);
  ------------------
  |  |  357|     38|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4452|       |
 4453|     38|    if( !isFunction(lsxp) && !isFunction(rsxp) ) {
  ------------------
  |  |  948|     38|#define isFunction		Rf_isFunction
  ------------------
                  if( !isFunction(lsxp) && !isFunction(rsxp) ) {
  ------------------
  |  |  948|      0|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (4453:9): [True: 0, False: 38]
  |  Branch (4453:30): [True: 0, False: 0]
  ------------------
 4454|      0|	UNPROTECT(4);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4455|      0|	return 0; /* no generic or group method so use default */
 4456|      0|    }
 4457|       |
 4458|     38|    if( lsxp != rsxp ) {
  ------------------
  |  Branch (4458:9): [True: 26, False: 12]
  ------------------
 4459|     26|	if ( isFunction(lsxp) && isFunction(rsxp) ) {
  ------------------
  |  |  948|     26|#define isFunction		Rf_isFunction
  ------------------
              	if ( isFunction(lsxp) && isFunction(rsxp) ) {
  ------------------
  |  |  948|     26|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (4459:7): [True: 26, False: 0]
  |  Branch (4459:27): [True: 0, False: 26]
  ------------------
 4460|       |	    /* special-case some methods involving difftime */
 4461|      0|	    const char *lname = CHAR(PRINTNAME(lmeth)),
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 4462|      0|		*rname = CHAR(PRINTNAME(rmeth));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 4463|      0|	    if( streql(rname, "Ops.difftime") &&
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 4464|      0|		(streql(lname, "+.POSIXt") || streql(lname, "-.POSIXt") ||
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              		(streql(lname, "+.POSIXt") || streql(lname, "-.POSIXt") ||
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 4465|      0|		 streql(lname, "+.Date") || streql(lname, "-.Date")) )
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              		 streql(lname, "+.Date") || streql(lname, "-.Date")) )
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 4466|      0|		rsxp = R_NilValue;
 4467|      0|	    else if (streql(lname, "Ops.difftime") &&
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 4468|      0|		     (streql(rname, "+.POSIXt") || streql(rname, "+.Date")) )
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              		     (streql(rname, "+.POSIXt") || streql(rname, "+.Date")) )
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 4469|      0|		lsxp = R_NilValue;
 4470|       |
 4471|       |	    /* Strict comparison, the docs requires methods to be "the same":
 4472|       |	      16 to take environments into account
 4473|       |	     1+2 for bitwise comparison of numbers
 4474|       |	       4 for the same order of attributes
 4475|       |	         bytecode ignored (can change at runtime)
 4476|       |	         srcref ignored (as per default)
 4477|       |	    */
 4478|      0|	    else if (!R_compute_identical(lsxp, rsxp, 16 + 1 + 2 + 4)) {
  ------------------
  |  Branch (4478:15): [True: 0, False: 0]
  ------------------
 4479|      0|		SEXP x = CAR(args), y = CADR(args);
 4480|      0|		if (R_chooseOpsMethod(x, y, lsxp, rsxp, call, FALSE, rho)) {
  ------------------
  |  Branch (4480:7): [True: 0, False: 0]
  ------------------
 4481|      0|		    rsxp = R_NilValue;
 4482|      0|		}
 4483|      0|		else if (R_chooseOpsMethod(y, x, rsxp, lsxp, call, TRUE, rho)) {
  ------------------
  |  Branch (4483:12): [True: 0, False: 0]
  ------------------
 4484|      0|		    lsxp = R_NilValue;
 4485|      0|		}
 4486|      0|		else {
 4487|      0|		    warning(_("Incompatible methods "
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		    warning(_("Incompatible methods "
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4488|      0|			      "(\"%s\", \"%s\") for \"%s\""),
 4489|      0|			    lname, rname, generic);
 4490|      0|		    UNPROTECT(4);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4491|      0|		    return 0;
 4492|      0|		}
 4493|      0|	    }
 4494|      0|	}
 4495|       |	/* if the right hand side is the one */
 4496|     26|	if( !isFunction(lsxp) ) { /* copy over the righthand stuff */
  ------------------
  |  |  948|     26|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (4496:6): [True: 0, False: 26]
  ------------------
 4497|      0|	    lsxp = rsxp;
 4498|      0|	    lmeth = rmeth;
 4499|      0|	    lgr = rgr;
 4500|      0|	    lclass = rclass;
 4501|      0|	    lwhich = rwhich;
 4502|      0|	}
 4503|     26|    }
 4504|       |
 4505|       |    /* we either have a group method or a class method */
 4506|       |
 4507|     38|    const void *vmax = vmaxget();
 4508|     38|    s = args;
 4509|     38|    const char *dispatchClassName = translateChar(STRING_ELT(lclass, lwhich));
  ------------------
  |  | 1037|     38|#define translateChar		Rf_translateChar
  ------------------
 4510|       |
 4511|     38|    SEXP t, m = PROTECT(allocVector(STRSXP,nargs));
  ------------------
  |  |  357|     38|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4512|    114|    for (int i = 0 ; i < nargs ; i++) {
  ------------------
  |  Branch (4512:22): [True: 76, False: 38]
  ------------------
 4513|     76|	t = classForGroupDispatch(CAR(s));
 4514|     76|	if (isString(t) && (stringPositionTr(t, dispatchClassName) >= 0))
  ------------------
  |  |  966|     76|#define isString		Rf_isString
  ------------------
              	if (isString(t) && (stringPositionTr(t, dispatchClassName) >= 0))
  ------------------
  |  | 1033|     50|#define stringPositionTr	Rf_stringPositionTr
  ------------------
  |  Branch (4514:6): [True: 50, False: 26]
  |  Branch (4514:21): [True: 50, False: 0]
  ------------------
 4515|     50|	    SET_STRING_ELT(m, i, PRINTNAME(lmeth));
 4516|     26|	else
 4517|     26|	    SET_STRING_ELT(m, i, R_BlankString);
 4518|     76|	s = CDR(s);
 4519|     76|    }
 4520|     38|    vmaxset(vmax);
 4521|       |
 4522|     38|    SEXP newvars = PROTECT(createS3Vars(
  ------------------
  |  |  357|     38|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4523|     38|	PROTECT(mkString(generic)),
 4524|     38|	lgr,
 4525|     38|	PROTECT(stringSuffix(lclass, lwhich)),
 4526|     38|	m,
 4527|     38|	rho,
 4528|     38|	R_BaseEnv
 4529|     38|    ));
 4530|       |
 4531|     38|    PROTECT(t = LCONS(lmeth, CDR(call)));
  ------------------
  |  |  357|     38|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4532|       |
 4533|       |    /* the arguments have been evaluated; since we are passing them */
 4534|       |    /* out to a closure we need to wrap them in promises so that */
 4535|       |    /* they get duplicated and things like missing/substitute work. */
 4536|       |
 4537|     38|    PROTECT(s = promiseArgs(CDR(call), rho));
  ------------------
  |  |  357|     38|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4538|     38|    if (length(s) != length(args))
  ------------------
  |  |  987|     38|#define length(x)		Rf_length(x)
  ------------------
                  if (length(s) != length(args))
  ------------------
  |  |  987|     38|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (4538:9): [True: 0, False: 38]
  ------------------
 4539|      0|	error(_("dispatch error in group dispatch"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("dispatch error in group dispatch"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4540|    114|    for (m = s ; m != R_NilValue ; m = CDR(m), args = CDR(args) ) {
  ------------------
  |  Branch (4540:18): [True: 76, False: 38]
  ------------------
 4541|     76|	IF_PROMSXP_SET_PRVALUE(CAR(m), CAR(args));
 4542|       |	/* ensure positional matching for operators */
 4543|     76|	if(isOps) SET_TAG(m, R_NilValue);
  ------------------
  |  Branch (4543:5): [True: 76, False: 0]
  ------------------
 4544|     76|    }
 4545|       |
 4546|     38|    *ans = applyClosure(t, lsxp, s, rho, newvars, TRUE);
  ------------------
  |  |  879|     38|#define applyClosure		Rf_applyClosure
  ------------------
 4547|     38|    UNPROTECT(10);
  ------------------
  |  |  358|     38|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4548|     38|    return 1;
 4549|     38|}
R_initialize_bcode:
 4595|      2|{
 4596|      2|  R_AddSym = install("+");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4597|      2|  R_SubSym = install("-");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4598|      2|  R_MulSym = install("*");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4599|      2|  R_DivSym = install("/");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4600|      2|  R_ExptSym = install("^");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4601|      2|  R_SqrtSym = install("sqrt");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4602|      2|  R_ExpSym = install("exp");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4603|      2|  R_EqSym = install("==");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4604|      2|  R_NeSym = install("!=");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4605|      2|  R_LtSym = install("<");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4606|      2|  R_LeSym = install("<=");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4607|      2|  R_GeSym = install(">=");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4608|      2|  R_GtSym = install(">");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4609|      2|  R_AndSym = install("&");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4610|      2|  R_OrSym = install("|");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4611|      2|  R_NotSym = install("!");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4612|      2|  R_CSym = install("c");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4613|      2|  R_LogSym = install("log");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4614|      2|  R_DotInternalSym = install(".Internal");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4615|      2|  R_DotExternalSym = install(".External");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4616|      2|  R_DotExternal2Sym = install(".External2");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4617|      2|  R_DotExternalgraphicsSym = install(".External.graphics");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4618|      2|  R_DotCallSym = install(".Call");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4619|      2|  R_DotCallgraphicsSym = install(".Call.graphics");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4620|      2|  R_DotFortranSym = install(".Fortran");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4621|      2|  R_DotCSym = install(".C");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 4622|       |
 4623|      2|  bcEval_init();
 4624|       |
 4625|       |  /* the first constants record always stays in place for protection */
 4626|      2|  R_ConstantsRegistry = allocVector(VECSXP, 2);
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
                R_ConstantsRegistry = allocVector(VECSXP, 2);
  ------------------
  |  |  131|      2|#define VECSXP	    19	  /* generic vectors */
  ------------------
 4627|      2|  R_PreserveObject(R_ConstantsRegistry);
 4628|      2|  SET_VECTOR_ELT(R_ConstantsRegistry, 0, R_NilValue);
 4629|      2|  SET_VECTOR_ELT(R_ConstantsRegistry, 1, R_NilValue);
 4630|       |
 4631|      2|  R_BCProtCommitted = R_BCNodeStackBase;
 4632|      2|}
R_PromiseExpr:
 5614|  4.32k|{
 5615|  4.32k|    return bytecodeExpr(PRCODE(p));
 5616|  4.32k|}
R_ClosureExpr:
 5619|    135|{
 5620|    135|    return bytecodeExpr(BODY(p));
 5621|    135|}
R_BCRelPC:
 7000|  4.70M|{
 7001|       |    /* used to capture the pc offset from its codebase at the time a
 7002|       |       context is created */
 7003|  4.70M|    if (body && currentpc)
  ------------------
  |  Branch (7003:9): [True: 4.69M, False: 10.2k]
  |  Branch (7003:17): [True: 4.69M, False: 0]
  ------------------
 7004|  4.69M|	return *((BCODE **) currentpc) - BCCODE(body);
  ------------------
  |  | 5659|  4.69M|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  ------------------
  |  |  |  |  736|  4.69M|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  ------------------
  ------------------
 7005|  10.2k|    else
 7006|  10.2k|	return -1;
 7007|  4.70M|}
R_findBCInterpreterSrcref:
 7036|     18|{
 7037|     18|    return R_findBCInterpreterLocation(cptr, "srcrefsIndex");
 7038|     18|}
R_getBCInterpreterExpression:
 7147|   385k|{
 7148|   385k|    SEXP exp = R_findBCInterpreterExpression();
 7149|   385k|    if (TYPEOF(exp) == PROMSXP) {
  ------------------
  |  |  116|   385k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (7149:9): [True: 0, False: 385k]
  ------------------
 7150|      0|	ENSURE_PROMISE_IS_EVALUATED(exp);
  ------------------
  |  |  946|      0|#define ENSURE_PROMISE_IS_EVALUATED(x) do {	\
  |  |  947|      0|	SEXP __x__ = (x);			\
  |  |  948|      0|	if (! PROMISE_IS_EVALUATED(__x__))	\
  |  |  ------------------
  |  |  |  Branch (948:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|	    forcePromise(__x__);		\
  |  |  950|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (950:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 7151|      0|	exp = PRVALUE(exp);
 7152|      0|    }
 7153|       |
 7154|       |    /* This tries to mimick the behavior of the AST interpreter to a
 7155|       |       reasonable level, based on relatively consistent expressions
 7156|       |       provided by the compiler in the constant pool. The AST
 7157|       |       interpreter behavior is rather inconsistent and should be fixed
 7158|       |       at some point. When this happens, the code below will have to
 7159|       |       be revisited, but the compiler code should mostly stay the
 7160|       |       same.
 7161|       |
 7162|       |       Currently this code attempts to bypass implementation of
 7163|       |       closure wrappers for internals and other foreign functions
 7164|       |       called via a directive, hide away primitives, but show
 7165|       |       assignment calls. This code ignores less usual problematic
 7166|       |       situations such as overriding of builtins or inlining of the
 7167|       |       wrappers by the compiler. Simple assignment calls are inflated
 7168|       |       (back) into the usual form like x[1] <- y. Expressions made of
 7169|       |       a single symbol are hidden away (note these are e.g. for
 7170|       |       missing function arguments). */
 7171|       |
 7172|   385k|    if (maybeAssignmentCall(exp)) {
  ------------------
  |  Branch (7172:9): [True: 0, False: 385k]
  ------------------
 7173|      0|	exp = inflateAssignmentCall(exp);
 7174|   385k|    } else if (TYPEOF(exp) == SYMSXP || maybeClosureWrapper(exp)
  ------------------
  |  |  112|   771k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (7174:16): [True: 0, False: 385k]
  |  Branch (7174:41): [True: 0, False: 385k]
  ------------------
 7175|   385k|	|| maybePrimitiveCall(exp)) {
  ------------------
  |  Branch (7175:5): [True: 384k, False: 1.00k]
  ------------------
 7176|       |
 7177|   384k|	RCNTXT *c = R_GlobalContext;
 7178|   384k|        while(c && c->callflag != CTXT_TOPLEVEL) {
  ------------------
  |  Branch (7178:15): [True: 384k, False: 0]
  |  Branch (7178:20): [True: 384k, False: 0]
  ------------------
 7179|   384k|	    if (c->callflag & CTXT_FUNCTION) {
  ------------------
  |  Branch (7179:10): [True: 384k, False: 0]
  ------------------
 7180|   384k|		exp = c->call;
 7181|   384k|		break;
 7182|   384k|	    }
 7183|      0|	    c = c->nextcontext;
 7184|      0|	}
 7185|   384k|    }
 7186|   385k|    return exp;
 7187|   385k|}
R_BCVersionOK:
 7198|  5.46M|{
 7199|  5.46M|    if (TYPEOF(s) != BCODESXP)
  ------------------
  |  |  133|  5.46M|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (7199:9): [True: 0, False: 5.46M]
  ------------------
 7200|      0|	return FALSE;
 7201|       |
 7202|  5.46M|    BCODE *pc = BCCODE(s);
  ------------------
  |  | 5659|  5.46M|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  ------------------
  |  |  |  |  736|  5.46M|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  ------------------
  ------------------
 7203|  5.46M|    int version = GETOP();
  ------------------
  |  | 5656|  5.46M|#define GETOP() (*pc++).i
  ------------------
 7204|       |
 7205|  5.46M|    return (version >= R_bcMinVersion && version <= R_bcVersion);
  ------------------
  |  Branch (7205:13): [True: 5.46M, False: 0]
  |  Branch (7205:42): [True: 5.46M, False: 0]
  ------------------
 7206|  5.46M|}
R_bcEncode:
 8759|  22.1k|{
 8760|  22.1k|    SEXP code;
 8761|  22.1k|    BCODE *pc;
 8762|  22.1k|    int *ipc, i, n, m, v;
 8763|       |
 8764|  22.1k|    m = (sizeof(BCODE) + sizeof(int) - 1) / sizeof(int);
 8765|       |
 8766|  22.1k|    n = LENGTH(bytes);
 8767|  22.1k|    if (n == 0)
  ------------------
  |  Branch (8767:9): [True: 0, False: 22.1k]
  ------------------
 8768|      0|	return R_NilValue;
 8769|  22.1k|    ipc = INTEGER(bytes);
 8770|       |
 8771|  22.1k|    v = ipc[0];
 8772|  22.1k|    if (v < R_bcMinVersion || v > R_bcVersion) {
  ------------------
  |  Branch (8772:9): [True: 0, False: 22.1k]
  |  Branch (8772:31): [True: 0, False: 22.1k]
  ------------------
 8773|      0|	code = allocVector(INTSXP, m * 2);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	code = allocVector(INTSXP, m * 2);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
 8774|      0|	pc = BCODE_PTR(code);
  ------------------
  |  |  736|      0|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  ------------------
 8775|      0|	pc[0].i = v;
 8776|      0|	pc[1].v = opinfo[BCMISMATCH_OP].addr;
 8777|      0|	return code;
 8778|      0|    }
 8779|  22.1k|    else {
 8780|  22.1k|	code = allocVector(INTSXP, m * n);
  ------------------
  |  |  875|  22.1k|#define allocVector		Rf_allocVector
  ------------------
              	code = allocVector(INTSXP, m * n);
  ------------------
  |  |  123|  22.1k|#define INTSXP	    13	  /* integer vectors */
  ------------------
 8781|  22.1k|	memset(INTEGER(code), 0, m * n * sizeof(int));
 8782|  22.1k|	pc = BCODE_PTR(code);
  ------------------
  |  |  736|  22.1k|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  ------------------
 8783|       |
 8784|   406k|	for (i = 0; i < n; i++) pc[i].i = ipc[i];
  ------------------
  |  Branch (8784:14): [True: 384k, False: 22.1k]
  ------------------
 8785|       |
 8786|       |	/* install the current version number */
 8787|  22.1k|	pc[0].i = R_bcVersion;
 8788|       |
 8789|       |	/* Revert to version 2 to allow for some one compiling in a
 8790|       |	   new R, loading/saving in an old one, and then trying to run
 8791|       |	   in a new one. This has happened! Setting the version number
 8792|       |	   back tells bcEval to drop back to eval. */
 8793|  22.1k|	if (n == 2 && ipc[1] == BCMISMATCH_OP)
  ------------------
  |  Branch (8793:6): [True: 0, False: 22.1k]
  |  Branch (8793:16): [True: 0, False: 0]
  ------------------
 8794|      0|	    pc[0].i = 2;
 8795|       |
 8796|   226k|	for (i = 1; i < n;) {
  ------------------
  |  Branch (8796:14): [True: 204k, False: 22.1k]
  ------------------
 8797|   204k|	    int op = pc[i].i;
 8798|   204k|	    if (op < 0 || op >= OPCOUNT)
  ------------------
  |  Branch (8798:10): [True: 0, False: 204k]
  |  Branch (8798:20): [True: 0, False: 204k]
  ------------------
 8799|      0|		error("unknown instruction code");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 8800|   204k|	    pc[i].v = opinfo[op].addr;
 8801|   204k|	    i += opinfo[op].argc + 1;
 8802|   204k|	}
 8803|       |
 8804|  22.1k|	return code;
 8805|  22.1k|    }
 8806|  22.1k|}
R_registerBC:
 8856|  22.1k|{
 8857|  22.1k|    if (R_check_constants <= 0)
  ------------------
  |  Branch (8857:9): [True: 22.1k, False: 0]
  ------------------
 8858|  22.1k|	return;
 8859|      0|    if (TYPEOF(bcBytes) != INTSXP)
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (8859:9): [True: 0, False: 0]
  ------------------
 8860|      0|	error("registerBC requires integer vector as bcBytes");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 8861|      0|    if (TYPEOF(bcode) != BCODESXP)
  ------------------
  |  |  133|      0|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (8861:9): [True: 0, False: 0]
  ------------------
 8862|      0|	error("registerBC requires BCODESXP object as bcode");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 8863|       |
 8864|      0|    static int count = CONST_CHECK_COUNT;
  ------------------
  |  | 8854|      0|#define CONST_CHECK_COUNT 1000
  ------------------
 8865|      0|    if (--count <= 0) {
  ------------------
  |  Branch (8865:9): [True: 0, False: 0]
  ------------------
 8866|      0|	count = CONST_CHECK_COUNT;
  ------------------
  |  | 8854|      0|#define CONST_CHECK_COUNT 1000
  ------------------
 8867|      0|	R_checkConstants(TRUE);
 8868|      0|    }
 8869|       |
 8870|       |    /* The constants registry is a linked list of constant records. Each
 8871|       |       constant record is a generic vector, its first element is a pointer
 8872|       |       to the next constant record, the second element is a weak reference
 8873|       |       to the byte-code object, the third element is a reference to the whole
 8874|       |       constant pool, and the following elements are interleaved original and
 8875|       |       copied constants. A constant registry corresponds to a constant pool.
 8876|       |       When the weak reference gets cleared, the respective constant record
 8877|       |       can be removed from the list.
 8878|       |
 8879|       |       One could simply compare/duplicate the lists of all constants (the whole
 8880|       |       constant pools), but that turned out too expensive */
 8881|       |
 8882|      0|    SEXP consts = BCODE_CONSTS(bcode); /* all constants, VECSXP */
  ------------------
  |  |  737|      0|#define BCODE_CONSTS(x) CDR(x)
  ------------------
 8883|       |
 8884|      0|#define CHECK_ALL_CONSTANTS
 8885|       |#ifndef CHECK_ALL_CONSTANTS
 8886|       |    int *ipc = INTEGER(bcBytes);
 8887|       |    int n = LENGTH(bcBytes);
 8888|       |    int i;
 8889|       |    int loadableConsts = 0;
 8890|       |
 8891|       |    /* add only constants loaded by certain instructions  */
 8892|       |    for(i = 0; i < n; i += opinfo[ipc[i]].argc + 1)
 8893|       |        if (ipc[i] == LDCONST_OP || ipc[i] == PUSHCONSTARG_OP ||
 8894|       |		ipc[i] == CALLSPECIAL_OP)
 8895|       |            loadableConsts++;
 8896|       |
 8897|       |    SEXP constsRecord = PROTECT(allocVector(VECSXP, loadableConsts * 2 + 3));
 8898|       |    int crIdx = 3;
 8899|       |    for(i = 0; i < n; i += opinfo[ipc[i]].argc + 1)
 8900|       |        if (ipc[i] == LDCONST_OP || ipc[i] == PUSHCONSTARG_OP ||
 8901|       |		ipc[i] == CALLSPECIAL_OP) {
 8902|       |            SEXP corig = VECTOR_ELT(consts, ipc[i + 1]);
 8903|       |            SET_VECTOR_ELT(constsRecord, crIdx++, corig);
 8904|       |            SET_VECTOR_ELT(constsRecord, crIdx++, duplicate(corig));
 8905|       |        }
 8906|       |#else
 8907|       |    /* add the whole constant pool */
 8908|      0|    SEXP constsRecord = PROTECT(allocVector(VECSXP, 2 + 3));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 8909|      0|    SET_VECTOR_ELT(constsRecord, 3, consts);
 8910|       |    /* the consts reference is in the record twice to make the code simpler */
 8911|      0|    SET_VECTOR_ELT(constsRecord, 4, duplicate(consts));
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 8912|      0|#endif
 8913|       |
 8914|      0|    SEXP wref = R_MakeWeakRef(bcode, R_NilValue, R_NilValue, FALSE);
 8915|      0|    SET_VECTOR_ELT(constsRecord, 0, VECTOR_ELT(R_ConstantsRegistry, 0));
 8916|      0|    SET_VECTOR_ELT(constsRecord, 1, wref);
 8917|      0|    SET_VECTOR_ELT(constsRecord, 2, consts);
 8918|      0|    SET_VECTOR_ELT(R_ConstantsRegistry, 0, constsRecord);
 8919|      0|    UNPROTECT(1); /* constsRecord */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 8920|      0|}
R_checkConstants:
 9025|  1.01k|{
 9026|  1.01k|    if (R_check_constants <= 0 || R_ConstantsRegistry == NULL)
  ------------------
  |  Branch (9026:9): [True: 1.01k, False: 0]
  |  Branch (9026:35): [True: 0, False: 0]
  ------------------
 9027|  1.01k|	return TRUE;
 9028|       |
 9029|      0|    static Rboolean checkingInProgress = FALSE;
 9030|      0|    RCNTXT cntxt;
 9031|       |
 9032|      0|    if (checkingInProgress)
  ------------------
  |  Branch (9032:9): [True: 0, False: 0]
  ------------------
 9033|       |	/* recursive invocation is possible because of allocation
 9034|       |           in R_compute_identical */
 9035|      0|	return TRUE;
 9036|       |
 9037|       |    /* set up context to recover checkingInProgress */
 9038|      0|    begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
  ------------------
  |  | 1864|      0|# define begincontext		Rf_begincontext
  ------------------
 9039|      0|                 R_NilValue, R_NilValue);
 9040|      0|    cntxt.cend = &const_cleanup;
 9041|      0|    cntxt.cenddata = &checkingInProgress;
 9042|       |
 9043|      0|    checkingInProgress = TRUE;
 9044|      0|    SEXP prev_crec = R_ConstantsRegistry;
 9045|      0|    SEXP crec = VECTOR_ELT(prev_crec, 0);
 9046|      0|    Rboolean constsOK = TRUE;
 9047|      0|    while(crec != R_NilValue) {
  ------------------
  |  Branch (9047:11): [True: 0, False: 0]
  ------------------
 9048|      0|	SEXP wref = VECTOR_ELT(crec, 1);
 9049|      0|	SEXP bc = R_WeakRefKey(wref);
 9050|      0|	if (!checkConstantsInRecord(crec, abortOnError))
  ------------------
  |  Branch (9050:6): [True: 0, False: 0]
  ------------------
 9051|      0|	    constsOK = FALSE;
 9052|      0|	if (bc == R_NilValue)
  ------------------
  |  Branch (9052:6): [True: 0, False: 0]
  ------------------
 9053|       |	    /* remove no longer needed record from the registry */
 9054|      0|	    SET_VECTOR_ELT(prev_crec, 0, VECTOR_ELT(crec, 0));
 9055|      0|	else
 9056|      0|            prev_crec = crec;
 9057|      0|	crec = VECTOR_ELT(crec, 0);
 9058|      0|    }
 9059|      0|    endcontext(&cntxt);
  ------------------
  |  | 1895|      0|# define endcontext		Rf_endcontext
  ------------------
 9060|      0|    checkingInProgress = FALSE;
 9061|      0|    return constsOK;
 9062|      0|}
do_mkcode:
 9065|     11|{
 9066|     11|    SEXP bytes, consts, ans;
 9067|       |
 9068|     11|    checkArity(op, args);
  ------------------
  |  | 1788|     11|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 9069|     11|    bytes = CAR(args);
 9070|     11|    consts = CADR(args);
 9071|     11|    ans = PROTECT(CONS(R_bcEncode(bytes), consts));
  ------------------
  |  |  357|     11|#define PROTECT(s)	Rf_protect(s)
  ------------------
 9072|     11|    SET_TYPEOF(ans, BCODESXP);
  ------------------
  |  |  133|     11|#define BCODESXP    21    /* byte code */
  ------------------
 9073|     11|    R_registerBC(bytes, ans);
 9074|     11|    UNPROTECT(1); /* ans */
  ------------------
  |  |  358|     11|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 9075|     11|    return ans;
 9076|     11|}
do_bcclose:
 9079|      1|{
 9080|      1|    SEXP forms, body, env;
 9081|       |
 9082|      1|    checkArity(op, args);
  ------------------
  |  | 1788|      1|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 9083|      1|    forms = CAR(args);
 9084|      1|    body = CADR(args);
 9085|      1|    env = CADDR(args);
 9086|       |
 9087|      1|    CheckFormals(forms, "bcClose");
  ------------------
  |  | 1868|      1|# define CheckFormals		Rf_CheckFormals
  ------------------
 9088|       |
 9089|      1|    if (! isByteCode(body))
  ------------------
  |  |  739|      1|#define isByteCode(x)	(TYPEOF(x)==BCODESXP)
  |  |  ------------------
  |  |  |  |  133|      1|#define BCODESXP    21    /* byte code */
  |  |  ------------------
  ------------------
  |  Branch (9089:9): [True: 0, False: 1]
  ------------------
 9090|      0|	error(_("invalid body"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid body"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 9091|       |
 9092|      1|    if (isNull(env)) {
  ------------------
  |  |  956|      1|#define isNull			Rf_isNull
  ------------------
  |  Branch (9092:9): [True: 0, False: 1]
  ------------------
 9093|      0|	error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 9094|      0|	env = R_BaseEnv;
 9095|      0|    } else
 9096|      1|    if (!isEnvironment(env))
  ------------------
  |  |  944|      1|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (9096:9): [True: 0, False: 1]
  ------------------
 9097|      0|	error(_("invalid environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 9098|       |
 9099|      1|    return mkCLOSXP(forms, body, env);
  ------------------
  |  | 1955|      1|# define mkCLOSXP		Rf_mkCLOSXP
  ------------------
 9100|      1|}
do_is_builtin_internal:
 9103|      2|{
 9104|      2|    SEXP symbol, i;
 9105|       |
 9106|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 9107|      2|    symbol = CAR(args);
 9108|       |
 9109|      2|    if (!isSymbol(symbol))
  ------------------
  |  |  953|      2|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (9109:9): [True: 0, False: 2]
  ------------------
 9110|      0|	error(_("invalid symbol"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid symbol"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 9111|       |
 9112|      2|    if ((i = INTERNAL(symbol)) != R_NilValue && TYPEOF(i) == BUILTINSXP)
  ------------------
  |  |  119|      2|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (9112:9): [True: 2, False: 0]
  |  Branch (9112:49): [True: 2, False: 0]
  ------------------
 9113|      2|	return R_TrueValue;
 9114|      0|    else
 9115|      0|	return R_FalseValue;
 9116|      2|}
do_bcversion:
 9159|     11|{
 9160|     11|  checkArity(op, args);
  ------------------
  |  | 1788|     11|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 9161|     11|  SEXP ans = allocVector(INTSXP, 1);
  ------------------
  |  |  875|     11|#define allocVector		Rf_allocVector
  ------------------
                SEXP ans = allocVector(INTSXP, 1);
  ------------------
  |  |  123|     11|#define INTSXP	    13	  /* integer vectors */
  ------------------
 9162|     11|  INTEGER(ans)[0] = R_bcVersion;
 9163|     11|  return ans;
 9164|     11|}
do_growconst:
 9218|     29|{
 9219|     29|    SEXP constBuf, ans;
 9220|     29|    int i, n;
 9221|       |
 9222|     29|    checkArity(op, args);
  ------------------
  |  | 1788|     29|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 9223|     29|    constBuf = CAR(args);
 9224|     29|    if (TYPEOF(constBuf) != VECSXP)
  ------------------
  |  |  131|     29|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (9224:9): [True: 0, False: 29]
  ------------------
 9225|      0|	error(_("constant buffer must be a generic vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("constant buffer must be a generic vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 9226|       |
 9227|     29|    n = LENGTH(constBuf);
 9228|     29|    ans = allocVector(VECSXP, 2 * n);
  ------------------
  |  |  875|     29|#define allocVector		Rf_allocVector
  ------------------
                  ans = allocVector(VECSXP, 2 * n);
  ------------------
  |  |  131|     29|#define VECSXP	    19	  /* generic vectors */
  ------------------
 9229|    138|    for (i = 0; i < n; i++)
  ------------------
  |  Branch (9229:17): [True: 109, False: 29]
  ------------------
 9230|    109|	SET_VECTOR_ELT(ans, i, VECTOR_ELT(constBuf, i));
 9231|       |
 9232|     29|    return ans;
 9233|     29|}
do_putconst:
 9236|    228|{
 9237|    228|    SEXP constBuf, x;
 9238|    228|    int i, constCount;
 9239|       |
 9240|    228|    checkArity(op, args);
  ------------------
  |  | 1788|    228|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 9241|       |
 9242|    228|    constBuf = CAR(args);
 9243|    228|    if (TYPEOF(constBuf) != VECSXP)
  ------------------
  |  |  131|    228|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (9243:9): [True: 0, False: 228]
  ------------------
 9244|      0|	error(_("constant buffer must be a generic vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("constant buffer must be a generic vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 9245|       |
 9246|    228|    constCount = asInteger(CADR(args));
  ------------------
  |  |  885|    228|#define asInteger		Rf_asInteger
  ------------------
 9247|    228|    if (constCount < 0 || constCount >= LENGTH(constBuf))
  ------------------
  |  Branch (9247:9): [True: 0, False: 228]
  |  Branch (9247:27): [True: 0, False: 228]
  ------------------
 9248|      0|	error("bad constCount value");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 9249|       |
 9250|    228|    x = CADDR(args);
 9251|       |
 9252|       |    /* check for a match and return index if one is found */
 9253|  3.29k|    for (i = 0; i < constCount; i++) {
  ------------------
  |  Branch (9253:17): [True: 3.19k, False: 95]
  ------------------
 9254|  3.19k|	SEXP y = VECTOR_ELT(constBuf, i);
 9255|       |	/* 16 - take closure environments into account, this is necessary
 9256|       |	        as closures (closure literals) can get into the AST when
 9257|       |	        the AST is generated by a program (e.g. distr package)
 9258|       |	*/
 9259|  3.19k|	if (x == y || R_compute_identical(x, y, 16))
  ------------------
  |  Branch (9259:6): [True: 129, False: 3.06k]
  |  Branch (9259:16): [True: 4, False: 3.06k]
  ------------------
 9260|    133|	    return ScalarInteger(i);
  ------------------
  |  | 1022|    133|#define ScalarInteger		Rf_ScalarInteger
  ------------------
 9261|  3.19k|    }
 9262|       |
 9263|       |    /* otherwise insert the constant and return index */
 9264|     95|    SET_VECTOR_ELT(constBuf, constCount, x);
 9265|     95|    return ScalarInteger(constCount);
  ------------------
  |  | 1022|     95|#define ScalarInteger		Rf_ScalarInteger
  ------------------
 9266|    228|}
do_getconst:
 9269|     11|{
 9270|     11|    SEXP constBuf, ans;
 9271|     11|    int i, n;
 9272|       |
 9273|     11|    checkArity(op, args);
  ------------------
  |  | 1788|     11|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 9274|     11|    constBuf = CAR(args);
 9275|     11|    n = asInteger(CADR(args));
  ------------------
  |  |  885|     11|#define asInteger		Rf_asInteger
  ------------------
 9276|       |
 9277|     11|    if (TYPEOF(constBuf) != VECSXP)
  ------------------
  |  |  131|     11|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (9277:9): [True: 0, False: 11]
  ------------------
 9278|      0|	error(_("constant buffer must be a generic vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("constant buffer must be a generic vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 9279|     11|    if (n < 0 || n > LENGTH(constBuf))
  ------------------
  |  Branch (9279:9): [True: 0, False: 11]
  |  Branch (9279:18): [True: 0, False: 11]
  ------------------
 9280|      0|	error(_("bad constant count"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("bad constant count"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 9281|       |
 9282|     11|    ans = allocVector(VECSXP, n);
  ------------------
  |  |  875|     11|#define allocVector		Rf_allocVector
  ------------------
                  ans = allocVector(VECSXP, n);
  ------------------
  |  |  131|     11|#define VECSXP	    19	  /* generic vectors */
  ------------------
 9283|    106|    for (i = 0; i < n; i++)
  ------------------
  |  Branch (9283:17): [True: 95, False: 11]
  ------------------
 9284|     95|	SET_VECTOR_ELT(ans, i, VECTOR_ELT(constBuf, i));
 9285|       |
 9286|     11|    return ans;
 9287|     11|}
eval.c:DECLNK_stack:
 1038|  8.98M|{
 1039|  8.98M|    if (base < R_BCProtCommitted) {
  ------------------
  |  Branch (1039:9): [True: 2.31M, False: 6.67M]
  ------------------
 1040|  2.31M|	R_bcstack_t *top = R_BCProtCommitted;
 1041|  15.8M|	for (R_bcstack_t *p = base; p < top; p++) {
  ------------------
  |  Branch (1041:30): [True: 13.4M, False: 2.31M]
  ------------------
 1042|  13.4M|	    if (p->tag == RAWMEM_TAG || p->tag == CACHESZ_TAG)
  ------------------
  |  | 1401|  26.9M|# define RAWMEM_TAG 254
  ------------------
              	    if (p->tag == RAWMEM_TAG || p->tag == CACHESZ_TAG)
  ------------------
  |  | 1402|  9.63M|# define CACHESZ_TAG 253
  ------------------
  |  Branch (1042:10): [True: 3.85M, False: 9.63M]
  |  Branch (1042:34): [True: 1.92M, False: 7.70M]
  ------------------
 1043|  5.78M|		p += p->u.ival;
 1044|  7.70M|	    else if (p->tag == 0)
  ------------------
  |  Branch (1044:15): [True: 6.55M, False: 1.15M]
  ------------------
 1045|  6.55M|		DECREMENT_LINKS(p->u.sxpval);
  ------------------
  |  |  545|  6.55M|#define DECREMENT_LINKS(x) do {			\
  |  |  546|  6.55M|	SEXP dl__x__ = (x);			\
  |  |  547|  6.55M|	DECREMENT_NAMED(dl__x__);		\
  |  |  ------------------
  |  |  |  |  223|  6.55M|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (223:43): [Folded, False: 6.55M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  548|  6.55M|	DECREMENT_REFCNT(dl__x__);		\
  |  |  549|  6.55M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (549:14): [Folded, False: 6.55M]
  |  |  ------------------
  ------------------
 1046|  13.4M|	}
 1047|  2.31M|	R_BCProtCommitted = base;
 1048|  2.31M|    }
 1049|  8.98M|    R_BCProtTop = base;
 1050|  8.98M|}
eval.c:forcePromise:
  965|  4.29M|{
  966|  4.29M|    if (! PROMISE_IS_EVALUATED(e)) {
  ------------------
  |  Branch (966:9): [True: 4.29M, False: 0]
  ------------------
  967|  4.29M|	PROTECT(e);
  ------------------
  |  |  357|  4.29M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  968|  4.29M|	if(PRSEEN(e)) {
  ------------------
  |  Branch (968:5): [True: 0, False: 4.29M]
  ------------------
  969|      0|	    if (PRSEEN(e) == 1)
  ------------------
  |  Branch (969:10): [True: 0, False: 0]
  ------------------
  970|      0|		errorcall(R_GlobalContext->call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  971|      0|			  _("promise already under evaluation: recursive default argument reference or earlier problems?"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  972|      0|	    else {
  973|       |		/* set PRSEEN to 1 to avoid infinite recursion */
  974|      0|		SET_PRSEEN(e, 1);
  975|      0|		warningcall(R_GlobalContext->call,
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
  976|      0|			     _("restarting interrupted promise evaluation"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  977|      0|	    }
  978|      0|	}
  979|       |	/* Mark the promise as under evaluation and push it on a stack
  980|       |	   that can be used to unmark pending promises if a jump out
  981|       |	   of the evaluation occurs. */
  982|  4.29M|	SET_PRSEEN(e, 1);
  983|  4.29M|	RPRSTACK prstack;
  984|  4.29M|	PUSH_PENDING_PROMISE(e, &prstack);
  985|       |
  986|  4.29M|	SEXP val = eval(PRCODE(e), PRENV(e));
  ------------------
  |  |  913|  4.29M|#define eval			Rf_eval
  ------------------
  987|  4.29M|	SET_PRVALUE(e, val);
  988|  4.29M|	ENSURE_NAMEDMAX(val);
  989|       |
  990|       |	/* Pop the stack, unmark the promise and set its value field.
  991|       |	   Also set the environment to R_NilValue to allow GC to
  992|       |	   reclaim the promise environment; this is also useful for
  993|       |	   fancy games with delayedAssign() */
  994|  4.29M|	POP_PENDING_PROMISE(&prstack);
  995|  4.29M|	SET_PRSEEN(e, 0);
  996|  4.29M|	SET_PRENV(e, R_NilValue);
  997|  4.29M|	UNPROTECT(1); /* e */
  ------------------
  |  |  358|  4.29M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  998|  4.29M|    }
  999|  4.29M|}
eval.c:PUSH_PENDING_PROMISE:
  953|  7.81M|{
  954|  7.81M|    cellptr->promise = e;
  955|  7.81M|    cellptr->next = R_PendingPromises;
  956|  7.81M|    R_PendingPromises = cellptr;
  957|  7.81M|}
eval.c:POP_PENDING_PROMISE:
  960|  7.43M|{
  961|  7.43M|    R_PendingPromises = cellptr->next;
  962|  7.43M|}
eval.c:loadCompilerNamespace:
 1424|      2|{
 1425|      2|    SEXP arg = PROTECT(mkString("compiler"));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1426|      2|    R_FindNamespace(arg);
 1427|      2|    UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1428|      2|}
eval.c:checkCompilerOptions:
 1431|      2|{
 1432|      2|    Rboolean old_visible = R_Visible;
 1433|      2|    SEXP packsym, funsym, call, fcall, arg;
 1434|       |
 1435|      2|    packsym = install("compiler");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1436|      2|    funsym = install("checkCompilerOptions");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1437|       |
 1438|      2|    PROTECT(arg = ScalarInteger(jitEnabled));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1439|      2|    PROTECT(fcall = lang3(R_TripleColonSymbol, packsym, funsym));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1440|      2|    PROTECT(call = lang2(fcall, arg));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1441|      2|    eval(call, R_BaseEnv);
  ------------------
  |  |  913|      2|#define eval			Rf_eval
  ------------------
 1442|      2|    UNPROTECT(3);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1443|      2|    R_Visible = old_visible;
 1444|      2|}
eval.c:applyClosure_core:
 2315|   400k|{
 2316|   400k|    SEXP newrho = make_applyClosure_env(call, op, arglist, rho, suppliedvars);
 2317|   400k|    PROTECT(newrho);
  ------------------
  |  |  357|   400k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2318|       |
 2319|       |    /*  If we have a generic function we need to use the sysparent of
 2320|       |	the generic as the sysparent of the method because the method
 2321|       |	is a straight substitution of the generic.  */
 2322|   400k|    if (sysparent == R_NilValue)
  ------------------
  |  Branch (2322:9): [True: 400k, False: 0]
  ------------------
 2323|   400k|	sysparent = (R_GlobalContext->callflag == CTXT_GENERIC) ?
  ------------------
  |  Branch (2323:14): [True: 395, False: 400k]
  ------------------
 2324|   400k|	    R_GlobalContext->sysparent : rho;
 2325|       |
 2326|   400k|    SEXP val = R_execClosure(call, newrho, sysparent, rho, arglist, op);
 2327|   400k|#ifdef ADJUST_ENVIR_REFCNTS
 2328|   400k|    Rboolean is_getter_call =
 2329|   400k|	(CADR(call) == R_TmpvalSymbol && ! R_isReplaceSymbol(CAR(call)));
  ------------------
  |  Branch (2329:3): [True: 579, False: 399k]
  |  Branch (2329:35): [True: 0, False: 579]
  ------------------
 2330|   400k|    R_CleanupEnvir(newrho, val);
 2331|   400k|    if (is_getter_call && MAYBE_REFERENCED(val))
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (2331:9): [True: 0, False: 400k]
  ------------------
 2332|      0|    	val = shallow_duplicate(val);
  ------------------
  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 2333|   400k|    if (unpromise)
  ------------------
  |  Branch (2333:9): [True: 397k, False: 3.41k]
  ------------------
 2334|   397k|	unpromiseArgs(arglist);
 2335|   400k|#endif
 2336|       |
 2337|   400k|    UNPROTECT(1); /* newrho */
  ------------------
  |  |  358|   400k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2338|   400k|    return val;
 2339|   400k|}
eval.c:make_applyClosure_env:
 2245|  3.91M|{
 2246|  3.91M|    SEXP formals, actuals, savedrho, newrho;
 2247|  3.91M|    SEXP f, a;
 2248|       |
 2249|       |    /* formals = list of formal parameters */
 2250|       |    /* actuals = values to be bound to formals */
 2251|       |    /* arglist = the tagged list of arguments */
 2252|       |
 2253|       |    /* protection against rho = NULL */
 2254|       |    // these are deliberately not translated
 2255|  3.91M|    if (!rho)
  ------------------
  |  Branch (2255:9): [True: 0, False: 3.91M]
  ------------------
 2256|      0|	errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 2257|      0|		  "'rho' cannot be C NULL: detected in C-level applyClosure");
 2258|  3.91M|    if (!isEnvironment(rho))
  ------------------
  |  |  944|  3.91M|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (2258:9): [True: 0, False: 3.91M]
  ------------------
 2259|      0|	errorcall(call, "'rho' must be an environment not %s: detected in C-level applyClosure",
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 2260|      0|		  R_typeToChar(rho));
 2261|  3.91M|    if (TYPEOF(op) != CLOSXP)
  ------------------
  |  |  114|  3.91M|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (2261:9): [True: 0, False: 3.91M]
  ------------------
 2262|      0|	errorcall(call, "'op' must be a closure not %s: detected in C-level applyClosure", R_typeToChar(op));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 2263|       |
 2264|  3.91M|    formals = FORMALS(op);
 2265|  3.91M|    savedrho = CLOENV(op);
 2266|       |
 2267|       |    /*  Build a list which matches the actual (unevaluated) arguments
 2268|       |	to the formal paramters.  Build a new environment which
 2269|       |	contains the matched pairs.  matchArgs_RC is used since the
 2270|       |	result becomes part of the environment frame and so needs
 2271|       |	reference couting enabled. */
 2272|       |
 2273|  3.91M|    actuals = matchArgs_RC(formals, arglist, call);
  ------------------
  |  | 1947|  3.91M|# define matchArgs_RC		Rf_matchArgs_RC
  ------------------
 2274|  3.91M|    PROTECT(newrho = NewEnvironment(formals, actuals, savedrho));
  ------------------
  |  |  357|  3.91M|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2275|       |
 2276|       |    /*  Use the default code for unbound formals.  FIXME: It looks like
 2277|       |	this code should preceed the building of the environment so that
 2278|       |	this will also go into the hash table.  */
 2279|       |
 2280|       |    /* This piece of code is destructively modifying the actuals list,
 2281|       |       which is now also the list of bindings in the frame of newrho.
 2282|       |       This is one place where internal structure of environment
 2283|       |       bindings leaks out of envir.c.  It should be rewritten
 2284|       |       eventually so as not to break encapsulation of the internal
 2285|       |       environment layout.  We can live with it for now since it only
 2286|       |       happens immediately after the environment creation.  LT */
 2287|       |
 2288|  3.91M|    f = formals;
 2289|  3.91M|    a = actuals;
 2290|  12.1M|    while (f != R_NilValue) {
  ------------------
  |  Branch (2290:12): [True: 8.23M, False: 3.91M]
  ------------------
 2291|  8.23M|	if (CAR(a) == R_MissingArg && CAR(f) != R_MissingArg) {
  ------------------
  |  Branch (2291:6): [True: 1.97M, False: 6.26M]
  |  Branch (2291:32): [True: 1.96M, False: 6.84k]
  ------------------
 2292|  1.96M|	    SETCAR(a, mkPROMISE(CAR(f), newrho));
  ------------------
  |  | 1957|  1.96M|# define mkPROMISE		Rf_mkPROMISE
  ------------------
 2293|  1.96M|	    SET_MISSING(a, 2);
 2294|  1.96M|	}
 2295|  8.23M|	f = CDR(f);
 2296|  8.23M|	a = CDR(a);
 2297|  8.23M|    }
 2298|       |
 2299|       |    /*  Fix up any extras that were supplied by usemethod. */
 2300|       |
 2301|  3.91M|    if (suppliedvars != R_NilValue)
  ------------------
  |  Branch (2301:9): [True: 433, False: 3.91M]
  ------------------
 2302|    433|	addMissingVarsToNewEnv(newrho, suppliedvars);
  ------------------
  |  |  862|    433|#define addMissingVarsToNewEnv	Rf_addMissingVarsToNewEnv
  ------------------
 2303|       |
 2304|  3.91M|    if (R_envHasNoSpecialSymbols(newrho))
  ------------------
  |  Branch (2304:9): [True: 3.91M, False: 0]
  ------------------
 2305|  3.91M|	SET_NO_SPECIAL_SYMBOLS(newrho);
 2306|       |
 2307|  3.91M|    UNPROTECT(1); /* newrho */
  ------------------
  |  |  358|  3.91M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2308|  3.91M|    return newrho;
 2309|  3.91M|}
eval.c:R_isReplaceSymbol:
 2011|    579|{
 2012|       |    /* fun is a replacement function name if it contains '<-'
 2013|       |       anywhere. For internally dispatched replacement functions this
 2014|       |       may occur in the middle; in other cases it will be at the
 2015|       |       end. */
 2016|    579|    if (TYPEOF(fun) == SYMSXP &&
  ------------------
  |  |  112|  1.15k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (2016:9): [True: 579, False: 0]
  ------------------
 2017|    579|	strstr(CHAR(PRINTNAME(fun)), "<-"))
  ------------------
  |  |  203|    579|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (2017:2): [True: 579, False: 0]
  ------------------
 2018|    579|	return TRUE;
 2019|      0|    else return FALSE;
 2020|    579|}
eval.c:handle_exec_continuation:
 2200|  3.52M|{
 2201|  3.52M|    while (is_exec_continuation(val)) {
  ------------------
  |  Branch (2201:12): [True: 0, False: 3.52M]
  ------------------
 2202|      0|	SEXP call = PROTECT(VECTOR_ELT(val, 1));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2203|      0|	SEXP rho = PROTECT(VECTOR_ELT(val, 2));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2204|      0|	SET_VECTOR_ELT(val, 2, R_NilValue); // to drop REFCNT
 2205|      0|	SEXP op = PROTECT(VECTOR_ELT(val, 3));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2206|       |
 2207|      0|	if (TYPEOF(op) == CLOSXP) {
  ------------------
  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (2207:6): [True: 0, False: 0]
  ------------------
 2208|      0|	    SEXP callrho = R_GlobalEnv;
 2209|      0|	    for (RCNTXT *cptr = R_GlobalContext;
 2210|      0|		 cptr != NULL && cptr->callflag != CTXT_TOPLEVEL;
  ------------------
  |  Branch (2210:4): [True: 0, False: 0]
  |  Branch (2210:20): [True: 0, False: 0]
  ------------------
 2211|      0|		 cptr = cptr->nextcontext)
 2212|      0|		if (cptr->callflag & CTXT_FUNCTION) {
  ------------------
  |  Branch (2212:7): [True: 0, False: 0]
  ------------------
 2213|      0|		    callrho = cptr->cloenv;
 2214|      0|		    break;
 2215|      0|		}
 2216|      0|	    SEXP arglist = PROTECT(promiseArgsEx(CDR(call), rho, TRUE));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2217|      0|	    SEXP suppliedvars = R_NilValue;
 2218|      0|	    val = applyClosure_core(call, op, arglist, rho, suppliedvars,
 2219|      0|				    callrho, TRUE);
 2220|      0|# ifdef ADJUST_ENVIR_REFCNTS
 2221|      0|	    R_CleanupEnvir(rho, val);
 2222|      0|# endif
 2223|      0|	    UNPROTECT(1); /* arglist */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2224|      0|	}
 2225|      0|	else {
 2226|       |	    /* Ideally this should handle BUILTINSXP/SPECIALSXP calls
 2227|       |	       in the standard way as in eval() or bceval(). For now,
 2228|       |	       just build a new call and eval. */
 2229|      0|	    SEXP expr = PROTECT(LCONS(op, CDR(call)));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2230|      0|	    val = eval(expr, rho);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 2231|      0|	    UNPROTECT(1); /* expr */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2232|      0|	}
 2233|      0|	UNPROTECT(3); /* call, rho, op */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2234|      0|    }
 2235|  3.52M|    return val;
 2236|  3.52M|}
eval.c:R_execClosure:
 2357|   400k|{
 2358|   400k|    SEXP body;
 2359|   400k|    RCNTXT cntxt;
 2360|   400k|    volatile Rboolean dbg = FALSE;
 2361|       |
 2362|   400k|    begincontext(&cntxt, CTXT_RETURN, call, newrho, sysparent, arglist, op);
  ------------------
  |  | 1864|   400k|# define begincontext		Rf_begincontext
  ------------------
 2363|       |
 2364|   400k|    body = BODY(op);
 2365|   400k|    if (R_CheckJIT(op)) {
  ------------------
  |  Branch (2365:9): [True: 1, False: 400k]
  ------------------
 2366|      1|	int old_enabled = R_jit_enabled;
 2367|      1|	R_jit_enabled = 0;
 2368|      1|	R_cmpfun(op);
 2369|      1|	body = BODY(op);
 2370|      1|	R_jit_enabled = old_enabled;
 2371|      1|    }
 2372|       |
 2373|       |    /* Get the srcref record from the closure object. The old srcref was
 2374|       |       saved in cntxt. */
 2375|       |
 2376|   400k|    R_Srcref = getAttrib(op, R_SrcrefSymbol);
  ------------------
  |  |  924|   400k|#define getAttrib		Rf_getAttrib
  ------------------
 2377|       |
 2378|       |    /* Debugging */
 2379|       |
 2380|   400k|    if ((RDEBUG(op) && R_current_debug_state()) || RSTEP(op)
  ------------------
  |  Branch (2380:10): [True: 0, False: 400k]
  |  Branch (2380:24): [True: 0, False: 0]
  |  Branch (2380:52): [True: 0, False: 400k]
  ------------------
 2381|   400k|         || (RDEBUG(rho) && R_BrowserLastCommand == 's')) {
  ------------------
  |  Branch (2381:14): [True: 0, False: 400k]
  |  Branch (2381:29): [True: 0, False: 0]
  ------------------
 2382|       |
 2383|      0|	dbg = TRUE;
 2384|      0|	SET_RSTEP(op, 0);
 2385|      0|	SET_RDEBUG(newrho, 1);
 2386|      0|	cntxt.browserfinish = 0; /* Don't want to inherit the "f" */
 2387|       |	/* switch to interpreted version when debugging compiled code */
 2388|      0|	if (TYPEOF(body) == BCODESXP)
  ------------------
  |  |  133|      0|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (2388:6): [True: 0, False: 0]
  ------------------
 2389|      0|	    body = bytecodeExpr(body);
 2390|      0|	Rprintf("debugging in: ");
 2391|      0|	PrintCall(call, rho);
 2392|      0|	SrcrefPrompt("debug", R_Srcref);
  ------------------
  |  | 1987|      0|# define SrcrefPrompt		Rf_SrcrefPrompt
  ------------------
 2393|      0|	PrintValue(body);
  ------------------
  |  | 1013|      0|#define PrintValue		Rf_PrintValue
  ------------------
 2394|      0|	do_browser(call, op, R_NilValue, newrho);
 2395|      0|    }
 2396|       |
 2397|       |    /*  Set a longjmp target which will catch any explicit returns
 2398|       |	from the function body.  */
 2399|       |
 2400|   400k|    if ((SETJMP(cntxt.cjmpbuf))) {
  ------------------
  |  | 1162|   400k|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (2400:9): [True: 108, False: 400k]
  ------------------
 2401|    108|	if (!cntxt.jumptarget) {
  ------------------
  |  Branch (2401:6): [True: 72, False: 36]
  ------------------
 2402|       |	    /* ignores intermediate jumps for on.exits */
 2403|     72|	    cntxt.returnValue = SEXP_TO_STACKVAL(R_ReturnedValue);
  ------------------
  |  | 2598|     72|#define SEXP_TO_STACKVAL(x) ((R_bcstack_t) { .tag = 0, .u.sxpval = (x) })
  ------------------
 2404|     72|	}
 2405|     36|	else
 2406|     36|	    cntxt.returnValue = SEXP_TO_STACKVAL(NULL); /* undefined */
  ------------------
  |  | 2598|     36|#define SEXP_TO_STACKVAL(x) ((R_bcstack_t) { .tag = 0, .u.sxpval = (x) })
  ------------------
 2407|    108|    }
 2408|   400k|    else
 2409|       |	/* make it available to on.exit and implicitly protect */
 2410|   400k|	cntxt.returnValue = SEXP_TO_STACKVAL(eval(body, newrho));
  ------------------
  |  | 2598|   400k|#define SEXP_TO_STACKVAL(x) ((R_bcstack_t) { .tag = 0, .u.sxpval = (x) })
  ------------------
 2411|       |
 2412|   400k|    R_Srcref = cntxt.srcref;
 2413|   400k|    endcontext(&cntxt);
  ------------------
  |  | 1895|   400k|# define endcontext		Rf_endcontext
  ------------------
 2414|       |
 2415|   400k|    if (dbg) {
  ------------------
  |  Branch (2415:9): [True: 0, False: 400k]
  ------------------
 2416|      0|	Rprintf("exiting from: ");
 2417|      0|	PrintCall(call, rho);
 2418|      0|    }
 2419|       |
 2420|       |    /* clear R_ReturnedValue to allow GC to reclaim old value */
 2421|   400k|    R_ReturnedValue = R_NilValue;
 2422|       |
 2423|   400k|    return STACKVAL_TO_SEXP(cntxt.returnValue);
 2424|   400k|}
eval.c:R_CheckJIT:
 1578|   400k|{
 1579|       |    /* to help with testing */
 1580|   400k|    if (jit_strategy < 0) {
  ------------------
  |  Branch (1580:9): [True: 2, False: 400k]
  ------------------
 1581|      2|	int dflt = R_jit_enabled == 1 ?
  ------------------
  |  Branch (1581:13): [True: 0, False: 2]
  ------------------
 1582|      2|	    STRATEGY_NO_SMALL : STRATEGY_TOP_SMALL_MAYBE;
  ------------------
  |  | 1546|      0|#define STRATEGY_NO_SMALL 0
  ------------------
              	    STRATEGY_NO_SMALL : STRATEGY_TOP_SMALL_MAYBE;
  ------------------
  |  | 1547|      2|#define STRATEGY_TOP_SMALL_MAYBE 1
  ------------------
 1583|      2|	int val = dflt;
 1584|      2|	char *valstr = getenv("R_JIT_STRATEGY");
 1585|      2|	if (valstr != NULL)
  ------------------
  |  Branch (1585:6): [True: 0, False: 2]
  ------------------
 1586|      0|	    val = atoi(valstr);
 1587|      2|	if (val < 0 || val > 4)
  ------------------
  |  Branch (1587:6): [True: 0, False: 2]
  |  Branch (1587:17): [True: 0, False: 2]
  ------------------
 1588|      0|	    jit_strategy = dflt;
 1589|      2|	else
 1590|      2|	    jit_strategy = val;
 1591|       |
 1592|      2|	valstr = getenv("R_MIN_JIT_SCORE");
 1593|      2|	if (valstr != NULL)
  ------------------
  |  Branch (1593:6): [True: 0, False: 2]
  ------------------
 1594|      0|	    MIN_JIT_SCORE = atoi(valstr);
 1595|      2|    }
 1596|       |
 1597|   400k|    SEXP body = BODY(fun);
 1598|       |
 1599|   400k|    if (R_jit_enabled > 0 && TYPEOF(body) != BCODESXP &&
  ------------------
  |  |  133|   792k|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (1599:9): [True: 392k, False: 7.91k]
  |  Branch (1599:30): [True: 873, False: 391k]
  ------------------
 1600|    873|	! R_disable_bytecode && ! NOJIT(fun)) {
  ------------------
  |  Branch (1600:2): [True: 873, False: 0]
  |  Branch (1600:26): [True: 33, False: 840]
  ------------------
 1601|       |
 1602|     33|	if (MAYBEJIT(fun)) {
  ------------------
  |  Branch (1602:6): [True: 1, False: 32]
  ------------------
 1603|       |	    /* function marked as MAYBEJIT the first time now seen
 1604|       |	       twice, so go ahead and compile */
 1605|      1|	    UNSET_MAYBEJIT(fun);
 1606|      1|	    return TRUE;
 1607|      1|	}
 1608|       |
 1609|     32|	if (jit_strategy == STRATEGY_NO_SCORE ||
  ------------------
  |  | 1549|     64|#define STRATEGY_NO_SCORE 3
  ------------------
  |  Branch (1609:6): [True: 0, False: 32]
  ------------------
 1610|     32|	    jit_strategy == STRATEGY_NO_CACHE)
  ------------------
  |  | 1550|     32|#define STRATEGY_NO_CACHE 4
  ------------------
  |  Branch (1610:6): [True: 0, False: 32]
  ------------------
 1611|      0|	    return TRUE;
 1612|       |
 1613|     32|	int score = JIT_score(body);
 1614|     32|	if (jit_strategy == STRATEGY_ALL_SMALL_MAYBE)
  ------------------
  |  | 1548|     32|#define STRATEGY_ALL_SMALL_MAYBE 2
  ------------------
  |  Branch (1614:6): [True: 0, False: 32]
  ------------------
 1615|      0|	    if (score < MIN_JIT_SCORE) { SET_MAYBEJIT(fun); return FALSE; }
  ------------------
  |  Branch (1615:10): [True: 0, False: 0]
  ------------------
 1616|       |
 1617|     32|	if (CLOENV(fun) == R_GlobalEnv) {
  ------------------
  |  Branch (1617:6): [True: 0, False: 32]
  ------------------
 1618|       |	    /* top level functions are only compiled if score is high enough */
 1619|      0|	    if (score < MIN_JIT_SCORE) {
  ------------------
  |  Branch (1619:10): [True: 0, False: 0]
  ------------------
 1620|      0|		if (jit_strategy == STRATEGY_TOP_SMALL_MAYBE)
  ------------------
  |  | 1547|      0|#define STRATEGY_TOP_SMALL_MAYBE 1
  ------------------
  |  Branch (1620:7): [True: 0, False: 0]
  ------------------
 1621|      0|		    SET_MAYBEJIT(fun);
 1622|      0|		else
 1623|      0|		    SET_NOJIT(fun);
 1624|      0|		return FALSE;
 1625|      0|	    }
 1626|      0|	    else return TRUE;
 1627|      0|	}
 1628|     32|	else {
 1629|       |	    /* only compile non-top-level function if score is high
 1630|       |	       enough and seen twice */
 1631|     32|	    if (score < MIN_JIT_SCORE) {
  ------------------
  |  Branch (1631:10): [True: 30, False: 2]
  ------------------
 1632|     30|		SET_NOJIT(fun);
 1633|     30|		return FALSE;
 1634|     30|	    }
 1635|      2|	    else {
 1636|      2|		SET_MAYBEJIT(fun);
 1637|      2|		return FALSE;
 1638|      2|	    }
 1639|     32|	}
 1640|     32|    }
 1641|   400k|    return FALSE;
 1642|   400k|}
eval.c:JIT_score:
 1524|  1.00k|{
 1525|  1.00k|    if (TYPEOF(e) == LANGSXP) {
  ------------------
  |  |  117|  1.00k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (1525:9): [True: 486, False: 516]
  ------------------
 1526|    486|	SEXP fun = CAR(e);
 1527|    486|	if (fun == R_IfSymbol) {
  ------------------
  |  Branch (1527:6): [True: 0, False: 486]
  ------------------
 1528|      0|	    int cons = JIT_score(CADR(e));
 1529|      0|	    int alt =  JIT_score(CADDR(e));
 1530|      0|	    return cons > alt ? cons : alt;
  ------------------
  |  |  897|      0|#define cons			Rf_cons
  ------------------
              	    return cons > alt ? cons : alt;
  ------------------
  |  |  897|      0|#define cons			Rf_cons
  ------------------
  |  Branch (1530:13): [True: 0, False: 0]
  ------------------
 1531|      0|	}
 1532|    486|	else if (fun == R_ForSymbol ||
  ------------------
  |  Branch (1532:11): [True: 0, False: 486]
  ------------------
 1533|    486|		 fun == R_WhileSymbol ||
  ------------------
  |  Branch (1533:4): [True: 0, False: 486]
  ------------------
 1534|    486|		 fun == R_RepeatSymbol)
  ------------------
  |  Branch (1534:4): [True: 0, False: 486]
  ------------------
 1535|      0|	    return LOOP_JIT_SCORE;
  ------------------
  |  | 1457|      0|#define LOOP_JIT_SCORE MIN_JIT_SCORE
  ------------------
 1536|    486|	else {
 1537|    486|	    int score = 1;
 1538|  1.45k|	    for (SEXP args = CDR(e); args != R_NilValue; args = CDR(args))
  ------------------
  |  Branch (1538:31): [True: 970, False: 486]
  ------------------
 1539|    970|		score += JIT_score(CAR(args));
 1540|    486|	    return score;
 1541|    486|	}
 1542|    486|    }
 1543|    516|    else return 1;
 1544|  1.00k|}
eval.c:R_cmpfun:
 1858|      1|{
 1859|      1|    R_exprhash_t hash = 0;
 1860|      1|    if (jit_strategy != STRATEGY_NO_CACHE) {
  ------------------
  |  | 1550|      1|#define STRATEGY_NO_CACHE 4
  ------------------
  |  Branch (1860:9): [True: 1, False: 0]
  ------------------
 1861|      1|	hash = hashfun(fun);
 1862|      1|	SEXP entry = get_jit_cache_entry(hash);
 1863|       |
 1864|      1|	if (entry != R_NilValue) {
  ------------------
  |  Branch (1864:6): [True: 0, False: 1]
  ------------------
 1865|      0|	    jit_info.count++;
 1866|      0|	    if (jit_env_match(jit_cache_env(entry), fun)) {
  ------------------
  |  Branch (1866:10): [True: 0, False: 0]
  ------------------
 1867|      0|		jit_info.envcount++;
 1868|      0|		if (jit_expr_match(jit_cache_expr(entry), BODY(fun))) {
  ------------------
  |  Branch (1868:7): [True: 0, False: 0]
  ------------------
 1869|      0|		    jit_info.bdcount++;
 1870|       |		    /* if function body has a srcref, all srcrefs compiled
 1871|       |		       in that function only depend on the body srcref;
 1872|       |		       but, otherwise the srcrefs compiled in are taken
 1873|       |		       from the function (op) */
 1874|      0|		    if (getAttrib(BODY(fun), R_SrcrefSymbol) != R_NilValue ||
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (1874:11): [True: 0, False: 0]
  ------------------
 1875|      0|			jit_srcref_match(jit_cache_srcref(entry),
  ------------------
  |  Branch (1875:4): [True: 0, False: 0]
  ------------------
 1876|      0|					 getAttrib(fun, R_SrcrefSymbol))) {
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 1877|      0|			PRINT_JIT_INFO;
  ------------------
  |  | 1649|      0|# define PRINT_JIT_INFO	do { } while(0)
  |  |  ------------------
  |  |  |  Branch (1649:38): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1878|      0|			SET_BODY(fun, jit_cache_code(entry));
 1879|       |			/**** reset the cache here?*/
 1880|      0|			return;
 1881|      0|		    }
 1882|      0|		}
 1883|       |		/* The functions probably differ only in source references
 1884|       |		   (for functions with bodies that have no source references
 1885|       |		   we know for sure, for other functions we speculate).
 1886|       |		   Therefore, we allow re-compilation and re-caching. This
 1887|       |		   situation may be caused e.g. by re-sourcing the same source
 1888|       |		   file or re-pasting the same definitions for a function in
 1889|       |		   interactive R session. Note srcref information includes
 1890|       |		   environments (srcfile), which are now compared by address,
 1891|       |		   so it may be we actually have logically identical source
 1892|       |		   references, anyway. */
 1893|       |		/* FIXME: revisit this when deep comparison of environments
 1894|       |			  (and srcrefs) is available */
 1895|      0|	    } else {
 1896|      0|		SET_NOJIT(fun);
 1897|       |		/**** also mark the cache entry as NOJIT, or as need to see
 1898|       |		      many times? */
 1899|      0|		return;
 1900|      0|	    }
 1901|      0|	}
 1902|      1|	PRINT_JIT_INFO;
  ------------------
  |  | 1649|      1|# define PRINT_JIT_INFO	do { } while(0)
  |  |  ------------------
  |  |  |  Branch (1649:38): [Folded, False: 1]
  |  |  ------------------
  ------------------
 1903|      1|    }
 1904|       |
 1905|      1|    SEXP val = R_cmpfun1(fun);
 1906|       |
 1907|      1|    if (TYPEOF(BODY(val)) != BCODESXP)
  ------------------
  |  |  133|      1|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (1907:9): [True: 0, False: 1]
  ------------------
 1908|      0|	SET_NOJIT(fun);
 1909|      1|    else {
 1910|      1|	if (jit_strategy != STRATEGY_NO_CACHE)
  ------------------
  |  | 1550|      1|#define STRATEGY_NO_CACHE 4
  ------------------
  |  Branch (1910:6): [True: 1, False: 0]
  ------------------
 1911|      1|	    set_jit_cache_entry(hash, val); /* val is protected by callee */
 1912|      1|	SET_BODY(fun, BODY(val));
 1913|      1|    }
 1914|      1|}
eval.c:hashfun:
 1416|      1|{
 1417|      1|    R_exprhash_t h = hashexpr(BODY(f));
 1418|      1|    if (getAttrib(BODY(f), R_SrcrefSymbol) == R_NilValue)
  ------------------
  |  |  924|      1|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (1418:9): [True: 1, False: 0]
  ------------------
 1419|      1|	h = hashsrcref(getAttrib(f, R_SrcrefSymbol), h);
  ------------------
  |  |  924|      1|#define getAttrib		Rf_getAttrib
  ------------------
 1420|      1|    return h;
 1421|      1|}
eval.c:hashexpr:
 1411|      1|{
 1412|      1|    return hashexpr1(e, 5381);
 1413|      1|}
eval.c:hashexpr1:
 1346|     80|{
 1347|     80|#define SKIP_NONSCALAR 	if (len != 1) break /* non-scalars hashed by address */
 1348|     80|    int len = length(e);
  ------------------
  |  |  987|     80|#define length(x)		Rf_length(x)
  ------------------
 1349|     80|    int type = TYPEOF(e);
 1350|     80|    h = HASH(type, h);
  ------------------
  |  | 1343|     80|#define HASH(x, h) hash((unsigned char *) &x, sizeof(x), h)
  ------------------
 1351|     80|    h = HASH(len, h);
  ------------------
  |  | 1343|     80|#define HASH(x, h) hash((unsigned char *) &x, sizeof(x), h)
  ------------------
 1352|       |
 1353|     80|    switch(type) {
  ------------------
  |  Branch (1353:12): [True: 39, False: 41]
  ------------------
 1354|     26|    case LANGSXP:
  ------------------
  |  |  117|     26|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (1354:5): [True: 26, False: 54]
  ------------------
 1355|     26|    case LISTSXP:
  ------------------
  |  |  113|     26|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1355:5): [True: 0, False: 80]
  ------------------
 1356|       |	/**** safer to only follow while CDR is LANGSXP/LISTSXP */
 1357|    105|	for (; e != R_NilValue; e = CDR(e))
  ------------------
  |  Branch (1357:9): [True: 79, False: 26]
  ------------------
 1358|     79|	    h = hashexpr1(CAR(e), h);
 1359|     26|	return h;
 1360|      1|    case LGLSXP:
  ------------------
  |  |  121|      1|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1360:5): [True: 1, False: 79]
  ------------------
 1361|      1|	SKIP_NONSCALAR;
  ------------------
  |  | 1347|      1|#define SKIP_NONSCALAR 	if (len != 1) break /* non-scalars hashed by address */
  |  |  ------------------
  |  |  |  Branch (1347:29): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1362|      2|	for (int i = 0; i < len; i++) {
  ------------------
  |  Branch (1362:18): [True: 1, False: 1]
  ------------------
 1363|      1|	    int ival = LOGICAL(e)[i];
 1364|      1|	    h = HASH(ival, h);
  ------------------
  |  | 1343|      1|#define HASH(x, h) hash((unsigned char *) &x, sizeof(x), h)
  ------------------
 1365|      1|	}
 1366|      1|	return h;
 1367|      5|    case INTSXP:
  ------------------
  |  |  123|      5|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1367:5): [True: 5, False: 75]
  ------------------
 1368|      5|	SKIP_NONSCALAR;
  ------------------
  |  | 1347|      5|#define SKIP_NONSCALAR 	if (len != 1) break /* non-scalars hashed by address */
  |  |  ------------------
  |  |  |  Branch (1347:29): [True: 0, False: 5]
  |  |  ------------------
  ------------------
 1369|     10|	for (int i = 0; i < len; i++) {
  ------------------
  |  Branch (1369:18): [True: 5, False: 5]
  ------------------
 1370|      5|	    int ival = INTEGER(e)[i];
 1371|      5|	    h = HASH(ival, h);
  ------------------
  |  | 1343|      5|#define HASH(x, h) hash((unsigned char *) &x, sizeof(x), h)
  ------------------
 1372|      5|	}
 1373|      5|	return h;
 1374|      4|    case REALSXP:
  ------------------
  |  |  124|      4|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1374:5): [True: 4, False: 76]
  ------------------
 1375|      4|	SKIP_NONSCALAR;
  ------------------
  |  | 1347|      4|#define SKIP_NONSCALAR 	if (len != 1) break /* non-scalars hashed by address */
  |  |  ------------------
  |  |  |  Branch (1347:29): [True: 0, False: 4]
  |  |  ------------------
  ------------------
 1376|      8|	for (int i = 0; i < len; i++) {
  ------------------
  |  Branch (1376:18): [True: 4, False: 4]
  ------------------
 1377|      4|	    double dval = REAL(e)[i];
 1378|      4|	    h = HASH(dval, h);
  ------------------
  |  | 1343|      4|#define HASH(x, h) hash((unsigned char *) &x, sizeof(x), h)
  ------------------
 1379|      4|	}
 1380|      4|	return h;
 1381|      3|    case STRSXP:
  ------------------
  |  |  126|      3|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1381:5): [True: 3, False: 77]
  ------------------
 1382|      3|	SKIP_NONSCALAR;
  ------------------
  |  | 1347|      3|#define SKIP_NONSCALAR 	if (len != 1) break /* non-scalars hashed by address */
  |  |  ------------------
  |  |  |  Branch (1347:29): [True: 0, False: 3]
  |  |  ------------------
  ------------------
 1383|      6|	for (int i = 0; i < len; i++) {
  ------------------
  |  Branch (1383:18): [True: 3, False: 3]
  ------------------
 1384|      3|	    SEXP cval = STRING_ELT(e, i);
 1385|      3|	    h = hash((unsigned char *) CHAR(cval), LENGTH(cval), h);
  ------------------
  |  |  203|      3|#define CHAR(x) R_CHAR(x)
  ------------------
 1386|      3|	}
 1387|      3|	return h;
 1388|     80|    }
 1389|       |
 1390|     41|    return HASH(e, h);
  ------------------
  |  | 1343|     41|#define HASH(x, h) hash((unsigned char *) &x, sizeof(x), h)
  ------------------
 1391|     80|#undef SKIP_NONSCALAR
 1392|     80|}
eval.c:hash:
 1331|    214|{
 1332|       |    // djb2 from http://www.cse.yorku.ca/~oz/hash.html
 1333|       |    // (modified for n-byte lengths)
 1334|       |
 1335|    214|    int i;
 1336|       |
 1337|  1.24k|    for(i = 0; i < n; i++)
  ------------------
  |  Branch (1337:16): [True: 1.03k, False: 214]
  ------------------
 1338|  1.03k|        hash = ((hash << 5) + hash) + str[i]; /* hash * 33 + c */
 1339|       |
 1340|    214|    return hash;
 1341|    214|}
eval.c:hashsrcref:
 1396|      1|{
 1397|      1|    if (TYPEOF(e) == INTSXP && LENGTH(e) >= 6) {
  ------------------
  |  |  123|      2|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1397:9): [True: 0, False: 1]
  |  Branch (1397:32): [True: 0, False: 0]
  ------------------
 1398|      0|	for(int i = 0; i < 6; i++) {
  ------------------
  |  Branch (1398:17): [True: 0, False: 0]
  ------------------
 1399|      0|	    int ival = INTEGER(e)[i];
 1400|      0|	    h = HASH(ival, h);
  ------------------
  |  | 1343|      0|#define HASH(x, h) hash((unsigned char *) &x, sizeof(x), h)
  ------------------
 1401|      0|	}
 1402|       |	/* FIXME: update this when deep-comparison of srcref is available */
 1403|      0|	SEXP srcfile = getAttrib(e, R_SrcfileSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 1404|      0|	h = HASH(srcfile, h);
  ------------------
  |  | 1343|      0|#define HASH(x, h) hash((unsigned char *) &x, sizeof(x), h)
  ------------------
 1405|      0|    }
 1406|      1|    return h;
 1407|      1|}
eval.c:get_jit_cache_entry:
 1753|      1|{
 1754|      1|    int hashidx = hash % JIT_CACHE_SIZE;
  ------------------
  |  | 1451|      1|#define JIT_CACHE_SIZE 1024
  ------------------
 1755|      1|    if (JIT_cache_hashes[hashidx] == hash) {
  ------------------
  |  Branch (1755:9): [True: 0, False: 1]
  ------------------
 1756|      0|	SEXP entry = VECTOR_ELT(JIT_cache, hashidx);
 1757|      0|	if (TYPEOF(jit_cache_code(entry)) == BCODESXP)
  ------------------
  |  |  133|      0|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (1757:6): [True: 0, False: 0]
  ------------------
 1758|      0|	    return entry;
 1759|      0|	else
 1760|       |	    /* function has been de-compiled; clear the cache entry */
 1761|      0|	    SET_VECTOR_ELT(JIT_cache, hashidx, R_NilValue);
 1762|      0|    }
 1763|      1|    return R_NilValue;
 1764|      1|}
eval.c:set_jit_cache_entry:
 1717|      1|{
 1718|      1|    int hashidx = hash % JIT_CACHE_SIZE;
  ------------------
  |  | 1451|      1|#define JIT_CACHE_SIZE 1024
  ------------------
 1719|       |
 1720|      1|    PROTECT(val);
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1721|      1|    SEXP entry = CONS(BODY(val), make_cached_cmpenv(val));
  ------------------
  |  |  309|      1|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 1722|      1|    SET_VECTOR_ELT(JIT_cache, hashidx, entry);
 1723|      1|    SET_TAG(entry, getAttrib(val, R_SrcrefSymbol));
  ------------------
  |  |  924|      1|#define getAttrib		Rf_getAttrib
  ------------------
 1724|      1|    UNPROTECT(1); /* val */
  ------------------
  |  |  358|      1|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1725|       |
 1726|      1|    JIT_cache_hashes[hashidx] = hash;
 1727|      1|}
eval.c:make_cached_cmpenv:
 1681|      1|{
 1682|      1|    SEXP frmls = FORMALS(fun);
 1683|      1|    SEXP cmpenv = CLOENV(fun);
 1684|      1|    SEXP top = topenv(R_NilValue, cmpenv);
  ------------------
  |  | 1036|      1|#define topenv		        Rf_topenv
  ------------------
 1685|      1|    if (cmpenv == top && frmls == R_NilValue)
  ------------------
  |  Branch (1685:9): [True: 1, False: 0]
  |  Branch (1685:26): [True: 0, False: 1]
  ------------------
 1686|      0|	return cmpenv;
 1687|      1|    else {
 1688|      1|	SEXP newenv = PROTECT(NewEnvironment(R_NilValue, R_NilValue, top));
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1689|      2|	for (; frmls != R_NilValue; frmls = CDR(frmls))
  ------------------
  |  Branch (1689:9): [True: 1, False: 1]
  ------------------
 1690|      1|	    defineVar(TAG(frmls), R_NilValue, newenv);
  ------------------
  |  |  905|      1|#define defineVar		Rf_defineVar
  ------------------
 1691|      1|	for (SEXP env = cmpenv; env != top; env = CDR(env)) {
  ------------------
  |  Branch (1691:26): [True: 0, False: 1]
  ------------------
 1692|      0|	    if (IS_STANDARD_UNHASHED_FRAME(env))
  ------------------
  |  | 1656|      0|#define IS_STANDARD_UNHASHED_FRAME(e) (! IS_USER_DATABASE(e) && HASHTAB(e) == R_NilValue)
  |  |  ------------------
  |  |  |  | 1655|      0|#define IS_USER_DATABASE(rho)  (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  |  |  ------------------
  |  |  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1655:33): [True: 0, False: 0]
  |  |  |  |  |  Branch (1655:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1656:65): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1693|      0|		cmpenv_enter_frame(FRAME(env), newenv);
 1694|      0|	    else if (IS_STANDARD_HASHED_FRAME(env)) {
  ------------------
  |  | 1657|      0|#define IS_STANDARD_HASHED_FRAME(e) (! IS_USER_DATABASE(e) && HASHTAB(e) != R_NilValue)
  |  |  ------------------
  |  |  |  | 1655|      0|#define IS_USER_DATABASE(rho)  (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  |  |  ------------------
  |  |  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1655:33): [True: 0, False: 0]
  |  |  |  |  |  Branch (1655:50): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1657:63): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1695|      0|		SEXP h = HASHTAB(env);
 1696|      0|		int n = length(h);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 1697|      0|		for (int i = 0; i < n; i++)
  ------------------
  |  Branch (1697:19): [True: 0, False: 0]
  ------------------
 1698|      0|		    cmpenv_enter_frame(VECTOR_ELT(h, i), newenv);
 1699|      0|	    } else {
 1700|      0|		UNPROTECT(1); /* newenv */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1701|      0|		return top;
 1702|      0|	    }
 1703|       |		/* topenv is a safe conservative answer; if a closure
 1704|       |		   defines anything, its environment will not match, and
 1705|       |		   it will never be compiled */
 1706|       |		/* FIXME: would it be safe to simply ignore elements of
 1707|       |		   of these environments? */
 1708|      0|	}
 1709|      1|	UNPROTECT(1); /* newenv */
  ------------------
  |  |  358|      1|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1710|      1|	return newenv;
 1711|      1|    }
 1712|      1|}
eval.c:R_CleanupEnvir:
 2137|  4.30M|{
 2138|  4.30M|    if (val != rho) {
  ------------------
  |  Branch (2138:9): [True: 4.30M, False: 0]
  ------------------
 2139|       |	/* release the bindings and promises in rho if rho is no
 2140|       |	   longer accessible from R */
 2141|  4.30M|	int refs = REFCNT(rho);
 2142|  4.30M|	if (refs > 0)
  ------------------
  |  Branch (2142:6): [True: 1.55M, False: 2.74M]
  ------------------
 2143|  1.55M|	    refs -= countCycleRefs(rho, val);
 2144|  4.30M|	if (refs == 0) {
  ------------------
  |  Branch (2144:6): [True: 2.75M, False: 1.54M]
  ------------------
 2145|  2.75M|	    for (SEXP b = FRAME(rho);
 2146|  10.6M|		 b != R_NilValue && REFCNT(b) == 1;
  ------------------
  |  Branch (2146:4): [True: 8.24M, False: 2.36M]
  |  Branch (2146:23): [True: 7.86M, False: 385k]
  ------------------
 2147|  7.86M|		 b = CDR(b)) {
 2148|  7.86M|		if (BNDCELL_TAG(b)) continue;
  ------------------
  |  Branch (2148:7): [True: 1.06k, False: 7.86M]
  ------------------
 2149|  7.86M|		SEXP v = CAR(b);
 2150|  7.86M|		if (REFCNT(v) == 1 && v != val) {
  ------------------
  |  Branch (2150:7): [True: 3.52M, False: 4.33M]
  |  Branch (2150:25): [True: 2.75M, False: 771k]
  ------------------
 2151|  2.75M|		    switch(TYPEOF(v)) {
  ------------------
  |  Branch (2151:14): [True: 1.96M, False: 782k]
  ------------------
 2152|   419k|		    case PROMSXP:
  ------------------
  |  |  116|   419k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2152:7): [True: 419k, False: 2.33M]
  ------------------
 2153|   419k|			clearPromise(v);
 2154|   419k|			break;
 2155|   775k|		    case DOTSXP:
  ------------------
  |  |  127|   775k|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (2155:7): [True: 775k, False: 1.97M]
  ------------------
 2156|   775k|			cleanupEnvDots(v);
 2157|   775k|			break;
 2158|   773k|		    case VECSXP: /* mainly for list(...) */
  ------------------
  |  |  131|   773k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2158:7): [True: 773k, False: 1.97M]
  ------------------
 2159|   773k|			cleanupEnvVector(v);
 2160|   773k|			break;
 2161|  2.75M|		    }
 2162|  2.75M|		}
 2163|  7.86M|		SETCAR(b, R_NilValue);
 2164|  7.86M|	    }
 2165|  2.75M|	    SET_ENCLOS(rho, R_EmptyEnv);
 2166|  2.75M|	}
 2167|  4.30M|    }
 2168|  4.30M|}
eval.c:countCycleRefs:
 2063|  1.55M|{
 2064|       |    /* check for simple cycles */
 2065|  1.55M|    int crefs = 0;
 2066|  1.55M|    for (SEXP b = FRAME(rho);
 2067|  8.54M|	 b != R_NilValue && REFCNT(b) == 1;
  ------------------
  |  Branch (2067:3): [True: 6.99M, False: 1.55M]
  |  Branch (2067:22): [True: 6.99M, False: 21]
  ------------------
 2068|  6.99M|	 b = CDR(b)) {
 2069|  6.99M|	if (BNDCELL_TAG(b)) continue;
  ------------------
  |  Branch (2069:6): [True: 1.01k, False: 6.99M]
  ------------------
 2070|  6.99M|	SEXP v = CAR(b);
 2071|  6.99M|	if (val != v) {
  ------------------
  |  Branch (2071:6): [True: 6.99M, False: 2.63k]
  ------------------
 2072|  6.99M|	    switch(TYPEOF(v)) {
  ------------------
  |  Branch (2072:13): [True: 6.20M, False: 785k]
  ------------------
 2073|  3.88M|	    case PROMSXP:
  ------------------
  |  |  116|  3.88M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2073:6): [True: 3.88M, False: 3.10M]
  ------------------
 2074|  3.88M|		if (REFCNT(v) == 1 && PRENV(v) == rho)
  ------------------
  |  Branch (2074:7): [True: 1.55M, False: 2.33M]
  |  Branch (2074:25): [True: 7.36k, False: 1.54M]
  ------------------
 2075|  7.36k|		    crefs++;
 2076|  3.88M|		break;
 2077|  2.31M|	    case CLOSXP:
  ------------------
  |  |  114|  2.31M|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (2077:6): [True: 2.31M, False: 4.67M]
  ------------------
 2078|  2.31M|		if (REFCNT(v) == 1 && CLOENV(v) == rho)
  ------------------
  |  Branch (2078:7): [True: 1.54M, False: 772k]
  |  Branch (2078:25): [True: 1.54M, False: 0]
  ------------------
 2079|  1.54M|		    crefs++;
 2080|  2.31M|		break;
 2081|  3.15k|	    case ENVSXP: /* is this worth bothering with? */
  ------------------
  |  |  115|  3.15k|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (2081:6): [True: 3.15k, False: 6.98M]
  ------------------
 2082|  3.15k|		if (v == rho)
  ------------------
  |  Branch (2082:7): [True: 2, False: 3.15k]
  ------------------
 2083|      2|		    crefs++;
 2084|  3.15k|		break;
 2085|  6.99M|	    }
 2086|  6.99M|	}
 2087|  6.99M|    }
 2088|  1.55M|    return crefs;
 2089|  1.55M|}
eval.c:clearPromise:
 2092|  4.74M|{
 2093|  4.74M|#ifdef IMMEDIATE_PROMISE_VALUES
 2094|       |    /* If PROMISE_TAG(p) is not zero then the promise is evaluated and
 2095|       |       the environment is already R_NilValue. Setting the value is not
 2096|       |       necessary, and clearing the code is probably not worth it. */
 2097|  4.74M|    if (PROMISE_TAG(p))	return;
  ------------------
  |  Branch (2097:9): [True: 437, False: 4.74M]
  ------------------
 2098|  4.74M|#endif
 2099|  4.74M|    SET_PRVALUE(p, R_UnboundValue);
 2100|  4.74M|    SET_PRENV(p, R_NilValue);
 2101|  4.74M|    SET_PRCODE(p, R_NilValue); /* for calls with literal values */
 2102|  4.74M|}
eval.c:cleanupEnvDots:
 2105|   775k|{
 2106|  1.55M|    for (; d != R_NilValue && REFCNT(d) == 1; d = CDR(d)) {
  ------------------
  |  Branch (2106:12): [True: 777k, False: 775k]
  |  Branch (2106:31): [True: 777k, False: 0]
  ------------------
 2107|   777k|	SEXP v = CAR(d);
 2108|   777k|	if (REFCNT(v) == 1 && TYPEOF(v) == PROMSXP)
  ------------------
  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2108:6): [True: 0, False: 777k]
  |  Branch (2108:24): [True: 0, False: 0]
  ------------------
 2109|      0|	    clearPromise(v);
 2110|   777k|	SETCAR(d, R_NilValue);
 2111|   777k|    }
 2112|   775k|}
eval.c:cleanupEnvVector:
 2115|   773k|{
 2116|       |    /* This is mainly for handling results of list(...) stored as a
 2117|       |       local variable. It would be cheaper to just use
 2118|       |       DECREMENT_REFCNT. It might also make sense to max out at len =
 2119|       |       10 or so, and to avoid ALTREP objects. */
 2120|       |
 2121|       |    /* FIXME: Disabled for now since a BUILTIN that saves its (NR)
 2122|       |       list can cause problems. .External.graphics does this for
 2123|       |       recording. Probably the best option is to not have the args go
 2124|       |       down as NR. Most of these are fixed now, but this stilll seems
 2125|       |       to wake things up, so hold off for now. */
 2126|   773k|    return;
 2127|       |
 2128|       |    // avoid ODS compiler warning.
 2129|       | #ifdef FALSE
 2130|       |    R_xlen_t len = XLENGTH(v);
 2131|       |    for (R_xlen_t i = 0; i < len; i++)
 2132|       |	SET_VECTOR_ELT(v, i, R_NilValue);
 2133|       |#endif
 2134|   773k|}
eval.c:is_exec_continuation:
 2191|  3.52M|{
 2192|  3.52M|    return (TYPEOF(val) == VECSXP && XLENGTH(val) == 4 &&
  ------------------
  |  |  131|  7.04M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2192:13): [True: 1.93M, False: 1.59M]
  |  Branch (2192:38): [True: 364, False: 1.93M]
  ------------------
 2193|    364|	    VECTOR_ELT(val, 0) == R_exec_token);
  ------------------
  |  Branch (2193:6): [True: 0, False: 364]
  ------------------
 2194|  3.52M|}
eval.c:asLogicalNoNA:
 2658|   771k|{
 2659|   771k|    int cond = NA_LOGICAL; // cannot be Rboolean
  ------------------
  |  |   55|   771k|#define NA_LOGICAL	R_NaInt
  ------------------
 2660|       |
 2661|       |    /* handle most common special case directly */
 2662|   771k|    if (IS_SCALAR(s, LGLSXP)) {
  ------------------
  |  |  121|   771k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2662:9): [True: 447, False: 770k]
  ------------------
 2663|    447|	cond = SCALAR_LVAL(s);
 2664|    447|	if (cond != NA_LOGICAL)
  ------------------
  |  |   55|    447|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (2664:6): [True: 447, False: 0]
  ------------------
 2665|    447|	    return (Rboolean) cond;
 2666|    447|    }
 2667|   770k|    else if (IS_SCALAR(s, INTSXP)) {
  ------------------
  |  |  123|   770k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2667:14): [True: 770k, False: 0]
  ------------------
 2668|   770k|	int val = SCALAR_IVAL(s);
 2669|   770k|	if (val != NA_INTEGER)
  ------------------
  |  |   56|   770k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (2669:6): [True: 770k, False: 0]
  ------------------
 2670|   770k|	    return val != 0;
 2671|   770k|    }
 2672|       |
 2673|      0|    int len = length(s);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 2674|      0|    if (len > 1)
  ------------------
  |  Branch (2674:9): [True: 0, False: 0]
  ------------------
 2675|      0|	errorcall(call, _("the condition has length > 1"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("the condition has length > 1"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2676|      0|    if (len > 0) {
  ------------------
  |  Branch (2676:9): [True: 0, False: 0]
  ------------------
 2677|       |	/* inline common cases for efficiency */
 2678|      0|	switch(TYPEOF(s)) {
 2679|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2679:2): [True: 0, False: 0]
  ------------------
 2680|      0|	    cond = LOGICAL(s)[0];
 2681|      0|	    break;
 2682|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2682:2): [True: 0, False: 0]
  ------------------
 2683|      0|	    cond = INTEGER(s)[0]; /* relies on NA_INTEGER == NA_LOGICAL */
 2684|      0|	    break;
 2685|      0|	default:
  ------------------
  |  Branch (2685:2): [True: 0, False: 0]
  ------------------
 2686|      0|	    cond = asLogical(s);
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
 2687|      0|	}
 2688|      0|    }
 2689|       |
 2690|      0|    if (cond == NA_LOGICAL) {
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (2690:9): [True: 0, False: 0]
  ------------------
 2691|      0|	char *msg = len ? (isLogical(s) ?
  ------------------
  |  |  952|      0|#define isLogical		Rf_isLogical
  ------------------
  |  Branch (2691:14): [True: 0, False: 0]
  |  Branch (2691:21): [True: 0, False: 0]
  ------------------
 2692|      0|			   _("missing value where TRUE/FALSE needed") :
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2693|      0|			   _("argument is not interpretable as logical")) :
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2694|      0|	    _("argument is of length zero");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2695|      0|	errorcall(call, "%s", msg);
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 2696|      0|    }
 2697|      0|    return (Rboolean) cond;
 2698|      0|}
eval.c:GET_BINDING_CELL:
 2747|  16.0M|{
 2748|  16.0M|    if (rho == R_BaseEnv || rho == R_BaseNamespace || IS_USER_DATABASE(rho))
  ------------------
  |  | 2744|  16.0M|    (OBJECT((rho)) && inherits((rho), "UserDefinedDatabase"))
  |  |  ------------------
  |  |  |  |  933|      0|#define inherits		Rf_inherits
  |  |  ------------------
  |  |  |  Branch (2744:6): [True: 0, False: 16.0M]
  |  |  |  Branch (2744:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (2748:9): [True: 0, False: 16.0M]
  |  Branch (2748:29): [True: 0, False: 16.0M]
  ------------------
 2749|      0|	return R_NilValue;
 2750|  16.0M|    else {
 2751|  16.0M|	R_varloc_t loc = R_findVarLocInFrame(rho, symbol);
 2752|  16.0M|	return (! R_VARLOC_IS_NULL(loc) && ! IS_ACTIVE_BINDING(loc.cell)) ?
  ------------------
  |  | 2053|  32.1M|#define R_VARLOC_IS_NULL(loc) ((loc).cell == NULL)
  ------------------
  |  Branch (2752:10): [True: 15.9M, False: 69.3k]
  |  Branch (2752:37): [True: 15.9M, False: 0]
  ------------------
 2753|  15.9M|	    loc.cell : R_NilValue;
 2754|  16.0M|    }
 2755|  16.0M|}
eval.c:SET_BINDING_VALUE:
 2757|  10.8M|static R_INLINE Rboolean SET_BINDING_VALUE(SEXP loc, SEXP value) {
 2758|       |    /* This depends on the current implementation of bindings */
 2759|  10.8M|    if (loc != R_NilValue &&
  ------------------
  |  Branch (2759:9): [True: 1.93M, False: 8.90M]
  ------------------
 2760|  1.93M|	! BINDING_IS_LOCKED(loc) && ! IS_ACTIVE_BINDING(loc)) {
  ------------------
  |  Branch (2760:2): [True: 1.93M, False: 0]
  |  Branch (2760:30): [True: 1.93M, False: 0]
  ------------------
 2761|  1.93M|	if (BNDCELL_TAG(loc) || CAR(loc) != value) {
  ------------------
  |  Branch (2761:6): [True: 0, False: 1.93M]
  |  Branch (2761:26): [True: 775k, False: 1.16M]
  ------------------
 2762|   775k|	    SET_BNDCELL(loc, value);
 2763|   775k|	    if (MISSING(loc))
  ------------------
  |  Branch (2763:10): [True: 32, False: 775k]
  ------------------
 2764|     32|		SET_MISSING(loc, 0);
 2765|   775k|	}
 2766|  1.93M|	return TRUE;
 2767|  1.93M|    }
 2768|  8.90M|    else
 2769|  8.90M|	return FALSE;
 2770|  10.8M|}
eval.c:getBlockSrcrefs:
 1987|  1.79k|{
 1988|  1.79k|    SEXP srcrefs = getAttrib(call, R_SrcrefSymbol);
  ------------------
  |  |  924|  1.79k|#define getAttrib		Rf_getAttrib
  ------------------
 1989|  1.79k|    if (TYPEOF(srcrefs) == VECSXP) return srcrefs;
  ------------------
  |  |  131|  1.79k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1989:9): [True: 0, False: 1.79k]
  ------------------
 1990|  1.79k|    return R_NilValue;
 1991|  1.79k|}
eval.c:getSrcref:
 1997|  6.18k|{
 1998|  6.18k|    SEXP result;
 1999|  6.18k|    if (!isNull(srcrefs)
  ------------------
  |  |  956|  6.18k|#define isNull			Rf_isNull
  ------------------
  |  Branch (1999:9): [True: 0, False: 6.18k]
  ------------------
 2000|      0|	&& length(srcrefs) > ind
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (2000:5): [True: 0, False: 0]
  ------------------
 2001|      0|	&& !isNull(result = VECTOR_ELT(srcrefs, ind))
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (2001:5): [True: 0, False: 0]
  ------------------
 2002|      0|	&& TYPEOF(result) == INTSXP
  ------------------
  |  |  123|  6.18k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2002:5): [True: 0, False: 0]
  ------------------
 2003|      0|	&& length(result) >= 6)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (2003:5): [True: 0, False: 0]
  ------------------
 2004|      0|	return result;
 2005|  6.18k|    else
 2006|  6.18k|	return R_NilValue;
 2007|  6.18k|}
eval.c:applydefine:
 3384|     32|{
 3385|     32|    SEXP expr, lhs, rhs, saverhs, tmp, afun, rhsprom;
 3386|     32|    R_varloc_t tmploc;
 3387|     32|    RCNTXT cntxt;
 3388|     32|    int nprot;
 3389|       |
 3390|     32|    expr = CAR(args);
 3391|       |
 3392|       |    /*  It's important that the rhs get evaluated first because
 3393|       |	assignment is right associative i.e.  a <- b <- c is parsed as
 3394|       |	a <- (b <- c).  */
 3395|       |
 3396|     32|    R_bcstack_t *old_bcprot_top = R_BCProtTop;
 3397|     32|    INCREMENT_BCSTACK_LINKS();
  ------------------
  |  | 1057|     32|#define INCREMENT_BCSTACK_LINKS() do {			\
  |  | 1058|     32|	if (R_BCNodeStackTop > R_BCProtTop)		\
  |  |  ------------------
  |  |  |  Branch (1058:6): [True: 4, False: 28]
  |  |  ------------------
  |  | 1059|     32|	    INCLNK_stack(R_BCNodeStackTop);		\
  |  | 1060|     32|    } while (0)
  |  |  ------------------
  |  |  |  Branch (1060:14): [Folded, False: 32]
  |  |  ------------------
  ------------------
 3398|     32|    INCLNK_stack_commit();
 3399|       |
 3400|     32|    PROTECT(saverhs = rhs = eval(CADR(args), rho));
  ------------------
  |  |  357|     32|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3401|     32|#ifdef SWITCH_TO_REFCNT
 3402|     32|    int refrhs = MAYBE_REFERENCED(saverhs);
  ------------------
  |  |  251|     32|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  ------------------
 3403|     32|    if (refrhs) INCREMENT_REFCNT(saverhs);
  ------------------
  |  Branch (3403:9): [True: 32, False: 0]
  ------------------
 3404|     32|#endif
 3405|       |
 3406|       |    /*  FIXME: We need to ensure that this works for hashed
 3407|       |	environments.  This code only works for unhashed ones.  the
 3408|       |	syntax error here is a deliberate marker so I don't forget that
 3409|       |	this needs to be done.  The code used in "missing" will help
 3410|       |	here.  */
 3411|       |
 3412|       |    /*  FIXME: This strategy will not work when we are working in the
 3413|       |	data frame defined by the system hash table.  The structure there
 3414|       |	is different.  Should we special case here?  */
 3415|       |
 3416|       |    /*  We need a temporary variable to hold the intermediate values
 3417|       |	in the computation.  For efficiency reasons we record the
 3418|       |	location where this variable is stored.  We need to protect
 3419|       |	the location in case the biding is removed from its
 3420|       |	environment by user code or an assignment within the
 3421|       |	assignment arguments */
 3422|       |
 3423|       |    /*  There are two issues with the approach here:
 3424|       |
 3425|       |	    A complex assignment within a complex assignment, like
 3426|       |	    f(x, y[] <- 1) <- 3, can cause the value temporary
 3427|       |	    variable for the outer assignment to be overwritten and
 3428|       |	    then removed by the inner one.  This could be addressed by
 3429|       |	    using multiple temporaries or using a promise for this
 3430|       |	    variable as is done for the RHS.  Printing of the
 3431|       |	    replacement function call in error messages might then need
 3432|       |	    to be adjusted.
 3433|       |
 3434|       |	    With assignments of the form f(g(x, z), y) <- w the value
 3435|       |	    of 'z' will be computed twice, once for a call to g(x, z)
 3436|       |	    and once for the call to the replacement function g<-.  It
 3437|       |	    might be possible to address this by using promises.
 3438|       |	    Using more temporaries would not work as it would mess up
 3439|       |	    replacement functions that use substitute and/or
 3440|       |	    nonstandard evaluation (and there are packages that do
 3441|       |	    that -- igraph is one).
 3442|       |
 3443|       |	    LT */
 3444|       |
 3445|     32|    FIXUP_RHS_NAMED(rhs);
  ------------------
  |  | 3308|     32|#define FIXUP_RHS_NAMED(r) do { \
  |  | 3309|     32|	SEXP __rhs__ = (r); \
  |  | 3310|     32|	if (NAMED(__rhs__)) \
  |  |  ------------------
  |  |  |  Branch (3310:6): [True: 32, False: 0]
  |  |  ------------------
  |  | 3311|     32|	    ENSURE_NAMEDMAX(__rhs__); \
  |  | 3312|     32|    } while (0)
  |  |  ------------------
  |  |  |  Branch (3312:14): [Folded, False: 32]
  |  |  ------------------
  ------------------
 3446|       |
 3447|     32|    if (rho == R_BaseNamespace)
  ------------------
  |  Branch (3447:9): [True: 0, False: 32]
  ------------------
 3448|      0|	errorcall(call, _("cannot do complex assignments in base namespace"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("cannot do complex assignments in base namespace"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3449|     32|    if (rho == R_BaseEnv)
  ------------------
  |  Branch (3449:9): [True: 0, False: 32]
  ------------------
 3450|      0|	errorcall(call, _("cannot do complex assignments in base environment"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("cannot do complex assignments in base environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3451|       |
 3452|     32|    tmploc = R_findVarLocInFrame(rho, R_TmpvalSymbol);
 3453|     32|    SEXP oldTmpval = NULL;
 3454|     32|    if (tmploc.cell == NULL) {
  ------------------
  |  Branch (3454:9): [True: 32, False: 0]
  ------------------
 3455|     32|	defineVar(R_TmpvalSymbol, R_NilValue, rho);
  ------------------
  |  |  905|     32|#define defineVar		Rf_defineVar
  ------------------
 3456|     32|	tmploc = R_findVarLocInFrame(rho, R_TmpvalSymbol);
 3457|     32|	DISABLE_REFCNT(tmploc.cell);
 3458|     32|	DECREMENT_REFCNT(CDR(tmploc.cell));
 3459|     32|    }
 3460|      0|    else {
 3461|      0|	oldTmpval = R_GetVarLocValue(tmploc);
 3462|      0|	if (BINDING_IS_LOCKED(tmploc.cell))
  ------------------
  |  Branch (3462:6): [True: 0, False: 0]
  ------------------
 3463|      0|	    error(_("existing `*tmp*` binding is locked"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("existing `*tmp*` binding is locked"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3464|      0|	if (IS_ACTIVE_BINDING(tmploc.cell))
  ------------------
  |  Branch (3464:6): [True: 0, False: 0]
  ------------------
 3465|      0|	    error(_("existing `*tmp*` binding is an active binding"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("existing `*tmp*` binding is an active binding"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3466|      0|	PROTECT(oldTmpval);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3467|      0|    }
 3468|     32|    PROTECT(tmploc.cell);
  ------------------
  |  |  357|     32|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3469|       |
 3470|       |    /* Now set up a context to remove it when we are done, even in the
 3471|       |     * case of an error.  This all helps error() provide a better call.
 3472|       |     */
 3473|     32|    begincontext(&cntxt, CTXT_CCODE, call, R_BaseEnv, R_BaseEnv,
  ------------------
  |  | 1864|     32|# define begincontext		Rf_begincontext
  ------------------
 3474|     32|		 R_NilValue, R_NilValue);
 3475|     32|    cntxt.cend = &tmp_cleanup;
 3476|     32|    cntxt.cenddata = rho;
 3477|       |
 3478|       |    /*  Do a partial evaluation down through the LHS. */
 3479|     32|    R_varloc_t lhsloc;
 3480|     32|    lhs = evalseq(CADR(expr), rho,
 3481|     32|		  PRIMVAL(op)==1 || PRIMVAL(op)==3, tmploc, &lhsloc);
  ------------------
  |  | 1347|     32|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
              		  PRIMVAL(op)==1 || PRIMVAL(op)==3, tmploc, &lhsloc);
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (3481:5): [True: 32, False: 0]
  |  Branch (3481:23): [True: 0, False: 0]
  ------------------
 3482|     32|    if (lhsloc.cell == NULL)
  ------------------
  |  Branch (3482:9): [True: 0, False: 32]
  ------------------
 3483|      0|	lhsloc.cell = R_NilValue;
 3484|     32|    PROTECT(lhsloc.cell);
  ------------------
  |  |  357|     32|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3485|       |
 3486|     32|    PROTECT(lhs);
  ------------------
  |  |  357|     32|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3487|     32|    PROTECT(rhsprom = mkRHSPROMISE(CADR(args), rhs));
  ------------------
  |  |  357|     32|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3488|       |
 3489|     32|    while (isLanguage(CADR(expr))) {
  ------------------
  |  |  950|     32|#define isLanguage		Rf_isLanguage
  ------------------
  |  Branch (3489:12): [True: 0, False: 32]
  ------------------
 3490|      0|	nprot = 1; /* the PROTECT of rhs below from this iteration */
 3491|      0|	if (TYPEOF(CAR(expr)) == SYMSXP)
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (3491:6): [True: 0, False: 0]
  ------------------
 3492|      0|	    tmp = getAssignFcnSymbol(CAR(expr));
 3493|      0|	else {
 3494|       |	    /* check for and handle assignments of the form
 3495|       |	       foo::bar(x) <- y or foo:::bar(x) <- y */
 3496|      0|	    tmp = R_NilValue; /* avoid uninitialized variable warnings */
 3497|      0|	    if (TYPEOF(CAR(expr)) == LANGSXP &&
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (3497:10): [True: 0, False: 0]
  ------------------
 3498|      0|		(CAR(CAR(expr)) == R_DoubleColonSymbol ||
  ------------------
  |  Branch (3498:4): [True: 0, False: 0]
  ------------------
 3499|      0|		 CAR(CAR(expr)) == R_TripleColonSymbol) &&
  ------------------
  |  Branch (3499:4): [True: 0, False: 0]
  ------------------
 3500|      0|		length(CAR(expr)) == 3 && TYPEOF(CADDR(CAR(expr))) == SYMSXP) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
              		length(CAR(expr)) == 3 && TYPEOF(CADDR(CAR(expr))) == SYMSXP) {
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (3500:3): [True: 0, False: 0]
  |  Branch (3500:29): [True: 0, False: 0]
  ------------------
 3501|      0|		tmp = getAssignFcnSymbol(CADDR(CAR(expr)));
 3502|      0|		PROTECT(tmp = lang3(CAAR(expr), CADR(CAR(expr)), tmp));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3503|      0|		nprot++;
 3504|      0|	    }
 3505|      0|	    else
 3506|      0|		error(_("invalid function in complex assignment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("invalid function in complex assignment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3507|      0|	}
 3508|      0|	SET_TEMPVARLOC_FROM_CAR(tmploc, lhs);
  ------------------
  |  | 3293|      0|#define SET_TEMPVARLOC_FROM_CAR(loc, lhs) do { \
  |  | 3294|      0|	SEXP __lhs__ = (lhs); \
  |  | 3295|      0|	SEXP __v__ = CAR(__lhs__); \
  |  | 3296|      0|	if (MAYBE_SHARED(__v__)) { \
  |  |  ------------------
  |  |  |  Branch (3296:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 3297|      0|	    __v__ = shallow_duplicate(__v__); \
  |  |  ------------------
  |  |  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  |  |  ------------------
  |  | 3298|      0|	    ENSURE_NAMED(__v__); \
  |  | 3299|      0|	    SETCAR(__lhs__, __v__); \
  |  | 3300|      0|	} \
  |  | 3301|      0|	R_SetVarLocValue(loc, __v__); \
  |  | 3302|      0|    } while(0)
  |  |  ------------------
  |  |  |  Branch (3302:13): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3509|      0|	PROTECT(rhs = replaceCall(tmp, R_TmpvalSymbol, CDDR(expr), rhsprom));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3510|      0|	rhs = eval(rhs, rho);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 3511|      0|	SET_PRVALUE(rhsprom, rhs);
 3512|      0|	SET_PRCODE(rhsprom, rhs); /* not good but is what we have been doing */
 3513|      0|	UNPROTECT(nprot);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3514|      0|	lhs = CDR(lhs);
 3515|      0|	expr = CADR(expr);
 3516|      0|    }
 3517|     32|    nprot = 6; /* the commont case */
 3518|     32|    if (oldTmpval != NULL) nprot++;
  ------------------
  |  Branch (3518:9): [True: 0, False: 32]
  ------------------
 3519|       |
 3520|     32|    if (TYPEOF(CAR(expr)) == SYMSXP)
  ------------------
  |  |  112|     32|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (3520:9): [True: 32, False: 0]
  ------------------
 3521|     32|	afun = getAssignFcnSymbol(CAR(expr));
 3522|      0|    else {
 3523|       |	/* check for and handle assignments of the form
 3524|       |	   foo::bar(x) <- y or foo:::bar(x) <- y */
 3525|      0|	afun = R_NilValue; /* avoid uninitialized variable warnings */
 3526|      0|	if (TYPEOF(CAR(expr)) == LANGSXP &&
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (3526:6): [True: 0, False: 0]
  ------------------
 3527|      0|	    (CAR(CAR(expr)) == R_DoubleColonSymbol ||
  ------------------
  |  Branch (3527:7): [True: 0, False: 0]
  ------------------
 3528|      0|	     CAR(CAR(expr)) == R_TripleColonSymbol) &&
  ------------------
  |  Branch (3528:7): [True: 0, False: 0]
  ------------------
 3529|      0|	    length(CAR(expr)) == 3 && TYPEOF(CADDR(CAR(expr))) == SYMSXP) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
              	    length(CAR(expr)) == 3 && TYPEOF(CADDR(CAR(expr))) == SYMSXP) {
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (3529:6): [True: 0, False: 0]
  |  Branch (3529:32): [True: 0, False: 0]
  ------------------
 3530|      0|	    afun = getAssignFcnSymbol(CADDR(CAR(expr)));
 3531|      0|	    PROTECT(afun = lang3(CAAR(expr), CADR(CAR(expr)), afun));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3532|      0|	    nprot++;
 3533|      0|	}
 3534|      0|	else
 3535|      0|	    error(_("invalid function in complex assignment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid function in complex assignment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3536|      0|    }
 3537|     32|    SET_TEMPVARLOC_FROM_CAR(tmploc, lhs);
  ------------------
  |  | 3293|     32|#define SET_TEMPVARLOC_FROM_CAR(loc, lhs) do { \
  |  | 3294|     32|	SEXP __lhs__ = (lhs); \
  |  | 3295|     32|	SEXP __v__ = CAR(__lhs__); \
  |  | 3296|     32|	if (MAYBE_SHARED(__v__)) { \
  |  |  ------------------
  |  |  |  Branch (3296:6): [True: 32, False: 0]
  |  |  ------------------
  |  | 3297|     32|	    __v__ = shallow_duplicate(__v__); \
  |  |  ------------------
  |  |  |  | 1030|     32|#define shallow_duplicate	Rf_shallow_duplicate
  |  |  ------------------
  |  | 3298|     32|	    ENSURE_NAMED(__v__); \
  |  | 3299|     32|	    SETCAR(__lhs__, __v__); \
  |  | 3300|     32|	} \
  |  | 3301|     32|	R_SetVarLocValue(loc, __v__); \
  |  | 3302|     32|    } while(0)
  |  |  ------------------
  |  |  |  Branch (3302:13): [Folded, False: 32]
  |  |  ------------------
  ------------------
 3538|     32|    SEXP lhsSym = CDR(lhs);
 3539|       |
 3540|     32|    PROTECT(expr = replaceCall(afun, R_TmpvalSymbol, CDDR(expr), rhsprom));
  ------------------
  |  |  357|     32|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3541|     32|    SEXP value = eval(expr, rho);
  ------------------
  |  |  913|     32|#define eval			Rf_eval
  ------------------
 3542|       |
 3543|     32|    SET_ASSIGNMENT_PENDING(lhsloc.cell, FALSE);
 3544|     32|    if (PRIMVAL(op) == 2)                       /* <<- */
  ------------------
  |  | 1347|     32|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (3544:9): [True: 0, False: 32]
  ------------------
 3545|      0|	setVar(lhsSym, value, ENCLOS(rho));
  ------------------
  |  | 1029|      0|#define setVar			Rf_setVar
  ------------------
 3546|     32|    else {                                      /* <-, = */
 3547|     32|	if (ALTREP(value)) {
  ------------------
  |  Branch (3547:6): [True: 0, False: 32]
  ------------------
 3548|      0|	    PROTECT(value);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3549|      0|	    value = try_assign_unwrap(value, lhsSym, rho, NULL);
 3550|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3551|      0|	}
 3552|     32|	defineVar(lhsSym, value, rho);
  ------------------
  |  |  905|     32|#define defineVar		Rf_defineVar
  ------------------
 3553|     32|    }
 3554|     32|    INCREMENT_NAMED(value);
  ------------------
  |  |  222|     32|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 32]
  |  |  ------------------
  ------------------
 3555|     32|    R_Visible = FALSE;
 3556|       |
 3557|     32|    endcontext(&cntxt); /* which does not run the remove */
  ------------------
  |  | 1895|     32|# define endcontext		Rf_endcontext
  ------------------
 3558|     32|    if (oldTmpval == NULL)
  ------------------
  |  Branch (3558:9): [True: 32, False: 0]
  ------------------
 3559|     32|	unbindVar(R_TmpvalSymbol, rho);
  ------------------
  |  | 2004|     32|# define unbindVar		Rf_unbindVar
  ------------------
 3560|      0|    else
 3561|      0|	R_SetVarLocValue(tmploc, oldTmpval);
 3562|     32|    UNPROTECT(nprot);
  ------------------
  |  |  358|     32|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3563|       |#ifdef OLD_RHS_NAMED
 3564|       |    /* we do not duplicate the value, so to be conservative mark the
 3565|       |       value as NAMED = NAMEDMAX */
 3566|       |    ENSURE_NAMEDMAX(saverhs);
 3567|       |#else
 3568|     32|    INCREMENT_NAMED(saverhs);
  ------------------
  |  |  222|     32|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 32]
  |  |  ------------------
  ------------------
 3569|     32|#endif
 3570|     32|#ifdef SWITCH_TO_REFCNT
 3571|     32|    if (refrhs) DECREMENT_REFCNT(saverhs);
  ------------------
  |  Branch (3571:9): [True: 32, False: 0]
  ------------------
 3572|     32|#endif
 3573|       |
 3574|     32|    DECREMENT_BCSTACK_LINKS(old_bcprot_top);
  ------------------
  |  | 1062|     32|#define DECREMENT_BCSTACK_LINKS(oldptop) do {		\
  |  | 1063|     32|	if (R_BCProtTop > (oldptop))			\
  |  |  ------------------
  |  |  |  Branch (1063:6): [True: 4, False: 28]
  |  |  ------------------
  |  | 1064|     32|	    DECLNK_stack(oldptop);			\
  |  | 1065|     32|    } while (0)
  |  |  ------------------
  |  |  |  Branch (1065:14): [Folded, False: 32]
  |  |  ------------------
  ------------------
 3575|       |
 3576|     32|    return saverhs;
 3577|     32|}
eval.c:INCLNK_stack:
 1018|  9.36M|{
 1019|  9.36M|    R_BCProtTop = top;
 1020|  9.36M|}
eval.c:INCLNK_stack_commit:
 1023|  1.92M|{
 1024|  1.92M|    if (R_BCProtCommitted < R_BCProtTop) {
  ------------------
  |  Branch (1024:9): [True: 1.54M, False: 386k]
  ------------------
 1025|  1.54M|	R_bcstack_t *base = R_BCProtCommitted;
 1026|  1.54M|	R_bcstack_t *top = R_BCProtTop;
 1027|  52.8M|	for (R_bcstack_t *p = base; p < top; p++) {
  ------------------
  |  Branch (1027:30): [True: 51.3M, False: 1.54M]
  ------------------
 1028|  51.3M|	    if (p->tag == RAWMEM_TAG || p->tag == CACHESZ_TAG)
  ------------------
  |  | 1401|   102M|# define RAWMEM_TAG 254
  ------------------
              	    if (p->tag == RAWMEM_TAG || p->tag == CACHESZ_TAG)
  ------------------
  |  | 1402|  38.1M|# define CACHESZ_TAG 253
  ------------------
  |  Branch (1028:10): [True: 13.1M, False: 38.1M]
  |  Branch (1028:34): [True: 10.0M, False: 28.1M]
  ------------------
 1029|  23.1M|		p += p->u.ival;
 1030|  28.1M|	    else if (p->tag == 0)
  ------------------
  |  Branch (1030:15): [True: 25.8M, False: 2.31M]
  ------------------
 1031|  25.8M|		INCREMENT_LINKS(p->u.sxpval);
  ------------------
  |  |  540|  25.8M|#define INCREMENT_LINKS(x) do {			\
  |  |  541|  25.8M|	SEXP il__x__ = (x);			\
  |  |  542|  25.8M|	INCREMENT_NAMED(il__x__);		\
  |  |  ------------------
  |  |  |  |  222|  25.8M|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 25.8M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  543|  25.8M|	INCREMENT_REFCNT(il__x__);		\
  |  |  544|  25.8M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (544:14): [Folded, False: 25.8M]
  |  |  ------------------
  ------------------
 1032|  51.3M|	}
 1033|  1.54M|	R_BCProtCommitted = R_BCProtTop;
 1034|  1.54M|    }
 1035|  1.92M|}
eval.c:evalseq:
 3187|     32|{
 3188|     32|    SEXP val, nval, nexpr;
 3189|     32|    if (isNull(expr))
  ------------------
  |  |  956|     32|#define isNull			Rf_isNull
  ------------------
  |  Branch (3189:9): [True: 0, False: 32]
  ------------------
 3190|      0|	error(_("invalid (NULL) left side of assignment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid (NULL) left side of assignment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3191|     32|    if (isSymbol(expr)) { /* now we are down to the target symbol */
  ------------------
  |  |  953|     32|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (3191:9): [True: 32, False: 0]
  ------------------
 3192|     32|	PROTECT(expr);
  ------------------
  |  |  357|     32|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3193|     32|	if(forcelocal) {
  ------------------
  |  Branch (3193:5): [True: 32, False: 0]
  ------------------
 3194|     32|	    nval = EnsureLocal(expr, rho, ploc);
 3195|     32|	}
 3196|      0|	else {
 3197|      0|	    nval = eval(expr, ENCLOS(rho));
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 3198|      0|	    PROTECT(nval); /* R_findVarLoc allocates for user databases */
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3199|      0|	    *ploc = R_findVarLoc(expr, ENCLOS(rho));
 3200|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3201|      0|	}
 3202|     32|	int maybe_in_assign = ploc->cell ?
  ------------------
  |  Branch (3202:24): [True: 32, False: 0]
  ------------------
 3203|     32|	    ASSIGNMENT_PENDING(ploc->cell) : FALSE;
 3204|     32|	if (ploc->cell)
  ------------------
  |  Branch (3204:6): [True: 32, False: 0]
  ------------------
 3205|     32|	    SET_ASSIGNMENT_PENDING(ploc->cell, TRUE);
 3206|     32|	if (maybe_in_assign || MAYBE_SHARED(nval))
  ------------------
  |  Branch (3206:6): [True: 0, False: 32]
  |  Branch (3206:25): [True: 32, False: 0]
  ------------------
 3207|     32|	    nval = shallow_duplicate(nval);
  ------------------
  |  | 1030|     32|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 3208|     32|	UNPROTECT(1);
  ------------------
  |  |  358|     32|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3209|     32|	return CONS_NR(nval, expr);
 3210|     32|    }
 3211|      0|    else if (isLanguage(expr)) {
  ------------------
  |  |  950|      0|#define isLanguage		Rf_isLanguage
  ------------------
  |  Branch (3211:14): [True: 0, False: 0]
  ------------------
 3212|      0|	PROTECT(expr);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3213|      0|	PROTECT(val = evalseq(CADR(expr), rho, forcelocal, tmploc, ploc));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3214|      0|	R_SetVarLocValue(tmploc, CAR(val));
 3215|      0|	PROTECT(nexpr = LCONS(R_GetVarLocSymbol(tmploc), CDDR(expr)));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3216|      0|	PROTECT(nexpr = LCONS(CAR(expr), nexpr));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3217|      0|	nval = eval(nexpr, rho);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 3218|       |	/* duplicate nval if it might be shared _or_ if the container,
 3219|       |	   CAR(val), has become possibly shared by going through a
 3220|       |	   closure.  This is taken to indicate that the corresponding
 3221|       |	   replacement function might be a closure and will need to
 3222|       |	   see an unmodified LHS value. This heuristic fails if the
 3223|       |	   accessor function called here is not a closure but the
 3224|       |	   replacement function is. */
 3225|      0|	if (MAYBE_REFERENCED(nval) &&
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3226|      0|	    (MAYBE_SHARED(nval) || MAYBE_SHARED(CAR(val))))
  ------------------
  |  Branch (3226:7): [True: 0, False: 0]
  |  Branch (3226:29): [True: 0, False: 0]
  ------------------
 3227|      0|	    nval = shallow_duplicate(nval);
  ------------------
  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 3228|      0|	UNPROTECT(4);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3229|      0|	return CONS_NR(nval, val);
 3230|      0|    }
 3231|      0|    else error(_("target of assignment expands to non-language object"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  else error(_("target of assignment expands to non-language object"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3232|      0|    return R_NilValue;	/*NOTREACHED*/
 3233|     32|}
eval.c:EnsureLocal:
 2592|  1.15M|{
 2593|  1.15M|    SEXP vl;
 2594|       |
 2595|  1.15M|    if ((vl = R_findVarInFrame(rho, symbol)) != R_UnboundValue) {
  ------------------
  |  Branch (2595:9): [True: 1.15M, False: 1.26k]
  ------------------
 2596|  1.15M|	vl = eval(symbol, rho);	/* for promises */
  ------------------
  |  |  913|  1.15M|#define eval			Rf_eval
  ------------------
 2597|  1.15M|	if(MAYBE_SHARED(vl)) {
  ------------------
  |  Branch (2597:5): [True: 385k, False: 770k]
  ------------------
 2598|       |	    /* Using R_shallow_duplicate_attr may defer duplicating
 2599|       |	       data until it it is needed. If the data are duplicated,
 2600|       |	       then the wrapper can be discarded at the end of the
 2601|       |	       assignment process in try_assign_unwrap(). */
 2602|   385k|	    PROTECT(vl);
  ------------------
  |  |  357|   385k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2603|   385k|	    PROTECT(vl = R_shallow_duplicate_attr(vl));
  ------------------
  |  |  357|   385k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2604|   385k|	    defineVar(symbol, vl, rho);
  ------------------
  |  |  905|   385k|#define defineVar		Rf_defineVar
  ------------------
 2605|   385k|	    INCREMENT_NAMED(vl);
  ------------------
  |  |  222|   385k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 385k]
  |  |  ------------------
  ------------------
 2606|   385k|	    UNPROTECT(2);
  ------------------
  |  |  358|   385k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2607|   385k|	}
 2608|  1.15M|	PROTECT(vl); /* R_findVarLocInFrame allocates for user databases */
  ------------------
  |  |  357|  1.15M|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2609|  1.15M|	*ploc = R_findVarLocInFrame(rho, symbol);
 2610|  1.15M|	UNPROTECT(1);
  ------------------
  |  |  358|  1.15M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2611|  1.15M|	return vl;
 2612|  1.15M|    }
 2613|       |
 2614|  1.26k|    vl = eval(symbol, ENCLOS(rho));
  ------------------
  |  |  913|  1.26k|#define eval			Rf_eval
  ------------------
 2615|  1.26k|    if (vl == R_UnboundValue) // can this really happen?
  ------------------
  |  Branch (2615:9): [True: 0, False: 1.26k]
  ------------------
 2616|      0|	R_ObjectNotFoundError(symbol, R_CurrentExpression, NULL);
 2617|       |
 2618|  1.26k|    PROTECT(vl = shallow_duplicate(vl));
  ------------------
  |  |  357|  1.26k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2619|  1.26k|    defineVar(symbol, vl, rho);
  ------------------
  |  |  905|  1.26k|#define defineVar		Rf_defineVar
  ------------------
 2620|  1.26k|    *ploc = R_findVarLocInFrame(rho, symbol);
 2621|  1.26k|    INCREMENT_NAMED(vl);
  ------------------
  |  |  222|  1.26k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 1.26k]
  |  |  ------------------
  ------------------
 2622|  1.26k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.26k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2623|  1.26k|    return vl;
 2624|  1.15M|}
eval.c:mkRHSPROMISE:
 3349|   770k|{
 3350|   770k|    return R_mkEVPROMISE_NR(expr, rhs);
 3351|   770k|}
eval.c:getAssignFcnSymbol:
 3330|     32|{
 3331|       |    /* handle [<-, [[<-, and $<- efficiently */
 3332|     32|    if (fun == R_SubsetSym)
  ------------------
  |  Branch (3332:9): [True: 0, False: 32]
  ------------------
 3333|      0|	return R_SubassignSym;
 3334|     32|    else if (fun == R_Subset2Sym)
  ------------------
  |  Branch (3334:14): [True: 16, False: 16]
  ------------------
 3335|     16|	return R_Subassign2Sym;
 3336|     16|    else if (fun == R_DollarSymbol)
  ------------------
  |  Branch (3336:14): [True: 0, False: 16]
  ------------------
 3337|      0|	return R_DollarGetsSymbol;
 3338|       |
 3339|       |    /* look up in the replacement functions table */
 3340|     16|    SEXP val = lookupAssignFcnSymbol(fun);
 3341|     16|    if (val != R_UnboundValue)
  ------------------
  |  Branch (3341:9): [True: 14, False: 2]
  ------------------
 3342|     14|	return val;
 3343|       |
 3344|       |    /* instal symbol, entern in table,  and return */
 3345|      2|    return installAssignFcnSymbol(fun);
 3346|     16|}
eval.c:lookupAssignFcnSymbol:
 3273|     16|{
 3274|     16|    return R_findVarInFrame(R_ReplaceFunsTable, fun);
 3275|     16|}
eval.c:installAssignFcnSymbol:
 3316|      2|{
 3317|      2|    char buf[ASSIGNBUFSIZ];
 3318|       |
 3319|       |    /* install the symbol */
 3320|      2|    if(strlen(CHAR(PRINTNAME(fun))) + 3 > ASSIGNBUFSIZ)
  ------------------
  |  |  203|      2|#define CHAR(x) R_CHAR(x)
  ------------------
                  if(strlen(CHAR(PRINTNAME(fun))) + 3 > ASSIGNBUFSIZ)
  ------------------
  |  | 3314|      2|#define ASSIGNBUFSIZ 32
  ------------------
  |  Branch (3320:8): [True: 0, False: 2]
  ------------------
 3321|      0|	error(_("overlong name in '%s'"), EncodeChar(PRINTNAME(fun)));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("overlong name in '%s'"), EncodeChar(PRINTNAME(fun)));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              	error(_("overlong name in '%s'"), EncodeChar(PRINTNAME(fun)));
  ------------------
  |  | 1890|      0|# define EncodeChar             Rf_EncodeChar
  ------------------
 3322|      2|    snprintf(buf, ASSIGNBUFSIZ, "%s<-", CHAR(PRINTNAME(fun)));
  ------------------
  |  | 3314|      2|#define ASSIGNBUFSIZ 32
  ------------------
                  snprintf(buf, ASSIGNBUFSIZ, "%s<-", CHAR(PRINTNAME(fun)));
  ------------------
  |  |  203|      2|#define CHAR(x) R_CHAR(x)
  ------------------
 3323|      2|    SEXP val = install(buf);
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 3324|       |
 3325|      2|    enterAssignFcnSymbol(fun, val);
 3326|      2|    return val;
 3327|      2|}
eval.c:enterAssignFcnSymbol:
 3278|      2|{
 3279|      2|    defineVar(fun, val, R_ReplaceFunsTable);
  ------------------
  |  |  905|      2|#define defineVar		Rf_defineVar
  ------------------
 3280|      2|}
eval.c:replaceCall:
 2634|     32|{
 2635|     32|    SEXP tmp, ptmp;
 2636|     32|    PROTECT(fun);
  ------------------
  |  |  357|     32|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2637|     32|    PROTECT(args);
  ------------------
  |  |  357|     32|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2638|     32|    PROTECT(rhs);
  ------------------
  |  |  357|     32|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2639|     32|    PROTECT(val);
  ------------------
  |  |  357|     32|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2640|     32|    ptmp = tmp = allocLang(length(args)+3);
  ------------------
  |  |  870|     32|#define allocLang		Rf_allocLang
  ------------------
                  ptmp = tmp = allocLang(length(args)+3);
  ------------------
  |  |  987|     32|#define length(x)		Rf_length(x)
  ------------------
 2641|     32|    UNPROTECT(4);
  ------------------
  |  |  358|     32|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2642|     32|    SETCAR(ptmp, fun); ptmp = CDR(ptmp);
 2643|     32|    SETCAR(ptmp, val); ptmp = CDR(ptmp);
 2644|     48|    while(args != R_NilValue) {
  ------------------
  |  Branch (2644:11): [True: 16, False: 32]
  ------------------
 2645|     16|	SETCAR(ptmp, CAR(args));
 2646|     16|	SET_TAG(ptmp, TAG(args));
 2647|     16|	ptmp = CDR(ptmp);
 2648|     16|	args = CDR(args);
 2649|     16|    }
 2650|     32|    SETCAR(ptmp, rhs);
 2651|     32|    SET_TAG(ptmp, R_valueSym);
 2652|     32|    MARK_ASSIGNMENT_CALL(tmp);
 2653|     32|    return tmp;
 2654|     32|}
eval.c:try_assign_unwrap:
 3358|      8|{
 3359|       |    /* If EnsureLocal() has introduced a wrapper for the LHS object in
 3360|       |       a complex assignment and the data has been duplicated, then it
 3361|       |       may be possible to remove the wrapper before assigning the
 3362|       |       final value to a its symbol. */
 3363|      8|    if (! MAYBE_REFERENCED(value))
  ------------------
  |  |  251|      8|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  ------------------
  |  Branch (3363:9): [True: 0, False: 8]
  ------------------
 3364|       |	/* Typical case for NAMED; can also happen for REFCNT. */
 3365|      0|	return R_tryUnwrap(value);
 3366|      8|#ifdef SWITCH_TO_REFCNT
 3367|      8|    else {
 3368|       |	/* Typical case for REFCNT; might not be safe to unwrap for NAMED. */
 3369|      8|	if (! MAYBE_SHARED(value)) {
  ------------------
  |  Branch (3369:6): [True: 8, False: 0]
  ------------------
 3370|      8|	    if (cell == NULL)  /* for AST; byte code has the binding */
  ------------------
  |  Branch (3370:10): [True: 0, False: 8]
  ------------------
 3371|      0|		cell = GET_BINDING_CELL(sym, rho);
 3372|       |	    /* Ruling out active bindigns may not be necessary at this
 3373|       |	       point, but just to be safe ... */
 3374|      8|	    if (! IS_ACTIVE_BINDING(cell) &&
  ------------------
  |  Branch (3374:10): [True: 8, False: 0]
  ------------------
 3375|      8|		value == BINDING_VALUE(cell))
  ------------------
  |  Branch (3375:3): [True: 8, False: 0]
  ------------------
 3376|      8|		return R_tryUnwrap(value);
 3377|      8|	}
 3378|      8|    }
 3379|      0|#endif
 3380|      0|    return value;
 3381|      8|}
eval.c:BINDING_VALUE:
 5707|  10.9M|{
 5708|  10.9M|    if (BNDCELL_TAG(loc)) {
  ------------------
  |  Branch (5708:9): [True: 22, False: 10.9M]
  ------------------
 5709|     22|	R_expand_binding_value(loc);
 5710|     22|	return CAR0(loc);
 5711|     22|    }
 5712|  10.9M|    else if (loc != R_NilValue && ! IS_ACTIVE_BINDING(loc))
  ------------------
  |  Branch (5712:14): [True: 10.9M, False: 45.7k]
  |  Branch (5712:35): [True: 10.9M, False: 0]
  ------------------
 5713|  10.9M|	return CAR0(loc);
 5714|  45.7k|    else
 5715|  45.7k|	return R_UnboundValue;
 5716|  10.9M|}
eval.c:promiseArgsEx:
 3798|  1.17M|{
 3799|  1.17M|    SEXP ans, h, tail;
 3800|       |
 3801|  1.17M|    PROTECT(ans = tail = CONS(R_NilValue, R_NilValue));
  ------------------
  |  |  357|  1.17M|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3802|       |
 3803|  4.28M|    while(el != R_NilValue) {
  ------------------
  |  Branch (3803:11): [True: 3.11M, False: 1.17M]
  ------------------
 3804|       |
 3805|       |	/* If we have a ... symbol, we look to see what it is bound to.
 3806|       |	 * If its binding is Null (i.e. zero length)
 3807|       |	 * we just ignore it and return the cdr with all its
 3808|       |	 * expressions promised; if it is bound to a ... list
 3809|       |	 * of promises, we repromise all the promises and then splice
 3810|       |	 * the list of resulting values into the return value.
 3811|       |	 * Anything else bound to a ... symbol is an error
 3812|       |	 */
 3813|       |
 3814|       |	/* double promises are needed to make sure a function argument
 3815|       |	   passed via ... is marked as referenced in the caller and
 3816|       |	   the callee */
 3817|       |
 3818|  3.11M|	if (CAR(el) == R_DotsSymbol) {
  ------------------
  |  Branch (3818:6): [True: 1.12k, False: 3.11M]
  ------------------
 3819|  1.12k|	    PROTECT(h = R_findVar(CAR(el), rho));
  ------------------
  |  |  357|  1.12k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3820|  1.12k|	    if (TYPEOF(h) == DOTSXP || h == R_NilValue) {
  ------------------
  |  |  127|  2.25k|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (3820:10): [True: 34, False: 1.09k]
  |  Branch (3820:33): [True: 0, False: 1.09k]
  ------------------
 3821|     92|		while (h != R_NilValue) {
  ------------------
  |  Branch (3821:10): [True: 58, False: 34]
  ------------------
 3822|     58|		    if (CAR(h) == R_MissingArg)
  ------------------
  |  Branch (3822:11): [True: 0, False: 58]
  ------------------
 3823|      0|		      SETCDR(tail, CONS(CAR(h), R_NilValue));
  ------------------
  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3824|     58|                    else
 3825|     58|		      SETCDR(tail, CONS(mkPROMISE(CAR(h), rho), R_NilValue));
  ------------------
  |  |  309|     58|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3826|     58|		    tail = CDR(tail);
 3827|     58|		    COPY_TAG(tail, h);
  ------------------
  |  | 3622|     58|#define COPY_TAG(to, from) do { \
  |  | 3623|     58|  SEXP __tag__ = TAG(from); \
  |  | 3624|     58|  if (__tag__ != R_NilValue) SET_TAG(to, __tag__); \
  |  |  ------------------
  |  |  |  Branch (3624:7): [True: 4, False: 54]
  |  |  ------------------
  |  | 3625|     58|} while (0)
  |  |  ------------------
  |  |  |  Branch (3625:10): [Folded, False: 58]
  |  |  ------------------
  ------------------
 3828|     58|		    h = CDR(h);
 3829|     58|		}
 3830|     34|	    }
 3831|  1.09k|	    else if (h != R_MissingArg)
  ------------------
  |  Branch (3831:15): [True: 0, False: 1.09k]
  ------------------
 3832|      0|		error(_("'...' used in an incorrect context"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("'...' used in an incorrect context"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3833|  1.12k|	    UNPROTECT(1); /* h */
  ------------------
  |  |  358|  1.12k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3834|  1.12k|	}
 3835|  3.11M|	else if (CAR(el) == R_MissingArg) {
  ------------------
  |  Branch (3835:11): [True: 6, False: 3.11M]
  ------------------
 3836|      6|	    SETCDR(tail, CONS(R_MissingArg, R_NilValue));
  ------------------
  |  |  309|      6|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3837|      6|	    tail = CDR(tail);
 3838|      6|	    COPY_TAG(tail, el);
  ------------------
  |  | 3622|      6|#define COPY_TAG(to, from) do { \
  |  | 3623|      6|  SEXP __tag__ = TAG(from); \
  |  | 3624|      6|  if (__tag__ != R_NilValue) SET_TAG(to, __tag__); \
  |  |  ------------------
  |  |  |  Branch (3624:7): [True: 0, False: 6]
  |  |  ------------------
  |  | 3625|      6|} while (0)
  |  |  ------------------
  |  |  |  Branch (3625:10): [Folded, False: 6]
  |  |  ------------------
  ------------------
 3839|      6|	}
 3840|  3.11M|	else {
 3841|  3.11M|	    if (forward && TYPEOF(CAR(el)) == SYMSXP) {
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (3841:10): [True: 0, False: 3.11M]
  |  Branch (3841:21): [True: 0, False: 0]
  ------------------
 3842|      0|		SEXP val = findVar(CAR(el), rho);
  ------------------
  |  |  918|      0|#define findVar			Rf_findVar
  ------------------
 3843|      0|		if (TYPEOF(val) == PROMSXP)
  ------------------
  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (3843:7): [True: 0, False: 0]
  ------------------
 3844|       |		    // repromise, or forward, argument to help with substitute()
 3845|      0|		    SETCDR(tail, CONS(mkPROMISE(val, rho), R_NilValue));
  ------------------
  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3846|      0|		else if (val == R_MissingArg)
  ------------------
  |  Branch (3846:12): [True: 0, False: 0]
  ------------------
 3847|      0|		    SETCDR(tail, CONS(R_MissingArg, R_NilValue));
  ------------------
  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3848|      0|		else
 3849|      0|		    SETCDR(tail, CONS(mkPROMISE(CAR(el), rho), R_NilValue));
  ------------------
  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3850|      0|	    }
 3851|  3.11M|	    else
 3852|  3.11M|		SETCDR(tail, CONS(mkPROMISE(CAR(el), rho), R_NilValue));
  ------------------
  |  |  309|  3.11M|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3853|  3.11M|	    tail = CDR(tail);
 3854|  3.11M|	    COPY_TAG(tail, el);
  ------------------
  |  | 3622|  3.11M|#define COPY_TAG(to, from) do { \
  |  | 3623|  3.11M|  SEXP __tag__ = TAG(from); \
  |  | 3624|  3.11M|  if (__tag__ != R_NilValue) SET_TAG(to, __tag__); \
  |  |  ------------------
  |  |  |  Branch (3624:7): [True: 772k, False: 2.33M]
  |  |  ------------------
  |  | 3625|  3.11M|} while (0)
  |  |  ------------------
  |  |  |  Branch (3625:10): [Folded, False: 3.11M]
  |  |  ------------------
  ------------------
 3855|  3.11M|	}
 3856|  3.11M|	el = CDR(el);
 3857|  3.11M|    }
 3858|  1.17M|    UNPROTECT(1);
  ------------------
  |  |  358|  1.17M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3859|  1.17M|    ans = CDR(ans);
 3860|  1.17M|    DECREMENT_REFCNT(ans);
 3861|  1.17M|    return ans;
 3862|  1.17M|}
eval.c:evalArgs:
 4087|  1.93k|{
 4088|  1.93k|    if(dropmissing) return evalList(el, rho, call, n);
  ------------------
  |  | 1898|      0|# define evalList		Rf_evalList
  ------------------
  |  Branch (4088:8): [True: 0, False: 1.93k]
  ------------------
 4089|  1.93k|    else return evalListKeepMissing(el, rho);
  ------------------
  |  | 1899|  1.93k|# define evalListKeepMissing	Rf_evalListKeepMissing
  ------------------
 4090|  1.93k|}
eval.c:unpromiseArgs:
 2174|  4.30M|{
 2175|       |    /* This assumes pargs will no longer be referenced. We could
 2176|       |       double check the refcounts on pargs as a sanity check. */
 2177|  12.1M|    for (; pargs != R_NilValue; pargs = CDR(pargs)) {
  ------------------
  |  Branch (2177:12): [True: 7.81M, False: 4.30M]
  ------------------
 2178|  7.81M|	SEXP v = CAR(pargs);
 2179|  7.81M|	if (TYPEOF(v) == PROMSXP && REFCNT(v) == 1)
  ------------------
  |  |  116|  15.6M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2179:6): [True: 7.41M, False: 396k]
  |  Branch (2179:30): [True: 4.32M, False: 3.09M]
  ------------------
 2180|  4.32M|	    clearPromise(v);
 2181|  7.81M|	SETCAR(pargs, R_NilValue);
 2182|  7.81M|    }
 2183|  4.30M|}
eval.c:classForGroupDispatch:
 4341|    152|static SEXP classForGroupDispatch(SEXP obj) {
 4342|       |
 4343|    152|    return IS_S4_OBJECT(obj) ? R_data_class2(obj)
  ------------------
  |  Branch (4343:12): [True: 0, False: 152]
  ------------------
 4344|    152|	    : getAttrib(obj, R_ClassSymbol);
  ------------------
  |  |  924|    152|#define getAttrib		Rf_getAttrib
  ------------------
 4345|    152|}
eval.c:findmethod:
 4310|     76|{
 4311|     76|    int len, whichclass;
 4312|     76|    const void *vmax = vmaxget();
 4313|       |
 4314|     76|    len = length(Class);
  ------------------
  |  |  987|     76|#define length(x)		Rf_length(x)
  ------------------
 4315|       |
 4316|       |    /* Need to interleave looking for group and generic methods
 4317|       |       e.g. if class(x) is c("foo", "bar)" then x > 3 should invoke
 4318|       |       "Ops.foo" rather than ">.bar"
 4319|       |    */
 4320|    176|    for (whichclass = 0 ; whichclass < len ; whichclass++) {
  ------------------
  |  Branch (4320:27): [True: 150, False: 26]
  ------------------
 4321|    150|	const char *ss = translateChar(STRING_ELT(Class, whichclass));
  ------------------
  |  | 1037|    150|#define translateChar		Rf_translateChar
  ------------------
 4322|    150|	*meth = installS3Signature(generic, ss);
  ------------------
  |  |  939|    150|#define installS3Signature	Rf_installS3Signature
  ------------------
 4323|    150|	*sxp = R_LookupMethod(*meth, rho, rho, R_BaseEnv);
 4324|    150|	if (isFunction(*sxp)) {
  ------------------
  |  |  948|    150|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (4324:6): [True: 0, False: 150]
  ------------------
 4325|      0|	    *gr = R_BlankScalarString;
 4326|      0|	    if (whichclass > 0) updateObjFromS4Slot(objSlot, ss);
  ------------------
  |  Branch (4326:10): [True: 0, False: 0]
  ------------------
 4327|      0|	    break;
 4328|      0|	}
 4329|    150|	*meth = installS3Signature(group, ss);
  ------------------
  |  |  939|    150|#define installS3Signature	Rf_installS3Signature
  ------------------
 4330|    150|	*sxp = R_LookupMethod(*meth, rho, rho, R_BaseEnv);
 4331|    150|	if (isFunction(*sxp)) {
  ------------------
  |  |  948|    150|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (4331:6): [True: 50, False: 100]
  ------------------
 4332|     50|	    *gr = mkString(group);
  ------------------
  |  | 1003|     50|#define mkString		Rf_mkString
  ------------------
 4333|     50|	    if (whichclass > 0) updateObjFromS4Slot(objSlot, ss);
  ------------------
  |  Branch (4333:10): [True: 50, False: 0]
  ------------------
 4334|     50|	    break;
 4335|     50|	}
 4336|    150|    }
 4337|     76|    vmaxset(vmax);
 4338|     76|    *which = whichclass;
 4339|     76|}
eval.c:updateObjFromS4Slot:
 4293|     50|static R_INLINE void updateObjFromS4Slot(SEXP objSlot, const char *className) {
 4294|     50|    SEXP obj = CAR(objSlot);
 4295|       |
 4296|     50|    if(IS_S4_OBJECT(obj) && isBasicClass(className)) {
  ------------------
  |  |  941|      0|#define isBasicClass            Rf_isBasicClass
  ------------------
  |  Branch (4296:8): [True: 0, False: 50]
  |  Branch (4296:29): [True: 0, False: 0]
  ------------------
 4297|       |	/* This and the similar test below implement the strategy
 4298|       |	 for S3 methods selected for S4 objects.  See ?Methods */
 4299|      0|	if(NAMED(obj)) ENSURE_NAMEDMAX(obj);
  ------------------
  |  Branch (4299:5): [True: 0, False: 0]
  ------------------
 4300|      0|	obj = R_getS4DataSlot(obj, OBJSXP); /* the .S3Class obj. or NULL*/
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
 4301|      0|	if(obj != R_NilValue) /* use the S3Part as the inherited object */
  ------------------
  |  Branch (4301:5): [True: 0, False: 0]
  ------------------
 4302|      0|	    SETCAR(objSlot, obj);
 4303|      0|    }
 4304|     50|}
eval.c:bytecodeExpr:
 5599|  4.46k|{
 5600|  4.46k|    if (isByteCode(e)) {
  ------------------
  |  |  739|  4.46k|#define isByteCode(x)	(TYPEOF(x)==BCODESXP)
  |  |  ------------------
  |  |  |  |  133|  4.46k|#define BCODESXP    21    /* byte code */
  |  |  ------------------
  |  |  |  Branch (739:23): [True: 3.23k, False: 1.22k]
  |  |  ------------------
  ------------------
 5601|  3.23k|	if (LENGTH(BCODE_CONSTS(e)) > 0)
  ------------------
  |  |  737|  3.23k|#define BCODE_CONSTS(x) CDR(x)
  ------------------
  |  Branch (5601:6): [True: 3.23k, False: 0]
  ------------------
 5602|  3.23k|	    return VECTOR_ELT(BCODE_CONSTS(e), 0);
  ------------------
  |  |  737|  3.23k|#define BCODE_CONSTS(x) CDR(x)
  ------------------
 5603|      0|	else return R_NilValue;
 5604|  3.23k|    }
 5605|  1.22k|    else return e;
 5606|  4.46k|}
eval.c:R_findBCInterpreterLocation:
 7013|   385k|{
 7014|   385k|    SEXP body = cptr ? cptr->bcbody : R_BCbody;
  ------------------
  |  Branch (7014:17): [True: 18, False: 385k]
  ------------------
 7015|   385k|    if (body == NULL)
  ------------------
  |  Branch (7015:9): [True: 0, False: 385k]
  ------------------
 7016|       |	/* This has happened, but it is not clear how. */
 7017|       |	/* (R_Srcref == R_InBCInterpreter && R_BCbody == NULL) */
 7018|      0|	return R_NilValue;
 7019|   385k|    SEXP constants = BCODE_CONSTS(body);
  ------------------
  |  |  737|   385k|#define BCODE_CONSTS(x) CDR(x)
  ------------------
 7020|   385k|    SEXP ltable = findLocTable(constants, iname);
 7021|   385k|    if (ltable == R_NilValue)
  ------------------
  |  Branch (7021:9): [True: 18, False: 385k]
  ------------------
 7022|       |	/* location table not available */
 7023|     18|	return R_NilValue;
 7024|       |
 7025|       |    /* use relpc stored in the context if available */
 7026|   385k|    if (cptr && cptr->relpc > 0)
  ------------------
  |  Branch (7026:9): [True: 0, False: 385k]
  |  Branch (7026:17): [True: 0, False: 0]
  ------------------
 7027|      0|	return getLocTableElt(cptr->relpc, ltable, constants);
 7028|       |
 7029|   385k|    BCODE *codebase = BCCODE(body);
  ------------------
  |  | 5659|   385k|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  ------------------
  |  |  |  |  736|   385k|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  ------------------
  ------------------
 7030|   385k|    ptrdiff_t relpc = (*((BCODE **)(cptr ? cptr->bcpc : R_BCpc))) - codebase;
  ------------------
  |  Branch (7030:37): [True: 0, False: 385k]
  ------------------
 7031|       |
 7032|   385k|    return getLocTableElt(relpc, ltable, constants);
 7033|   385k|}
eval.c:findLocTable:
 6975|   385k|{
 6976|   385k|    int i;
 6977|       |    /* location tables are at the end of the constant pool */
 6978|   390k|    for(i = LENGTH(constants) - 1; i >= 0 ; i--) {
  ------------------
  |  Branch (6978:36): [True: 390k, False: 18]
  ------------------
 6979|   390k|	SEXP s = VECTOR_ELT(constants, i);
 6980|       |	/* could use exact check instead of inherits */
 6981|   390k|	if (TYPEOF(s) == INTSXP && inherits(s, tclass))
  ------------------
  |  |  123|   780k|#define INTSXP	    13	  /* integer vectors */
  ------------------
              	if (TYPEOF(s) == INTSXP && inherits(s, tclass))
  ------------------
  |  |  933|   386k|#define inherits		Rf_inherits
  ------------------
  |  Branch (6981:6): [True: 386k, False: 4.07k]
  |  Branch (6981:29): [True: 385k, False: 84]
  ------------------
 6982|   385k|	    return s;
 6983|   390k|    }
 6984|     18|    return R_NilValue;
 6985|   385k|}
eval.c:getLocTableElt:
 6989|   385k|{
 6990|   385k|    if (table == R_NilValue || relpc >= LENGTH(table) || relpc < 0)
  ------------------
  |  Branch (6990:9): [True: 0, False: 385k]
  |  Branch (6990:32): [True: 0, False: 385k]
  |  Branch (6990:58): [True: 0, False: 385k]
  ------------------
 6991|      0|	return R_NilValue;
 6992|       |
 6993|   385k|    int cidx = INTEGER(table)[relpc];
 6994|   385k|    if (cidx < 0 || cidx >= LENGTH(constants))
  ------------------
  |  Branch (6994:9): [True: 0, False: 385k]
  |  Branch (6994:21): [True: 0, False: 385k]
  ------------------
 6995|      0|	return R_NilValue;
 6996|   385k|    return VECTOR_ELT(constants, cidx);
 6997|   385k|}
eval.c:R_findBCInterpreterExpression:
 7041|   385k|{
 7042|       |    return R_findBCInterpreterLocation(NULL, "expressionsIndex");
 7043|   385k|}
eval.c:maybeAssignmentCall:
 7073|   385k|{
 7074|   385k|    if (TYPEOF(expr) != LANGSXP)
  ------------------
  |  |  117|   385k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (7074:9): [True: 0, False: 385k]
  ------------------
 7075|      0|	return FALSE;
 7076|       |
 7077|   385k|    if (TYPEOF(CAR(expr)) != SYMSXP)
  ------------------
  |  |  112|   385k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (7077:9): [True: 0, False: 385k]
  ------------------
 7078|      0|	return FALSE;
 7079|   385k|    const char *name = CHAR(PRINTNAME(CAR(expr)));
  ------------------
  |  |  203|   385k|#define CHAR(x) R_CHAR(x)
  ------------------
 7080|   385k|    size_t slen = strlen(name);
 7081|   385k|    return slen > 2 && name[slen-2] == '<' && name[slen-1] == '-';
  ------------------
  |  Branch (7081:12): [True: 1.70k, False: 384k]
  |  Branch (7081:24): [True: 0, False: 1.70k]
  |  Branch (7081:47): [True: 0, False: 0]
  ------------------
 7082|   385k|}
eval.c:maybeClosureWrapper:
 7056|   385k|{
 7057|   385k|    if (TYPEOF(expr) != LANGSXP)
  ------------------
  |  |  117|   385k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (7057:9): [True: 0, False: 385k]
  ------------------
 7058|      0|	return FALSE;
 7059|       |
 7060|   385k|    SEXP sym = CAR(expr);
 7061|       |
 7062|   385k|    if (!(sym == R_DotInternalSym || sym == R_DotExternalSym ||
  ------------------
  |  Branch (7062:11): [True: 0, False: 385k]
  |  Branch (7062:38): [True: 0, False: 385k]
  ------------------
 7063|   385k|	sym == R_DotExternal2Sym || sym == R_DotExternalgraphicsSym ||
  ------------------
  |  Branch (7063:2): [True: 0, False: 385k]
  |  Branch (7063:30): [True: 0, False: 385k]
  ------------------
 7064|   385k|	sym == R_DotCallSym || sym == R_DotFortranSym ||
  ------------------
  |  Branch (7064:2): [True: 0, False: 385k]
  |  Branch (7064:25): [True: 0, False: 385k]
  ------------------
 7065|   385k|	sym == R_DotCSym || sym == R_DotCallgraphicsSym))
  ------------------
  |  Branch (7065:2): [True: 0, False: 385k]
  |  Branch (7065:22): [True: 0, False: 385k]
  ------------------
 7066|       |
 7067|   385k|	return FALSE;
 7068|       |
 7069|      0|    return CDR(expr) != R_NilValue && CADR(expr) != R_NilValue;
  ------------------
  |  Branch (7069:12): [True: 0, False: 0]
  |  Branch (7069:39): [True: 0, False: 0]
  ------------------
 7070|   385k|}
eval.c:maybePrimitiveCall:
 7087|   385k|{
 7088|   385k|    if (TYPEOF(expr) != LANGSXP)
  ------------------
  |  |  117|   385k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (7088:9): [True: 0, False: 385k]
  ------------------
 7089|      0|	return FALSE;
 7090|       |
 7091|   385k|    if (TYPEOF(CAR(expr)) == SYMSXP) {
  ------------------
  |  |  112|   385k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (7091:9): [True: 385k, False: 0]
  ------------------
 7092|   385k|	SEXP value = SYMVALUE(CAR(expr));
 7093|   385k|	if (TYPEOF(value) == PROMSXP)
  ------------------
  |  |  116|   385k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (7093:6): [True: 0, False: 385k]
  ------------------
 7094|      0|	    value = PRVALUE(value);
 7095|   385k|	return TYPEOF(value) == BUILTINSXP || TYPEOF(value) == SPECIALSXP;
  ------------------
  |  |  119|   771k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
              	return TYPEOF(value) == BUILTINSXP || TYPEOF(value) == SPECIALSXP;
  ------------------
  |  |  118|   386k|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (7095:9): [True: 384k, False: 1.00k]
  |  Branch (7095:40): [True: 0, False: 1.00k]
  ------------------
 7096|   385k|    }
 7097|      0|    return FALSE;
 7098|   385k|}
eval.c:bcEval:
 7532|  1.94M|{
 7533|       |  /* check version and allow bytecode to be disabled for testing */
 7534|  1.94M|  if (R_disable_bytecode || ! R_BCVersionOK(body))
  ------------------
  |  Branch (7534:7): [True: 0, False: 1.94M]
  |  Branch (7534:29): [True: 0, False: 1.94M]
  ------------------
 7535|      0|      return eval(bytecodeExpr(body), rho);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 7536|       |
 7537|  1.94M|  struct bcEval_globals globals;
 7538|  1.94M|  save_bcEval_globals(&globals);
 7539|       |
 7540|  1.94M|  R_Srcref = R_InBCInterpreter;
 7541|  1.94M|  R_BCIntActive = 1;
 7542|       |
 7543|  1.94M|  R_BCFrame = NULL;
 7544|       |
 7545|  1.94M|  struct bcEval_locals locals = bcode_setup_locals(body, rho);
 7546|  1.94M|  SEXP value = bcEval_loop(&locals);
 7547|  1.94M|  restore_bcEval_globals(&globals);
 7548|  1.94M|  return value;  
 7549|  1.94M|}
eval.c:save_bcEval_globals:
 7224|  8.98M|{
 7225|  8.98M|    g->oldntop = R_BCNodeStackTop;
 7226|  8.98M|    g->oldbcintactive = R_BCIntActive;
 7227|  8.98M|    g->oldbcbody = R_BCbody;
 7228|  8.98M|    g->oldbcpc = R_BCpc;
 7229|  8.98M|    g->oldbcframe = R_BCFrame;
 7230|  8.98M|    g->oldsrcref = R_Srcref;
 7231|       |#ifdef BC_PROFILING
 7232|       |    g->old_current_opcode = current_opcode;
 7233|       |#endif
 7234|  8.98M|    g->old_bcprot_top = R_BCProtTop;
 7235|  8.98M|    g->old_bcprot_committed = R_BCProtCommitted;
 7236|  8.98M|    g->oldevdepth = R_EvalDepth;
 7237|  8.98M|    INCREMENT_BCSTACK_LINKS();
  ------------------
  |  | 1057|  8.98M|#define INCREMENT_BCSTACK_LINKS() do {			\
  |  | 1058|  8.98M|	if (R_BCNodeStackTop > R_BCProtTop)		\
  |  |  ------------------
  |  |  |  Branch (1058:6): [True: 8.98M, False: 5.21k]
  |  |  ------------------
  |  | 1059|  8.98M|	    INCLNK_stack(R_BCNodeStackTop);		\
  |  | 1060|  8.98M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (1060:14): [Folded, False: 8.98M]
  |  |  ------------------
  ------------------
 7238|  8.98M|}
eval.c:bcode_setup_locals:
 7407|  8.98M|{
 7408|  8.98M|    struct bcEval_locals loc;
 7409|  8.98M|    loc.body = body;
 7410|  8.98M|    loc.rho = rho;
 7411|  8.98M|    loc.pc = BCCODE(body) + 1; /* pop off version */
  ------------------
  |  | 5659|  8.98M|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  ------------------
  |  |  |  |  736|  8.98M|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  ------------------
  ------------------
 7412|  8.98M|    struct vcache_info vcinfo = setup_vcache(body);
 7413|  8.98M|    loc.vcache = vcinfo.vcache;
 7414|  8.98M|    loc.smallcache = vcinfo.smallcache;
 7415|  8.98M|    R_BCbody = body; //**** move this somewhere else?
 7416|  8.98M|    return loc;
 7417|  8.98M|}
eval.c:setup_vcache:
 7369|  8.98M|{
 7370|  8.98M|    R_binding_cache_t vcache = NULL;
 7371|  8.98M|    Rboolean smallcache = TRUE;
 7372|       |
 7373|  8.98M|#ifdef USE_BINDING_CACHE
 7374|  8.98M|    R_xlen_t n = BCCONSTS_LEN(body);
  ------------------
  |  | 5549|  8.98M|#define BCCONSTS_LEN(e) XLENGTH(BCODE_CONSTS(e))
  |  |  ------------------
  |  |  |  |  737|  8.98M|#define BCODE_CONSTS(x) CDR(x)
  |  |  ------------------
  ------------------
 7375|  8.98M|# ifdef CACHE_MAX
 7376|  8.98M|    if (n > CACHE_MAX) {
  ------------------
  |  | 5757|  8.98M|# define CACHE_MAX 256
  ------------------
  |  Branch (7376:9): [True: 64, False: 8.98M]
  ------------------
 7377|     64|	n = CACHE_MAX;
  ------------------
  |  | 5757|     64|# define CACHE_MAX 256
  ------------------
 7378|     64|	smallcache = FALSE;
 7379|     64|    }
 7380|  8.98M|# endif
 7381|  8.98M|# ifdef CACHE_ON_STACK
 7382|       |    /* initialize binding cache on the stack */
 7383|  8.98M|    if (R_BCNodeStackTop + n + 1 > R_BCNodeStackEnd)
  ------------------
  |  Branch (7383:9): [True: 0, False: 8.98M]
  ------------------
 7384|      0|	nodeStackOverflow();
 7385|  8.98M|    R_BCNodeStackTop->u.ival = (int) n;
 7386|  8.98M|    R_BCNodeStackTop->tag = CACHESZ_TAG;
  ------------------
  |  | 1402|  8.98M|# define CACHESZ_TAG 253
  ------------------
 7387|  8.98M|    R_BCNodeStackTop++;
 7388|  8.98M|    vcache = R_BCNodeStackTop;
 7389|   166M|    while (n > 0) {
  ------------------
  |  Branch (7389:12): [True: 157M, False: 8.98M]
  ------------------
 7390|   157M|	SETSTACK_NLNK(0, R_NilValue);
  ------------------
  |  | 4849|   157M|#define SETSTACK_NLNK(i, v) SETSTACK_NLNK_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4843|   157M|#define SETSTACK_NLNK_PTR(s, v) do {			\
  |  |  |  | 4844|   157M|	R_bcstack_t *__s__ = (s);			\
  |  |  |  | 4845|   157M|	SEXP __v__ = (v);				\
  |  |  |  | 4846|   157M|	__s__->tag = NLNKSXP;				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4803|   157M|#define NLNKSXP 9996
  |  |  |  |  ------------------
  |  |  |  | 4847|   157M|	__s__->u.sxpval = __v__;			\
  |  |  |  | 4848|   157M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4848:14): [Folded, False: 157M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7391|   157M|	R_BCNodeStackTop++;
 7392|   157M|	n--;
 7393|   157M|    }
 7394|       |# else
 7395|       |    /* allocate binding cache and protect on stack */
 7396|       |    vcache = allocVector(VECSXP, n);
 7397|       |    BCNPUSH(vcache);
 7398|       |# endif
 7399|  8.98M|#endif
 7400|  8.98M|    R_BCProtTop = R_BCNodeStackTop;
 7401|       |
 7402|  8.98M|    return (struct vcache_info) { vcache, smallcache };
 7403|  8.98M|}
eval.c:bcEval_loop:
 7552|  1.94M|{
 7553|  1.94M|  INITIALIZE_MACHINE();
  ------------------
  |  | 5647|  1.94M|    do {							\
  |  | 5648|  1.94M|	static Rboolean loop_initialized = FALSE;		\
  |  | 5649|  1.94M|	if (! loop_initialized) {				\
  |  |  ------------------
  |  |  |  Branch (5649:6): [True: 2, False: 1.94M]
  |  |  ------------------
  |  | 5650|      2|	    loop_initialized = TRUE;				\
  |  | 5651|      2|	    goto init;						\
  |  | 5652|      2|	}							\
  |  | 5653|  1.94M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5653:14): [Folded, False: 1.94M]
  |  |  ------------------
  ------------------
 7554|       |
 7555|  1.94M|  struct bcEval_locals locals = *ploc;
 7556|       |
 7557|  1.94M|  SEXP body, rho;
 7558|  1.94M|  R_bcconsts_t constants;
 7559|  1.94M|  BCODE *pc, *codebase;
 7560|  1.94M|  R_binding_cache_t vcache;
 7561|  1.94M|  Rboolean smallcache;
 7562|       |
 7563|  1.94M|  RESTORE_BCEVAL_LOCALS(&locals);
  ------------------
  |  | 7275|  1.94M|#define RESTORE_BCEVAL_LOCALS(loc) do {		\
  |  | 7276|  1.94M|	body = (loc)->body;			\
  |  | 7277|  1.94M|	codebase = BCCODE(body);		\
  |  |  ------------------
  |  |  |  | 5659|  1.94M|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  |  |  ------------------
  |  |  |  |  |  |  736|  1.94M|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 7278|  1.94M|	constants = BCCONSTS(body);		\
  |  |  ------------------
  |  |  |  | 5548|  1.94M|    (R_bcconsts_t) {((SEXP const *) DATAPTR_RO(BCODE_CONSTS(e)))}
  |  |  |  |  ------------------
  |  |  |  |  |  |  737|  1.94M|#define BCODE_CONSTS(x) CDR(x)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 7279|  1.94M|	rho = (loc)->rho;			\
  |  | 7280|  1.94M|	vcache = (loc)->vcache;			\
  |  | 7281|  1.94M|	smallcache = (loc)->smallcache;		\
  |  | 7282|  1.94M|	pc = (loc)->pc;				\
  |  | 7283|  1.94M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (7283:14): [Folded, False: 1.94M]
  |  |  ------------------
  ------------------
 7564|       |
 7565|  1.94M|  BCODE *currentpc = NULL;
 7566|  1.94M|  void *oldbcpc = R_BCpc;
 7567|  1.94M|  R_BCpc = &currentpc;
 7568|       |
 7569|  1.94M|  static int evalcount = 0;
 7570|  1.94M|  BC_CHECK_SIGINT();
  ------------------
  |  | 6281|  1.94M|#define BC_CHECK_SIGINT() do {			\
  |  | 6282|  1.94M|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  ------------------
  |  |  |  |   45|  1.94M|#define BC_COUNT_DELTA 127
  |  |  ------------------
  |  |  |  Branch (6282:6): [True: 79, False: 1.94M]
  |  |  ------------------
  |  | 6283|     79|	    bc_check_sigint();			\
  |  | 6284|     79|	    evalcount = 0;			\
  |  | 6285|     79|	}					\
  |  | 6286|  1.94M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6286:14): [Folded, False: 1.94M]
  |  |  ------------------
  ------------------
 7571|       |
 7572|  1.94M|  BEGIN_MACHINE {
  ------------------
  |  | 5644|  1.94M|#define BEGIN_MACHINE NEXT(); init: { int which = 0; loop: switch(which++)
  |  |  ------------------
  |  |  |  | 5655|  1.94M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5644:67): [True: 258, False: 2]
  |  |  ------------------
  ------------------
 7573|      2|    OP(BCMISMATCH, 0): error(_("byte code version mismatch"));
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
                  OP(BCMISMATCH, 0): error(_("byte code version mismatch"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  OP(BCMISMATCH, 0): error(_("byte code version mismatch"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 7574|  7.82M|    OP(RETURN, 0):
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|  7.82M|    op_##name
  ------------------
 7575|  7.82M|      if (R_BCFrame == NULL) {
  ------------------
  |  Branch (7575:11): [True: 1.94M, False: 5.87M]
  ------------------
 7576|  1.94M|	  R_BCpc = oldbcpc;
 7577|  1.94M|	  SEXP retvalue = GETSTACK(-1);
  ------------------
  |  | 4903|  1.94M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|  1.94M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 1.02k, False: 1.94M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7578|  1.94M|	  return retvalue;
 7579|  1.94M|      }
 7580|  5.87M|      else if (BCFRAME_CNTXT() == NULL)
  ------------------
  |  | 7333|  5.87M|#define BCFRAME_CNTXT() (R_BCFrame->pcntxt)
  ------------------
  |  Branch (7580:16): [True: 3.13M, False: 2.74M]
  ------------------
 7581|  3.13M|	  DO_GETVAR_FORCE_PROMISE_RETURN();
  ------------------
  |  | 7517|  3.13M|#define DO_GETVAR_FORCE_PROMISE_RETURN() do {			\
  |  | 7518|  3.13M|	RESTORE_BCEVAL_LOCALS(BCFRAME_LOCALS());		\
  |  |  ------------------
  |  |  |  | 7275|  3.13M|#define RESTORE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  | 7276|  3.13M|	body = (loc)->body;			\
  |  |  |  | 7277|  3.13M|	codebase = BCCODE(body);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5659|  3.13M|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  736|  3.13M|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7278|  3.13M|	constants = BCCONSTS(body);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5548|  3.13M|    (R_bcconsts_t) {((SEXP const *) DATAPTR_RO(BCODE_CONSTS(e)))}
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  737|  3.13M|#define BCODE_CONSTS(x) CDR(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7279|  3.13M|	rho = (loc)->rho;			\
  |  |  |  | 7280|  3.13M|	vcache = (loc)->vcache;			\
  |  |  |  | 7281|  3.13M|	smallcache = (loc)->smallcache;		\
  |  |  |  | 7282|  3.13M|	pc = (loc)->pc;				\
  |  |  |  | 7283|  3.13M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (7283:14): [Folded, False: 3.13M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 7519|  3.13M|	finish_force_promise();					\
  |  | 7520|  3.13M|	NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|  3.13M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 7521|  3.13M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (7521:14): [Folded, False: 3.13M]
  |  |  ------------------
  ------------------
 7582|  2.74M|      else {
 7583|  2.74M|	  BCFRAME_CNTXT()->returnValue = R_BCNodeStackTop[-1];
  ------------------
  |  | 7333|  2.74M|#define BCFRAME_CNTXT() (R_BCFrame->pcntxt)
  ------------------
 7584|  2.74M|	  DO_INLINE_CLOSURE_CALL_RETURN();
  ------------------
  |  | 7480|  2.74M|#define DO_INLINE_CLOSURE_CALL_RETURN() do {			\
  |  | 7481|  2.74M|	RESTORE_BCEVAL_LOCALS(BCFRAME_LOCALS());		\
  |  |  ------------------
  |  |  |  | 7275|  2.74M|#define RESTORE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  | 7276|  2.74M|	body = (loc)->body;			\
  |  |  |  | 7277|  2.74M|	codebase = BCCODE(body);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5659|  2.74M|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  736|  2.74M|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7278|  2.74M|	constants = BCCONSTS(body);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5548|  2.74M|    (R_bcconsts_t) {((SEXP const *) DATAPTR_RO(BCODE_CONSTS(e)))}
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  737|  2.74M|#define BCODE_CONSTS(x) CDR(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7279|  2.74M|	rho = (loc)->rho;			\
  |  |  |  | 7280|  2.74M|	vcache = (loc)->vcache;			\
  |  |  |  | 7281|  2.74M|	smallcache = (loc)->smallcache;		\
  |  |  |  | 7282|  2.74M|	pc = (loc)->pc;				\
  |  |  |  | 7283|  2.74M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (7283:14): [Folded, False: 2.74M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 7482|  2.74M|	finish_inline_closure_call();				\
  |  | 7483|  2.74M|	NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|  2.74M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 7484|  2.74M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (7484:14): [Folded, False: 2.74M]
  |  |  ------------------
  ------------------
 7585|  2.74M|      }
 7586|  5.87M|    OP(GOTO, 1):
  ------------------
  |  | 5638|  5.87M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  5.87M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  5.87M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  5.87M|    goto loop; \
  |  | 5642|  5.87M|    op_##name
  ------------------
 7587|  1.16M|      {
 7588|  1.16M|	int label = GETOP();
  ------------------
  |  | 5656|  1.16M|#define GETOP() (*pc++).i
  ------------------
 7589|  1.16M|	BC_CHECK_SIGINT();
  ------------------
  |  | 6281|  1.16M|#define BC_CHECK_SIGINT() do {			\
  |  | 6282|  1.16M|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  ------------------
  |  |  |  |   45|  1.16M|#define BC_COUNT_DELTA 127
  |  |  ------------------
  |  |  |  Branch (6282:6): [True: 10, False: 1.16M]
  |  |  ------------------
  |  | 6283|     10|	    bc_check_sigint();			\
  |  | 6284|     10|	    evalcount = 0;			\
  |  | 6285|     10|	}					\
  |  | 6286|  1.16M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6286:14): [Folded, False: 1.16M]
  |  |  ------------------
  ------------------
 7590|  1.16M|	pc = codebase + label;
 7591|  1.16M|	NEXT();
  ------------------
  |  | 5655|  1.16M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7592|  1.16M|      }
 7593|  4.29M|    OP(BRIFNOT, 2):
  ------------------
  |  | 5638|  1.16M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.16M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.16M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.16M|    goto loop; \
  |  | 5642|  4.29M|    op_##name
  ------------------
 7594|  4.29M|      {
 7595|  4.29M|	int callidx = GETOP();
  ------------------
  |  | 5656|  4.29M|#define GETOP() (*pc++).i
  ------------------
 7596|  4.29M|	int label = GETOP();
  ------------------
  |  | 5656|  4.29M|#define GETOP() (*pc++).i
  ------------------
 7597|  4.29M|	Rboolean cond = GETSTACK_LOGICAL_NO_NA_PTR(R_BCNodeStackTop - 1,
 7598|  4.29M|						   callidx, constants, rho);
 7599|  4.29M|	BCNPOP_IGNORE_VALUE();
  ------------------
  |  | 5519|  4.29M|#define BCNPOP_IGNORE_VALUE() R_BCNodeStackTop--
  ------------------
 7600|  4.29M|	if (! cond) {
  ------------------
  |  Branch (7600:6): [True: 2.74M, False: 1.55M]
  ------------------
 7601|  2.74M|	    BC_CHECK_SIGINT(); /**** only on back branch?*/
  ------------------
  |  | 6281|  2.74M|#define BC_CHECK_SIGINT() do {			\
  |  | 6282|  2.74M|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  ------------------
  |  |  |  |   45|  2.74M|#define BC_COUNT_DELTA 127
  |  |  ------------------
  |  |  |  Branch (6282:6): [True: 87, False: 2.74M]
  |  |  ------------------
  |  | 6283|     87|	    bc_check_sigint();			\
  |  | 6284|     87|	    evalcount = 0;			\
  |  | 6285|     87|	}					\
  |  | 6286|  2.74M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6286:14): [Folded, False: 2.74M]
  |  |  ------------------
  ------------------
 7602|  2.74M|	    pc = codebase + label;
 7603|  2.74M|	}
 7604|  4.29M|	NEXT();
  ------------------
  |  | 5655|  4.29M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7605|  4.29M|      }
 7606|  14.3M|    OP(POP, 0): BCNPOP_IGNORE_VALUE(); NEXT();
  ------------------
  |  | 5638|  4.29M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  4.29M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  4.29M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  4.29M|    goto loop; \
  |  | 5642|  14.3M|    op_##name
  ------------------
                  OP(POP, 0): BCNPOP_IGNORE_VALUE(); NEXT();
  ------------------
  |  | 5519|  14.3M|#define BCNPOP_IGNORE_VALUE() R_BCNodeStackTop--
  ------------------
                  OP(POP, 0): BCNPOP_IGNORE_VALUE(); NEXT();
  ------------------
  |  | 5655|  14.3M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7607|  14.3M|    OP(DUP, 0): BCNDUP(); NEXT();
  ------------------
  |  | 5638|  14.3M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  14.3M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  14.3M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  14.3M|    goto loop; \
  |  | 5642|  14.3M|    op_##name
  ------------------
                  OP(DUP, 0): BCNDUP(); NEXT();
  ------------------
  |  | 5497|      0|#define BCNDUP() do {						\
  |  | 5498|      0|	R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1;		\
  |  | 5499|      0|	if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow();	\
  |  |  ------------------
  |  |  |  Branch (5499:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5500|      0|	__ntop__[-1] = __ntop__[-2];				\
  |  | 5501|      0|	R_BCNodeStackTop = __ntop__;				\
  |  | 5502|      0|    } while(0)
  |  |  ------------------
  |  |  |  Branch (5502:13): [Folded, False: 0]
  |  |  ------------------
  ------------------
                  OP(DUP, 0): BCNDUP(); NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7608|      2|    OP(PRINTVALUE, 0): PrintValue(BCNPOP()); NEXT();
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
                  OP(PRINTVALUE, 0): PrintValue(BCNPOP()); NEXT();
  ------------------
  |  | 1013|      0|#define PrintValue		Rf_PrintValue
  ------------------
                  OP(PRINTVALUE, 0): PrintValue(BCNPOP()); NEXT();
  ------------------
  |  | 5518|      0|#define BCNPOP() (R_BCNodeStackTop--, GETSTACK(0))
  |  |  ------------------
  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                  OP(PRINTVALUE, 0): PrintValue(BCNPOP()); NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7609|     12|    OP(STARTLOOPCNTXT, 2):
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|     12|    op_##name
  ------------------
 7610|     12|	{
 7611|     12|	    int is_for_loop = GETOP();
  ------------------
  |  | 5656|     12|#define GETOP() (*pc++).i
  ------------------
 7612|     12|	    R_bcstack_t *oldtop = R_BCNodeStackTop;
 7613|     12|	    RCNTXT *cntxt = BCNALLOC_CNTXT();
  ------------------
  |  | 5590|     12|#define BCNALLOC_CNTXT() (RCNTXT *) BCNALLOC(sizeof(RCNTXT))
  ------------------
 7614|     12|	    int break_offset = GETOP();
  ------------------
  |  | 5656|     12|#define GETOP() (*pc++).i
  ------------------
 7615|     12|	    BCODE *break_pc = codebase + break_offset;
 7616|     12|	    struct bcEval_locals locals;
 7617|     12|	    SAVE_BCEVAL_LOCALS(&locals);
  ------------------
  |  | 7267|     12|#define SAVE_BCEVAL_LOCALS(loc) do {		\
  |  | 7268|     12|	(loc)->body = body;			\
  |  | 7269|     12|	(loc)->rho = rho;			\
  |  | 7270|     12|	(loc)->vcache = vcache;			\
  |  | 7271|     12|	(loc)->smallcache = smallcache;		\
  |  | 7272|     12|	(loc)->pc = pc;				\
  |  | 7273|     12|    } while (0)
  |  |  ------------------
  |  |  |  Branch (7273:14): [Folded, False: 12]
  |  |  ------------------
  ------------------
 7618|     12|	    PUSH_LOOP_LOCALS(break_pc);
  ------------------
  |  | 7297|     12|#define PUSH_LOOP_LOCALS(bpc) do {				\
  |  | 7298|     12|	struct cntxt_loop_locals *loc =				\
  |  | 7299|     12|	    BCNALLOC(sizeof(struct cntxt_loop_locals));		\
  |  | 7300|     12|	SAVE_BCEVAL_LOCALS(&(loc->locals));			\
  |  |  ------------------
  |  |  |  | 7267|     12|#define SAVE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  | 7268|     12|	(loc)->body = body;			\
  |  |  |  | 7269|     12|	(loc)->rho = rho;			\
  |  |  |  | 7270|     12|	(loc)->vcache = vcache;			\
  |  |  |  | 7271|     12|	(loc)->smallcache = smallcache;		\
  |  |  |  | 7272|     12|	(loc)->pc = pc;				\
  |  |  |  | 7273|     12|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (7273:14): [Folded, False: 12]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 7301|     12|	loc->break_pc = (bpc);					\
  |  | 7302|     12|    } while (0)
  |  |  ------------------
  |  |  |  Branch (7302:14): [Folded, False: 12]
  |  |  ------------------
  ------------------
 7619|     12|	    if (is_for_loop) {
  ------------------
  |  Branch (7619:10): [True: 12, False: 0]
  ------------------
 7620|       |		/* duplicate the for loop state data on the top of the stack */
 7621|     12|		R_bcstack_t *loopdata = oldtop - FOR_LOOP_STATE_SIZE;
  ------------------
  |  | 6875|     12|#define FOR_LOOP_STATE_SIZE 5
  ------------------
 7622|     12|		BCNSTACKCHECK(FOR_LOOP_STATE_SIZE);
  ------------------
  |  | 5521|     12|#define BCNSTACKCHECK(n)  do {						\
  |  | 5522|     12|	if (R_BCNodeStackTop + (n) > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5522:6): [True: 0, False: 12]
  |  |  ------------------
  |  | 5523|     12|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5523:14): [Folded, False: 12]
  |  |  ------------------
  ------------------
 7623|     72|		for (int i = 0; i < FOR_LOOP_STATE_SIZE; i++)
  ------------------
  |  | 6875|     72|#define FOR_LOOP_STATE_SIZE 5
  ------------------
  |  Branch (7623:19): [True: 60, False: 12]
  ------------------
 7624|     60|		    R_BCNodeStackTop[i] = loopdata[i];
 7625|     12|		R_BCNodeStackTop += FOR_LOOP_STATE_SIZE;
  ------------------
  |  | 6875|     12|#define FOR_LOOP_STATE_SIZE 5
  ------------------
 7626|     12|		SET_FOR_LOOP_BCPROT_OFFSET(R_BCProtTop - R_BCNodeStackBase);
  ------------------
  |  | 6880|     12|#define SET_FOR_LOOP_BCPROT_OFFSET(v) SETSTACK_INTEGER(-5, (int) (v))
  |  |  ------------------
  |  |  |  | 4909|     12|#define SETSTACK_INTEGER(i, v) SETSTACK_INTEGER_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4871|     12|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  |  |  | 4872|     12|    int __v__ = (v); \
  |  |  |  |  |  | 4873|     12|    (s)->tag = INTSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  123|     12|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4874|     12|    (s)->u.ival = __v__; \
  |  |  |  |  |  | 4875|     12|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4875:10): [Folded, False: 12]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7627|     12|		INCLNK_stack(R_BCNodeStackTop);
 7628|       |
 7629|     12|		begincontext(cntxt, CTXT_LOOP, R_NilValue, rho, R_BaseEnv,
  ------------------
  |  | 1864|     12|# define begincontext		Rf_begincontext
  ------------------
 7630|     12|			     R_NilValue, R_NilValue);
 7631|     12|		switch (SETJMP(cntxt->cjmpbuf)) {
  ------------------
  |  | 1162|     12|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (7631:11): [True: 0, False: 12]
  ------------------
 7632|      0|		case CTXT_BREAK:
  ------------------
  |  Branch (7632:3): [True: 0, False: 12]
  ------------------
 7633|      0|		    locals = recover_loop_locals(FOR_LOOP_STATE_SIZE, TRUE);
  ------------------
  |  | 6875|      0|#define FOR_LOOP_STATE_SIZE 5
  ------------------
 7634|      0|		    break;
 7635|      0|		case CTXT_NEXT:
  ------------------
  |  Branch (7635:3): [True: 0, False: 12]
  ------------------
 7636|      0|		    locals = recover_loop_locals(FOR_LOOP_STATE_SIZE, FALSE);
  ------------------
  |  | 6875|      0|#define FOR_LOOP_STATE_SIZE 5
  ------------------
 7637|      0|		    break;
 7638|     12|		}
 7639|     12|	    }
 7640|      0|	    else {
 7641|      0|		begincontext(cntxt, CTXT_LOOP, R_NilValue, rho, R_BaseEnv,
  ------------------
  |  | 1864|      0|# define begincontext		Rf_begincontext
  ------------------
 7642|      0|			     R_NilValue, R_NilValue);
 7643|      0|		switch (SETJMP(cntxt->cjmpbuf)) {
  ------------------
  |  | 1162|      0|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (7643:11): [True: 0, False: 0]
  ------------------
 7644|      0|		case CTXT_BREAK:
  ------------------
  |  Branch (7644:3): [True: 0, False: 0]
  ------------------
 7645|      0|		    locals = recover_loop_locals(0, TRUE);
 7646|      0|		    break;
 7647|      0|		case CTXT_NEXT:
  ------------------
  |  Branch (7647:3): [True: 0, False: 0]
  ------------------
 7648|      0|		    locals = recover_loop_locals(0, FALSE);
 7649|      0|		    break;
 7650|      0|		}
 7651|      0|	    }
 7652|     12|	    RESTORE_BCEVAL_LOCALS(&locals);
  ------------------
  |  | 7275|     12|#define RESTORE_BCEVAL_LOCALS(loc) do {		\
  |  | 7276|     12|	body = (loc)->body;			\
  |  | 7277|     12|	codebase = BCCODE(body);		\
  |  |  ------------------
  |  |  |  | 5659|     12|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  |  |  ------------------
  |  |  |  |  |  |  736|     12|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 7278|     12|	constants = BCCONSTS(body);		\
  |  |  ------------------
  |  |  |  | 5548|     12|    (R_bcconsts_t) {((SEXP const *) DATAPTR_RO(BCODE_CONSTS(e)))}
  |  |  |  |  ------------------
  |  |  |  |  |  |  737|     12|#define BCODE_CONSTS(x) CDR(x)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 7279|     12|	rho = (loc)->rho;			\
  |  | 7280|     12|	vcache = (loc)->vcache;			\
  |  | 7281|     12|	smallcache = (loc)->smallcache;		\
  |  | 7282|     12|	pc = (loc)->pc;				\
  |  | 7283|     12|    } while (0)
  |  |  ------------------
  |  |  |  Branch (7283:14): [Folded, False: 12]
  |  |  ------------------
  ------------------
 7653|     12|	    NEXT();
  ------------------
  |  | 5655|     12|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7654|       |	    /* context, offsets on stack, to be popped by ENDLOOPCNTXT */
 7655|     12|	}
 7656|     14|    OP(ENDLOOPCNTXT, 1):
  ------------------
  |  | 5638|     14|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|     14|    opinfo[name##_OP].argc = (n); \
  |  | 5640|     14|    opinfo[name##_OP].instname = #name; \
  |  | 5641|     14|    goto loop; \
  |  | 5642|     14|    op_##name
  ------------------
 7657|     12|	{
 7658|     12|	    int is_for_loop = GETOP();
  ------------------
  |  | 5656|     12|#define GETOP() (*pc++).i
  ------------------
 7659|     12|	    if (is_for_loop) {
  ------------------
  |  Branch (7659:10): [True: 12, False: 0]
  ------------------
 7660|     12|		int offset = GET_FOR_LOOP_BCPROT_OFFSET();
  ------------------
  |  | 6881|     12|#define GET_FOR_LOOP_BCPROT_OFFSET() GETSTACK_IVAL_PTR(R_BCNodeStackTop - 5)
  |  |  ------------------
  |  |  |  | 4841|     12|#define GETSTACK_IVAL_PTR(s) ((s)->u.ival)
  |  |  ------------------
  ------------------
 7661|     12|		DECLNK_stack(R_BCNodeStackBase + offset);
 7662|       |
 7663|       |		/* remove the duplicated for loop state data */
 7664|     12|		R_BCNodeStackTop -= FOR_LOOP_STATE_SIZE;
  ------------------
  |  | 6875|     12|#define FOR_LOOP_STATE_SIZE 5
  ------------------
 7665|     12|	    }
 7666|     12|	    POP_LOOP_LOCALS();
  ------------------
  |  | 7304|     12|#define POP_LOOP_LOCALS() do {					\
  |  | 7305|     12|	BCNPOP_ALLOC(sizeof(struct cntxt_loop_locals));		\
  |  | 7306|     12|    } while (0)
  |  |  ------------------
  |  |  |  Branch (7306:14): [Folded, False: 12]
  |  |  ------------------
  ------------------
 7667|     12|	    BCNPOP_AND_END_CNTXT();
 7668|     12|	    NEXT();
  ------------------
  |  | 5655|     12|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7669|     12|	}
 7670|     14|    OP(DOLOOPNEXT, 0): findcontext(CTXT_NEXT, rho, R_NilValue);
  ------------------
  |  | 5638|     14|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|     14|    opinfo[name##_OP].argc = (n); \
  |  | 5640|     14|    opinfo[name##_OP].instname = #name; \
  |  | 5641|     14|    goto loop; \
  |  | 5642|     14|    op_##name
  ------------------
                  OP(DOLOOPNEXT, 0): findcontext(CTXT_NEXT, rho, R_NilValue);
  ------------------
  |  | 1901|      0|# define findcontext		Rf_findcontext
  ------------------
 7671|      2|    OP(DOLOOPBREAK, 0): findcontext(CTXT_BREAK, rho, R_NilValue);
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
                  OP(DOLOOPBREAK, 0): findcontext(CTXT_BREAK, rho, R_NilValue);
  ------------------
  |  | 1901|      0|# define findcontext		Rf_findcontext
  ------------------
 7672|   386k|    OP(STARTFOR, 3):
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|   386k|    op_##name
  ------------------
 7673|   386k|      {
 7674|   386k|	Rboolean iscompact = FALSE;
 7675|   386k|	SEXP seq = getForLoopSeq(-1, &iscompact);
 7676|   386k|	int callidx = GETOP();
  ------------------
  |  | 5656|   386k|#define GETOP() (*pc++).i
  ------------------
 7677|   386k|	SEXP symbol = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|   386k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 7678|   386k|	int label = GETOP();
  ------------------
  |  | 5656|   386k|#define GETOP() (*pc++).i
  ------------------
 7679|       |
 7680|   386k|	INSERT_FOR_LOOP_BCPROT_OFFSET();
  ------------------
  |  | 6882|   386k|#define INSERT_FOR_LOOP_BCPROT_OFFSET() do {				\
  |  | 6883|   386k|	/* insert space for the BCProt offset below the sequence */	\
  |  | 6884|   386k|	if (R_BCNodeStackTop >= R_BCNodeStackEnd)			\
  |  |  ------------------
  |  |  |  Branch (6884:6): [True: 0, False: 386k]
  |  |  ------------------
  |  | 6885|   386k|	    nodeStackOverflow();					\
  |  | 6886|   386k|	R_BCNodeStackTop[0] = R_BCNodeStackTop[-1];			\
  |  | 6887|   386k|	SETSTACK_INTEGER(-1, 0);					\
  |  |  ------------------
  |  |  |  | 4909|   386k|#define SETSTACK_INTEGER(i, v) SETSTACK_INTEGER_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4871|   386k|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  |  |  | 4872|   386k|    int __v__ = (v); \
  |  |  |  |  |  | 4873|   386k|    (s)->tag = INTSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  123|   386k|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4874|   386k|    (s)->u.ival = __v__; \
  |  |  |  |  |  | 4875|   386k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4875:10): [Folded, False: 386k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6888|   386k|	R_BCNodeStackTop++;						\
  |  | 6889|   386k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6889:14): [Folded, False: 386k]
  |  |  ------------------
  ------------------
 7681|       |
 7682|       |	/* if we are iterating over a factor, coerce to character first */
 7683|   386k|	if (inherits(seq, "factor")) {
  ------------------
  |  |  933|   386k|#define inherits		Rf_inherits
  ------------------
  |  Branch (7683:6): [True: 0, False: 386k]
  ------------------
 7684|      0|	    seq = asCharacterFactor(seq);
  ------------------
  |  |  883|      0|#define asCharacterFactor	Rf_asCharacterFactor
  ------------------
 7685|      0|	    SETSTACK(-1, seq);
  ------------------
  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7686|      0|	}
 7687|       |
 7688|   386k|	defineVar(symbol, R_NilValue, rho);
  ------------------
  |  |  905|   386k|#define defineVar		Rf_defineVar
  ------------------
 7689|   386k|	BCNPUSH(GET_BINDING_CELL(symbol, rho));
  ------------------
  |  | 5449|   386k|#define BCNPUSH(v) do { \
  |  | 5450|   386k|  SEXP __value__ = (v); \
  |  | 5451|   386k|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5452|   386k|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5452:7): [True: 0, False: 386k]
  |  |  ------------------
  |  | 5453|   386k|  SETSTACK(0, __value__); \
  |  |  ------------------
  |  |  |  | 4905|   386k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|   386k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|   386k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|   386k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 386k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|   386k|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|   386k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|   386k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|   386k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 386k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5454|   386k|  R_BCNodeStackTop = __ntop__; \
  |  | 5455|   386k|} while (0)
  |  |  ------------------
  |  |  |  Branch (5455:10): [Folded, False: 386k]
  |  |  ------------------
  ------------------
 7690|       |
 7691|   386k|	SEXP value = allocVector(RAWSXP, sizeof(R_loopinfo_t));
  ------------------
  |  |  875|   386k|#define allocVector		Rf_allocVector
  ------------------
              	SEXP value = allocVector(RAWSXP, sizeof(R_loopinfo_t));
  ------------------
  |  |  136|   386k|#define RAWSXP      24    /* raw bytes */
  ------------------
 7692|   386k|	R_loopinfo_t *loopinfo = (R_loopinfo_t *) RAW0(value);
 7693|   386k|	loopinfo->idx = -1;
 7694|   386k|#ifdef COMPACT_INTSEQ
 7695|   386k|	if (iscompact) {
  ------------------
  |  Branch (7695:6): [True: 386k, False: 188]
  ------------------
 7696|   386k|	    int n1 = INTEGER(seq)[0];
 7697|   386k|	    int n2 = INTEGER(seq)[1];
 7698|   386k|	    loopinfo->len = n1 <= n2 ? n2 - n1 + 1 : n1 - n2 + 1;
  ------------------
  |  Branch (7698:22): [True: 386k, False: 0]
  ------------------
 7699|   386k|	}
 7700|    188|	else
 7701|    188|#endif
 7702|    188|	if (isVector(seq))
  ------------------
  |  |  974|    188|#define isVector		Rf_isVector
  ------------------
  |  Branch (7702:6): [True: 176, False: 12]
  ------------------
 7703|    176|	  loopinfo->len = XLENGTH(seq);
 7704|     12|	else if (isList(seq) || isNull(seq))
  ------------------
  |  |  951|     12|#define isList			Rf_isList
  ------------------
              	else if (isList(seq) || isNull(seq))
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (7704:11): [True: 12, False: 0]
  |  Branch (7704:26): [True: 0, False: 0]
  ------------------
 7705|     12|	  loopinfo->len = length(seq);
  ------------------
  |  |  987|     12|#define length(x)		Rf_length(x)
  ------------------
 7706|      0|	else errorcall(GETCONST(constants, callidx),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	else errorcall(GETCONST(constants, callidx),
  ------------------
  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 7707|      0|		       _("invalid for() loop sequence"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 7708|   386k|#ifdef COMPACT_INTSEQ
 7709|   386k|	loopinfo->type = iscompact ? INTSEQSXP : TYPEOF(seq);
  ------------------
  |  | 4800|   386k|# define INTSEQSXP 9999
  ------------------
  |  Branch (7709:19): [True: 386k, False: 188]
  ------------------
 7710|       |#else
 7711|       |	loopinfo->type = TYPEOF(seq);
 7712|       |#endif
 7713|   386k|	loopinfo->symbol = symbol;
 7714|   386k|	BCNPUSH(value);
  ------------------
  |  | 5449|   386k|#define BCNPUSH(v) do { \
  |  | 5450|   386k|  SEXP __value__ = (v); \
  |  | 5451|   386k|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5452|   386k|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5452:7): [True: 0, False: 386k]
  |  |  ------------------
  |  | 5453|   386k|  SETSTACK(0, __value__); \
  |  |  ------------------
  |  |  |  | 4905|   386k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|   386k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|   386k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|   386k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 386k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|   386k|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|   386k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|   386k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|   386k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 386k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5454|   386k|  R_BCNodeStackTop = __ntop__; \
  |  | 5455|   386k|} while (0)
  |  |  ------------------
  |  |  |  Branch (5455:10): [Folded, False: 386k]
  |  |  ------------------
  ------------------
 7715|       |
 7716|       |	/* bump up links count of seq to avoid modification by loop code */
 7717|   386k|	INCREMENT_LINKS(seq);
  ------------------
  |  |  540|   386k|#define INCREMENT_LINKS(x) do {			\
  |  |  541|   386k|	SEXP il__x__ = (x);			\
  |  |  542|   386k|	INCREMENT_NAMED(il__x__);		\
  |  |  ------------------
  |  |  |  |  222|   386k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 386k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  543|   386k|	INCREMENT_REFCNT(il__x__);		\
  |  |  544|   386k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (544:14): [Folded, False: 386k]
  |  |  ------------------
  ------------------
 7718|       |
 7719|       |	/* place initial loop variable value object on stack */
 7720|   386k|	switch(TYPEOF(seq)) {
 7721|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (7721:2): [True: 0, False: 386k]
  ------------------
 7722|   386k|	case INTSXP:
  ------------------
  |  |  123|   386k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (7722:2): [True: 386k, False: 158]
  ------------------
 7723|   386k|	case REALSXP:
  ------------------
  |  |  124|   386k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (7723:2): [True: 0, False: 386k]
  ------------------
 7724|   386k|	case CPLXSXP:
  ------------------
  |  |  125|   386k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (7724:2): [True: 0, False: 386k]
  ------------------
 7725|   386k|	case STRSXP:
  ------------------
  |  |  126|   386k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (7725:2): [True: 46, False: 386k]
  ------------------
 7726|   386k|	case RAWSXP:
  ------------------
  |  |  136|   386k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (7726:2): [True: 0, False: 386k]
  ------------------
 7727|   386k|	    value = allocVector(TYPEOF(seq), 1);
  ------------------
  |  |  875|   386k|#define allocVector		Rf_allocVector
  ------------------
 7728|   386k|	    INCREMENT_NAMED(value);
  ------------------
  |  |  222|   386k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 386k]
  |  |  ------------------
  ------------------
 7729|   386k|	    BCNPUSH_NLNK(value);
  ------------------
  |  | 5457|   386k|#define BCNPUSH_NLNK(v) do {			\
  |  | 5458|   386k|	BCNPUSH(R_NilValue);			\
  |  |  ------------------
  |  |  |  | 5449|   386k|#define BCNPUSH(v) do { \
  |  |  |  | 5450|   386k|  SEXP __value__ = (v); \
  |  |  |  | 5451|   386k|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|   386k|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 386k]
  |  |  |  |  ------------------
  |  |  |  | 5453|   386k|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|   386k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|   386k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|   386k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|   386k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 386k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|   386k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|   386k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|   386k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|   386k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 386k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|   386k|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|   386k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 386k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5459|   386k|	SETSTACK_NLNK(-1, v);			\
  |  |  ------------------
  |  |  |  | 4849|   386k|#define SETSTACK_NLNK(i, v) SETSTACK_NLNK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4843|   386k|#define SETSTACK_NLNK_PTR(s, v) do {			\
  |  |  |  |  |  | 4844|   386k|	R_bcstack_t *__s__ = (s);			\
  |  |  |  |  |  | 4845|   386k|	SEXP __v__ = (v);				\
  |  |  |  |  |  | 4846|   386k|	__s__->tag = NLNKSXP;				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4803|   386k|#define NLNKSXP 9996
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4847|   386k|	__s__->u.sxpval = __v__;			\
  |  |  |  |  |  | 4848|   386k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4848:14): [Folded, False: 386k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5460|   386k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5460:14): [Folded, False: 386k]
  |  |  ------------------
  ------------------
 7730|   386k|	    break;
 7731|    112|	default: BCNPUSH(R_NilValue);
  ------------------
  |  | 5449|    112|#define BCNPUSH(v) do { \
  |  | 5450|    112|  SEXP __value__ = (v); \
  |  | 5451|    112|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5452|    112|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5452:7): [True: 0, False: 112]
  |  |  ------------------
  |  | 5453|    112|  SETSTACK(0, __value__); \
  |  |  ------------------
  |  |  |  | 4905|    112|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|    112|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|    112|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|    112|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 112]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|    112|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|    112|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|    112|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|    112|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 112]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5454|    112|  R_BCNodeStackTop = __ntop__; \
  |  | 5455|    112|} while (0)
  |  |  ------------------
  |  |  |  Branch (5455:10): [Folded, False: 112]
  |  |  ------------------
  ------------------
  |  Branch (7731:2): [True: 112, False: 386k]
  ------------------
 7732|   386k|	}
 7733|       |	/* the seq, binding cell, and value on the stack are now boxed */
 7734|       |
 7735|   386k|	SET_FOR_LOOP_BCPROT_OFFSET(R_BCProtTop - R_BCNodeStackBase);
  ------------------
  |  | 6880|   386k|#define SET_FOR_LOOP_BCPROT_OFFSET(v) SETSTACK_INTEGER(-5, (int) (v))
  |  |  ------------------
  |  |  |  | 4909|   386k|#define SETSTACK_INTEGER(i, v) SETSTACK_INTEGER_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4871|   386k|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  |  |  | 4872|   386k|    int __v__ = (v); \
  |  |  |  |  |  | 4873|   386k|    (s)->tag = INTSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  123|   386k|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4874|   386k|    (s)->u.ival = __v__; \
  |  |  |  |  |  | 4875|   386k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4875:10): [Folded, False: 386k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7736|   386k|	INCLNK_stack(R_BCNodeStackTop);
 7737|       |
 7738|   386k|	BC_CHECK_SIGINT();
  ------------------
  |  | 6281|   386k|#define BC_CHECK_SIGINT() do {			\
  |  | 6282|   386k|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  ------------------
  |  |  |  |   45|   386k|#define BC_COUNT_DELTA 127
  |  |  ------------------
  |  |  |  Branch (6282:6): [True: 4, False: 386k]
  |  |  ------------------
  |  | 6283|      4|	    bc_check_sigint();			\
  |  | 6284|      4|	    evalcount = 0;			\
  |  | 6285|      4|	}					\
  |  | 6286|   386k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6286:14): [Folded, False: 386k]
  |  |  ------------------
  ------------------
 7739|   386k|	pc = codebase + label;
 7740|   386k|	NEXT();
  ------------------
  |  | 5655|   386k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7741|   386k|      }
 7742|   775k|    OP(STEPFOR, 1):
  ------------------
  |  | 5638|   386k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   386k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   386k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   386k|    goto loop; \
  |  | 5642|   775k|    op_##name
  ------------------
 7743|   775k|      {
 7744|   775k|	int label = GETOP();
  ------------------
  |  | 5656|   775k|#define GETOP() (*pc++).i
  ------------------
 7745|   775k|	R_loopinfo_t *loopinfo = GET_FOR_LOOP_INFO();
  ------------------
  |  | 6876|   775k|#define GET_FOR_LOOP_INFO() ((R_loopinfo_t *) RAW0(GETSTACK_SXPVAL(-2)))
  |  |  ------------------
  |  |  |  | 4901|   775k|#define GETSTACK_SXPVAL(i) GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|   775k|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7746|   775k|	R_xlen_t i = ++(loopinfo->idx);
 7747|   775k|	R_xlen_t n = loopinfo->len;
 7748|   775k|	if (i < n) {
  ------------------
  |  Branch (7748:6): [True: 388k, False: 386k]
  ------------------
 7749|   388k|	  BC_CHECK_SIGINT_LOOP(i);
  ------------------
  |  | 6290|   388k|#define BC_CHECK_SIGINT_LOOP(i) do {		\
  |  | 6291|   388k|	if ((i & BC_LOOP_COUNT_MASK) == 0) {	\
  |  |  ------------------
  |  |  |  | 6289|   388k|#define BC_LOOP_COUNT_MASK BC_COUNT_DELTA
  |  |  |  |  ------------------
  |  |  |  |  |  |   45|   388k|#define BC_COUNT_DELTA 127
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (6291:6): [True: 386k, False: 2.20k]
  |  |  ------------------
  |  | 6292|   386k|	    bc_check_sigint();			\
  |  | 6293|   386k|	    evalcount = 0;			\
  |  | 6294|   386k|	}					\
  |  | 6295|   388k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6295:14): [Folded, False: 388k]
  |  |  ------------------
  ------------------
 7750|   388k|	  pc = codebase + label;
 7751|   388k|	  int type = loopinfo->type;
 7752|   388k|	  SEXP seq = GET_FOR_LOOP_SEQ();
  ------------------
  |  | 6878|   388k|#define GET_FOR_LOOP_SEQ() GETSTACK_SXPVAL(-4)
  |  |  ------------------
  |  |  |  | 4901|   388k|#define GETSTACK_SXPVAL(i) GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|   388k|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7753|   388k|	  SEXP cell = GET_FOR_LOOP_BINDING();
  ------------------
  |  | 6877|   388k|#define GET_FOR_LOOP_BINDING() GETSTACK_SXPVAL(-3)
  |  |  ------------------
  |  |  |  | 4901|   388k|#define GETSTACK_SXPVAL(i) GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|   388k|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7754|   388k|	  SEXP value = NULL;
 7755|   388k|	  switch (type) {
 7756|      0|	  case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (7756:4): [True: 0, False: 388k]
  ------------------
 7757|      0|	    if (BNDCELL_TAG_WR(cell) == REALSXP) {
  ------------------
  |  | 5682|      0|#define BNDCELL_TAG_WR(v) (BINDING_IS_LOCKED(v) ? 0 : BNDCELL_TAG(v))
  |  |  ------------------
  |  |  |  Branch (5682:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	    if (BNDCELL_TAG_WR(cell) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (7757:10): [True: 0, False: 0]
  ------------------
 7758|      0|		SET_BNDCELL_DVAL(cell,  REAL_ELT(seq, i));
 7759|      0|		NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7760|      0|	    }
 7761|      0|	    if (BNDCELL_WRITABLE(cell)) {
  ------------------
  |  | 5685|      0|    (v != R_NilValue &&	 ! BINDING_IS_LOCKED(v) && ! IS_ACTIVE_BINDING(v))
  |  |  ------------------
  |  |  |  Branch (5685:6): [True: 0, False: 0]
  |  |  |  Branch (5685:26): [True: 0, False: 0]
  |  |  |  Branch (5685:52): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 7762|      0|		NEW_BNDCELL_DVAL(cell, REAL_ELT(seq, i));
 7763|      0|		NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7764|      0|	    }
 7765|      0|	    GET_VEC_LOOP_VALUE(value);
  ------------------
  |  | 6891|      0|#define GET_VEC_LOOP_VALUE(var) do {			\
  |  | 6892|      0|	(var) = GETSTACK_SXPVAL(-1);			\
  |  |  ------------------
  |  |  |  | 4901|      0|#define GETSTACK_SXPVAL(i) GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|      0|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6893|      0|	if (BNDCELL_TAG(cell) ||			\
  |  |  ------------------
  |  |  |  Branch (6893:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6894|      0|	    (var) != CAR(cell) || MAYBE_SHARED(var) ||	\
  |  |  ------------------
  |  |  |  Branch (6894:6): [True: 0, False: 0]
  |  |  |  Branch (6894:28): [True: 0, False: 0]
  |  |  ------------------
  |  | 6895|      0|	    ATTRIB(var) != R_NilValue) {		\
  |  |  ------------------
  |  |  |  Branch (6895:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6896|      0|	    (var) = allocVector(TYPEOF(seq), 1);	\
  |  |  ------------------
  |  |  |  |  875|      0|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  | 6897|      0|	    SETSTACK_NLNK(-1, var);			\
  |  |  ------------------
  |  |  |  | 4849|      0|#define SETSTACK_NLNK(i, v) SETSTACK_NLNK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4843|      0|#define SETSTACK_NLNK_PTR(s, v) do {			\
  |  |  |  |  |  | 4844|      0|	R_bcstack_t *__s__ = (s);			\
  |  |  |  |  |  | 4845|      0|	SEXP __v__ = (v);				\
  |  |  |  |  |  | 4846|      0|	__s__->tag = NLNKSXP;				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4803|      0|#define NLNKSXP 9996
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4847|      0|	__s__->u.sxpval = __v__;			\
  |  |  |  |  |  | 4848|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4848:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6898|      0|	    INCREMENT_NAMED(var);			\
  |  |  ------------------
  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6899|      0|	}						\
  |  | 6900|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6900:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 7766|      0|	    SET_SCALAR_DVAL(value, REAL_ELT(seq, i));
 7767|      0|	    SET_FOR_LOOP_VAR(value, cell, loopinfo, rho);
  ------------------
  |  | 6904|      0|#define SET_FOR_LOOP_VAR(value, cell, loopinfo, rho) do {	\
  |  | 6905|      0|	if (BNDCELL_UNBOUND(cell) ||				\
  |  |  ------------------
  |  |  |  | 5686|      0|#define BNDCELL_UNBOUND(v) (BNDCELL_TAG(v) == 0 && CAR0(v) == R_UnboundValue)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5686:29): [True: 0, False: 0]
  |  |  |  |  |  Branch (5686:52): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6906|      0|	    ! SET_BINDING_VALUE(cell, value))			\
  |  |  ------------------
  |  |  |  Branch (6906:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6907|      0|	    defineVar(loopinfo->symbol, value, rho);		\
  |  |  ------------------
  |  |  |  |  905|      0|#define defineVar		Rf_defineVar
  |  |  ------------------
  |  | 6908|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6908:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 7768|      0|	    NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7769|    886|	  case INTSXP:
  ------------------
  |  |  123|    886|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (7769:4): [True: 886, False: 387k]
  ------------------
 7770|    886|	    if (BNDCELL_TAG_WR(cell) == INTSXP) {
  ------------------
  |  | 5682|    886|#define BNDCELL_TAG_WR(v) (BINDING_IS_LOCKED(v) ? 0 : BNDCELL_TAG(v))
  |  |  ------------------
  |  |  |  Branch (5682:28): [True: 0, False: 886]
  |  |  ------------------
  ------------------
              	    if (BNDCELL_TAG_WR(cell) == INTSXP) {
  ------------------
  |  |  123|    886|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (7770:10): [True: 862, False: 24]
  ------------------
 7771|    862|		SET_BNDCELL_IVAL(cell, INTEGER_ELT(seq, i));
 7772|    862|		NEXT();
  ------------------
  |  | 5655|    862|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7773|    862|	    }
 7774|    886|	    if (BNDCELL_WRITABLE(cell)) {
  ------------------
  |  | 5685|    886|    (v != R_NilValue &&	 ! BINDING_IS_LOCKED(v) && ! IS_ACTIVE_BINDING(v))
  |  |  ------------------
  |  |  |  Branch (5685:6): [True: 24, False: 862]
  |  |  |  Branch (5685:26): [True: 24, False: 0]
  |  |  |  Branch (5685:52): [True: 24, False: 0]
  |  |  ------------------
  ------------------
 7775|     24|		NEW_BNDCELL_IVAL(cell, INTEGER_ELT(seq, i));
 7776|     24|		NEXT();
  ------------------
  |  | 5655|     24|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7777|     24|	    }
 7778|    886|	    GET_VEC_LOOP_VALUE(value);
  ------------------
  |  | 6891|    886|#define GET_VEC_LOOP_VALUE(var) do {			\
  |  | 6892|    886|	(var) = GETSTACK_SXPVAL(-1);			\
  |  |  ------------------
  |  |  |  | 4901|    886|#define GETSTACK_SXPVAL(i) GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|    886|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6893|    886|	if (BNDCELL_TAG(cell) ||			\
  |  |  ------------------
  |  |  |  Branch (6893:6): [True: 886, False: 0]
  |  |  ------------------
  |  | 6894|    886|	    (var) != CAR(cell) || MAYBE_SHARED(var) ||	\
  |  |  ------------------
  |  |  |  Branch (6894:6): [True: 0, False: 0]
  |  |  |  Branch (6894:28): [True: 0, False: 0]
  |  |  ------------------
  |  | 6895|    886|	    ATTRIB(var) != R_NilValue) {		\
  |  |  ------------------
  |  |  |  Branch (6895:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6896|      0|	    (var) = allocVector(TYPEOF(seq), 1);	\
  |  |  ------------------
  |  |  |  |  875|      0|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  | 6897|      0|	    SETSTACK_NLNK(-1, var);			\
  |  |  ------------------
  |  |  |  | 4849|      0|#define SETSTACK_NLNK(i, v) SETSTACK_NLNK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4843|      0|#define SETSTACK_NLNK_PTR(s, v) do {			\
  |  |  |  |  |  | 4844|      0|	R_bcstack_t *__s__ = (s);			\
  |  |  |  |  |  | 4845|      0|	SEXP __v__ = (v);				\
  |  |  |  |  |  | 4846|      0|	__s__->tag = NLNKSXP;				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4803|      0|#define NLNKSXP 9996
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4847|      0|	__s__->u.sxpval = __v__;			\
  |  |  |  |  |  | 4848|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4848:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6898|      0|	    INCREMENT_NAMED(var);			\
  |  |  ------------------
  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6899|      0|	}						\
  |  | 6900|    886|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6900:14): [Folded, False: 886]
  |  |  ------------------
  ------------------
 7779|    886|	    SET_SCALAR_IVAL(value, INTEGER_ELT(seq, i));
 7780|    886|	    SET_FOR_LOOP_VAR(value, cell, loopinfo, rho);
  ------------------
  |  | 6904|    886|#define SET_FOR_LOOP_VAR(value, cell, loopinfo, rho) do {	\
  |  | 6905|    886|	if (BNDCELL_UNBOUND(cell) ||				\
  |  |  ------------------
  |  |  |  | 5686|  1.77k|#define BNDCELL_UNBOUND(v) (BNDCELL_TAG(v) == 0 && CAR0(v) == R_UnboundValue)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5686:29): [True: 0, False: 886]
  |  |  |  |  |  Branch (5686:52): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6906|    886|	    ! SET_BINDING_VALUE(cell, value))			\
  |  |  ------------------
  |  |  |  Branch (6906:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6907|    886|	    defineVar(loopinfo->symbol, value, rho);		\
  |  |  ------------------
  |  |  |  |  905|      0|#define defineVar		Rf_defineVar
  |  |  ------------------
  |  | 6908|    886|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6908:14): [Folded, False: 886]
  |  |  ------------------
  ------------------
 7781|    886|	    NEXT();
  ------------------
  |  | 5655|    886|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7782|    886|#ifdef COMPACT_INTSEQ
 7783|   388k|	  case INTSEQSXP:
  ------------------
  |  | 4800|   388k|# define INTSEQSXP 9999
  ------------------
  |  Branch (7783:4): [True: 387k, False: 1.46k]
  ------------------
 7784|   388k|	    {
 7785|   388k|		int *info = INTEGER(seq);
 7786|   388k|		int n1 = info[0];
 7787|   388k|		int n2 = info[1];
 7788|   388k|		int ii = (int) i;
 7789|   388k|		int ival = n1 <= n2 ? n1 + ii : n1 - ii;
  ------------------
  |  Branch (7789:14): [True: 387k, False: 886]
  ------------------
 7790|   388k|		if (BNDCELL_TAG_WR(cell) == INTSXP) {
  ------------------
  |  | 5682|   388k|#define BNDCELL_TAG_WR(v) (BINDING_IS_LOCKED(v) ? 0 : BNDCELL_TAG(v))
  |  |  ------------------
  |  |  |  Branch (5682:28): [True: 0, False: 388k]
  |  |  ------------------
  ------------------
              		if (BNDCELL_TAG_WR(cell) == INTSXP) {
  ------------------
  |  |  123|   388k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (7790:7): [True: 814, False: 387k]
  ------------------
 7791|    814|		    SET_BNDCELL_IVAL(cell,  ival);
 7792|    814|		    NEXT();
  ------------------
  |  | 5655|    814|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7793|    814|		}
 7794|   388k|		if (BNDCELL_WRITABLE(cell)) {
  ------------------
  |  | 5685|   388k|    (v != R_NilValue &&	 ! BINDING_IS_LOCKED(v) && ! IS_ACTIVE_BINDING(v))
  |  |  ------------------
  |  |  |  Branch (5685:6): [True: 386k, False: 1.70k]
  |  |  |  Branch (5685:26): [True: 386k, False: 0]
  |  |  |  Branch (5685:52): [True: 386k, False: 0]
  |  |  ------------------
  ------------------
 7795|   386k|		    NEW_BNDCELL_IVAL(cell, ival);
 7796|   386k|		    NEXT();
  ------------------
  |  | 5655|   386k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7797|   386k|		}
 7798|   388k|		GET_VEC_LOOP_VALUE(value);
  ------------------
  |  | 6891|   388k|#define GET_VEC_LOOP_VALUE(var) do {			\
  |  | 6892|   388k|	(var) = GETSTACK_SXPVAL(-1);			\
  |  |  ------------------
  |  |  |  | 4901|   388k|#define GETSTACK_SXPVAL(i) GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|   388k|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6893|   388k|	if (BNDCELL_TAG(cell) ||			\
  |  |  ------------------
  |  |  |  Branch (6893:6): [True: 388k, False: 0]
  |  |  ------------------
  |  | 6894|   388k|	    (var) != CAR(cell) || MAYBE_SHARED(var) ||	\
  |  |  ------------------
  |  |  |  Branch (6894:6): [True: 0, False: 0]
  |  |  |  Branch (6894:28): [True: 0, False: 0]
  |  |  ------------------
  |  | 6895|   388k|	    ATTRIB(var) != R_NilValue) {		\
  |  |  ------------------
  |  |  |  Branch (6895:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6896|      0|	    (var) = allocVector(TYPEOF(seq), 1);	\
  |  |  ------------------
  |  |  |  |  875|      0|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  | 6897|      0|	    SETSTACK_NLNK(-1, var);			\
  |  |  ------------------
  |  |  |  | 4849|      0|#define SETSTACK_NLNK(i, v) SETSTACK_NLNK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4843|      0|#define SETSTACK_NLNK_PTR(s, v) do {			\
  |  |  |  |  |  | 4844|      0|	R_bcstack_t *__s__ = (s);			\
  |  |  |  |  |  | 4845|      0|	SEXP __v__ = (v);				\
  |  |  |  |  |  | 4846|      0|	__s__->tag = NLNKSXP;				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4803|      0|#define NLNKSXP 9996
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4847|      0|	__s__->u.sxpval = __v__;			\
  |  |  |  |  |  | 4848|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4848:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6898|      0|	    INCREMENT_NAMED(var);			\
  |  |  ------------------
  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6899|      0|	}						\
  |  | 6900|   388k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6900:14): [Folded, False: 388k]
  |  |  ------------------
  ------------------
 7799|   388k|		SET_SCALAR_IVAL(value, ival);
 7800|   388k|		SET_FOR_LOOP_VAR(value, cell, loopinfo, rho);
  ------------------
  |  | 6904|   388k|#define SET_FOR_LOOP_VAR(value, cell, loopinfo, rho) do {	\
  |  | 6905|   388k|	if (BNDCELL_UNBOUND(cell) ||				\
  |  |  ------------------
  |  |  |  | 5686|   776k|#define BNDCELL_UNBOUND(v) (BNDCELL_TAG(v) == 0 && CAR0(v) == R_UnboundValue)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5686:29): [True: 0, False: 388k]
  |  |  |  |  |  Branch (5686:52): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6906|   388k|	    ! SET_BINDING_VALUE(cell, value))			\
  |  |  ------------------
  |  |  |  Branch (6906:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6907|   388k|	    defineVar(loopinfo->symbol, value, rho);		\
  |  |  ------------------
  |  |  |  |  905|      0|#define defineVar		Rf_defineVar
  |  |  ------------------
  |  | 6908|   388k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6908:14): [Folded, False: 388k]
  |  |  ------------------
  ------------------
 7801|   388k|		NEXT();
  ------------------
  |  | 5655|   388k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7802|   388k|	    }
 7803|   388k|#endif
 7804|   388k|	  case LGLSXP:
  ------------------
  |  |  121|   388k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (7804:4): [True: 0, False: 388k]
  ------------------
 7805|   388k|	    if (BNDCELL_TAG_WR(cell) == LGLSXP) {
  ------------------
  |  | 5682|   388k|#define BNDCELL_TAG_WR(v) (BINDING_IS_LOCKED(v) ? 0 : BNDCELL_TAG(v))
  |  |  ------------------
  |  |  |  Branch (5682:28): [True: 0, False: 388k]
  |  |  ------------------
  ------------------
              	    if (BNDCELL_TAG_WR(cell) == LGLSXP) {
  ------------------
  |  |  121|   388k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (7805:10): [True: 0, False: 388k]
  ------------------
 7806|      0|		SET_BNDCELL_LVAL(cell,  LOGICAL_ELT(seq, i));
 7807|      0|		NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7808|      0|	    }
 7809|   388k|	    if (BNDCELL_WRITABLE(cell)) {
  ------------------
  |  | 5685|   388k|    (v != R_NilValue &&	 ! BINDING_IS_LOCKED(v) && ! IS_ACTIVE_BINDING(v))
  |  |  ------------------
  |  |  |  Branch (5685:6): [True: 0, False: 388k]
  |  |  |  Branch (5685:26): [True: 0, False: 0]
  |  |  |  Branch (5685:52): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 7810|      0|		NEW_BNDCELL_LVAL(cell, LOGICAL_ELT(seq, i));
 7811|      0|		NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7812|      0|	    }
 7813|   388k|	    GET_VEC_LOOP_VALUE(value);
  ------------------
  |  | 6891|   388k|#define GET_VEC_LOOP_VALUE(var) do {			\
  |  | 6892|   388k|	(var) = GETSTACK_SXPVAL(-1);			\
  |  |  ------------------
  |  |  |  | 4901|   388k|#define GETSTACK_SXPVAL(i) GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|   388k|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6893|   388k|	if (BNDCELL_TAG(cell) ||			\
  |  |  ------------------
  |  |  |  Branch (6893:6): [True: 388k, False: 0]
  |  |  ------------------
  |  | 6894|   388k|	    (var) != CAR(cell) || MAYBE_SHARED(var) ||	\
  |  |  ------------------
  |  |  |  Branch (6894:6): [True: 0, False: 0]
  |  |  |  Branch (6894:28): [True: 0, False: 0]
  |  |  ------------------
  |  | 6895|   388k|	    ATTRIB(var) != R_NilValue) {		\
  |  |  ------------------
  |  |  |  Branch (6895:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6896|      0|	    (var) = allocVector(TYPEOF(seq), 1);	\
  |  |  ------------------
  |  |  |  |  875|      0|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  | 6897|      0|	    SETSTACK_NLNK(-1, var);			\
  |  |  ------------------
  |  |  |  | 4849|      0|#define SETSTACK_NLNK(i, v) SETSTACK_NLNK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4843|      0|#define SETSTACK_NLNK_PTR(s, v) do {			\
  |  |  |  |  |  | 4844|      0|	R_bcstack_t *__s__ = (s);			\
  |  |  |  |  |  | 4845|      0|	SEXP __v__ = (v);				\
  |  |  |  |  |  | 4846|      0|	__s__->tag = NLNKSXP;				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4803|      0|#define NLNKSXP 9996
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4847|      0|	__s__->u.sxpval = __v__;			\
  |  |  |  |  |  | 4848|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4848:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6898|      0|	    INCREMENT_NAMED(var);			\
  |  |  ------------------
  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6899|      0|	}						\
  |  | 6900|   388k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6900:14): [Folded, False: 388k]
  |  |  ------------------
  ------------------
 7814|   388k|	    SET_SCALAR_LVAL(value, LOGICAL_ELT(seq, i));
 7815|   388k|	    SET_FOR_LOOP_VAR(value, cell, loopinfo, rho);
  ------------------
  |  | 6904|   388k|#define SET_FOR_LOOP_VAR(value, cell, loopinfo, rho) do {	\
  |  | 6905|   388k|	if (BNDCELL_UNBOUND(cell) ||				\
  |  |  ------------------
  |  |  |  | 5686|   776k|#define BNDCELL_UNBOUND(v) (BNDCELL_TAG(v) == 0 && CAR0(v) == R_UnboundValue)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5686:29): [True: 0, False: 388k]
  |  |  |  |  |  Branch (5686:52): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6906|   388k|	    ! SET_BINDING_VALUE(cell, value))			\
  |  |  ------------------
  |  |  |  Branch (6906:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6907|   388k|	    defineVar(loopinfo->symbol, value, rho);		\
  |  |  ------------------
  |  |  |  |  905|      0|#define defineVar		Rf_defineVar
  |  |  ------------------
  |  | 6908|   388k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6908:14): [Folded, False: 388k]
  |  |  ------------------
  ------------------
 7816|   388k|	    NEXT();
  ------------------
  |  | 5655|   388k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7817|   388k|	  case CPLXSXP:
  ------------------
  |  |  125|   388k|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (7817:4): [True: 0, False: 388k]
  ------------------
 7818|   388k|	    GET_VEC_LOOP_VALUE(value);
  ------------------
  |  | 6891|   388k|#define GET_VEC_LOOP_VALUE(var) do {			\
  |  | 6892|   388k|	(var) = GETSTACK_SXPVAL(-1);			\
  |  |  ------------------
  |  |  |  | 4901|   388k|#define GETSTACK_SXPVAL(i) GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|   388k|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6893|   388k|	if (BNDCELL_TAG(cell) ||			\
  |  |  ------------------
  |  |  |  Branch (6893:6): [True: 388k, False: 0]
  |  |  ------------------
  |  | 6894|   388k|	    (var) != CAR(cell) || MAYBE_SHARED(var) ||	\
  |  |  ------------------
  |  |  |  Branch (6894:6): [True: 0, False: 0]
  |  |  |  Branch (6894:28): [True: 0, False: 0]
  |  |  ------------------
  |  | 6895|   388k|	    ATTRIB(var) != R_NilValue) {		\
  |  |  ------------------
  |  |  |  Branch (6895:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6896|      0|	    (var) = allocVector(TYPEOF(seq), 1);	\
  |  |  ------------------
  |  |  |  |  875|      0|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  | 6897|      0|	    SETSTACK_NLNK(-1, var);			\
  |  |  ------------------
  |  |  |  | 4849|      0|#define SETSTACK_NLNK(i, v) SETSTACK_NLNK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4843|      0|#define SETSTACK_NLNK_PTR(s, v) do {			\
  |  |  |  |  |  | 4844|      0|	R_bcstack_t *__s__ = (s);			\
  |  |  |  |  |  | 4845|      0|	SEXP __v__ = (v);				\
  |  |  |  |  |  | 4846|      0|	__s__->tag = NLNKSXP;				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4803|      0|#define NLNKSXP 9996
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4847|      0|	__s__->u.sxpval = __v__;			\
  |  |  |  |  |  | 4848|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4848:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6898|      0|	    INCREMENT_NAMED(var);			\
  |  |  ------------------
  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6899|      0|	}						\
  |  | 6900|   388k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6900:14): [Folded, False: 388k]
  |  |  ------------------
  ------------------
 7819|   388k|	    SET_SCALAR_CVAL(value, COMPLEX_ELT(seq, i));
 7820|   388k|	    break;
 7821|    508|	  case STRSXP:
  ------------------
  |  |  126|    508|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (7821:4): [True: 508, False: 388k]
  ------------------
 7822|    508|	    GET_VEC_LOOP_VALUE(value);
  ------------------
  |  | 6891|    508|#define GET_VEC_LOOP_VALUE(var) do {			\
  |  | 6892|    508|	(var) = GETSTACK_SXPVAL(-1);			\
  |  |  ------------------
  |  |  |  | 4901|    508|#define GETSTACK_SXPVAL(i) GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|    508|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6893|    508|	if (BNDCELL_TAG(cell) ||			\
  |  |  ------------------
  |  |  |  Branch (6893:6): [True: 0, False: 508]
  |  |  ------------------
  |  | 6894|    508|	    (var) != CAR(cell) || MAYBE_SHARED(var) ||	\
  |  |  ------------------
  |  |  |  Branch (6894:6): [True: 22, False: 486]
  |  |  |  Branch (6894:28): [True: 4, False: 482]
  |  |  ------------------
  |  | 6895|    508|	    ATTRIB(var) != R_NilValue) {		\
  |  |  ------------------
  |  |  |  Branch (6895:6): [True: 0, False: 482]
  |  |  ------------------
  |  | 6896|     26|	    (var) = allocVector(TYPEOF(seq), 1);	\
  |  |  ------------------
  |  |  |  |  875|     26|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  | 6897|     26|	    SETSTACK_NLNK(-1, var);			\
  |  |  ------------------
  |  |  |  | 4849|     26|#define SETSTACK_NLNK(i, v) SETSTACK_NLNK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4843|     26|#define SETSTACK_NLNK_PTR(s, v) do {			\
  |  |  |  |  |  | 4844|     26|	R_bcstack_t *__s__ = (s);			\
  |  |  |  |  |  | 4845|     26|	SEXP __v__ = (v);				\
  |  |  |  |  |  | 4846|     26|	__s__->tag = NLNKSXP;				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4803|     26|#define NLNKSXP 9996
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4847|     26|	__s__->u.sxpval = __v__;			\
  |  |  |  |  |  | 4848|     26|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4848:14): [Folded, False: 26]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6898|     26|	    INCREMENT_NAMED(var);			\
  |  |  ------------------
  |  |  |  |  222|     26|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 26]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6899|     26|	}						\
  |  | 6900|    508|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6900:14): [Folded, False: 508]
  |  |  ------------------
  ------------------
 7823|    508|	    SET_STRING_ELT(value, 0, STRING_ELT(seq, i));
 7824|    508|	    break;
 7825|      0|	  case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (7825:4): [True: 0, False: 388k]
  ------------------
 7826|      0|	    GET_VEC_LOOP_VALUE(value);
  ------------------
  |  | 6891|      0|#define GET_VEC_LOOP_VALUE(var) do {			\
  |  | 6892|      0|	(var) = GETSTACK_SXPVAL(-1);			\
  |  |  ------------------
  |  |  |  | 4901|      0|#define GETSTACK_SXPVAL(i) GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|      0|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6893|      0|	if (BNDCELL_TAG(cell) ||			\
  |  |  ------------------
  |  |  |  Branch (6893:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6894|      0|	    (var) != CAR(cell) || MAYBE_SHARED(var) ||	\
  |  |  ------------------
  |  |  |  Branch (6894:6): [True: 0, False: 0]
  |  |  |  Branch (6894:28): [True: 0, False: 0]
  |  |  ------------------
  |  | 6895|      0|	    ATTRIB(var) != R_NilValue) {		\
  |  |  ------------------
  |  |  |  Branch (6895:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6896|      0|	    (var) = allocVector(TYPEOF(seq), 1);	\
  |  |  ------------------
  |  |  |  |  875|      0|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  | 6897|      0|	    SETSTACK_NLNK(-1, var);			\
  |  |  ------------------
  |  |  |  | 4849|      0|#define SETSTACK_NLNK(i, v) SETSTACK_NLNK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4843|      0|#define SETSTACK_NLNK_PTR(s, v) do {			\
  |  |  |  |  |  | 4844|      0|	R_bcstack_t *__s__ = (s);			\
  |  |  |  |  |  | 4845|      0|	SEXP __v__ = (v);				\
  |  |  |  |  |  | 4846|      0|	__s__->tag = NLNKSXP;				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4803|      0|#define NLNKSXP 9996
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4847|      0|	__s__->u.sxpval = __v__;			\
  |  |  |  |  |  | 4848|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4848:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6898|      0|	    INCREMENT_NAMED(var);			\
  |  |  ------------------
  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6899|      0|	}						\
  |  | 6900|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6900:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 7827|      0|	    SET_SCALAR_BVAL(value, RAW(seq)[i]);
 7828|      0|	    break;
 7829|      0|	  case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (7829:4): [True: 0, False: 388k]
  ------------------
 7830|     69|	  case VECSXP:
  ------------------
  |  |  131|     69|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (7830:4): [True: 69, False: 388k]
  ------------------
 7831|     69|	    value = VECTOR_ELT(seq, i);
 7832|     69|	    ENSURE_NAMEDMAX(value);
 7833|     69|	    break;
 7834|      0|	  case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (7834:4): [True: 0, False: 388k]
  ------------------
 7835|      0|	    value = CAR(seq);
 7836|      0|	    SET_FOR_LOOP_SEQ(CDR(seq));
  ------------------
  |  | 6879|      0|#define SET_FOR_LOOP_SEQ(v) SETSTACK(-4, v);
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7837|      0|	    ENSURE_NAMEDMAX(value);
 7838|      0|	    break;
 7839|      0|	  default:
  ------------------
  |  Branch (7839:4): [True: 0, False: 388k]
  ------------------
 7840|      0|	    error(_("invalid sequence argument in for loop"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid sequence argument in for loop"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 7841|   388k|	  }
 7842|    577|	  SET_FOR_LOOP_VAR(value, cell, loopinfo, rho);
  ------------------
  |  | 6904|    577|#define SET_FOR_LOOP_VAR(value, cell, loopinfo, rho) do {	\
  |  | 6905|    577|	if (BNDCELL_UNBOUND(cell) ||				\
  |  |  ------------------
  |  |  |  | 5686|  1.15k|#define BNDCELL_UNBOUND(v) (BNDCELL_TAG(v) == 0 && CAR0(v) == R_UnboundValue)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5686:29): [True: 577, False: 0]
  |  |  |  |  |  Branch (5686:52): [True: 0, False: 577]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6906|    577|	    ! SET_BINDING_VALUE(cell, value))			\
  |  |  ------------------
  |  |  |  Branch (6906:6): [True: 0, False: 577]
  |  |  ------------------
  |  | 6907|    577|	    defineVar(loopinfo->symbol, value, rho);		\
  |  |  ------------------
  |  |  |  |  905|      0|#define defineVar		Rf_defineVar
  |  |  ------------------
  |  | 6908|    577|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6908:14): [Folded, False: 577]
  |  |  ------------------
  ------------------
 7843|    577|	}
 7844|   387k|	NEXT();
  ------------------
  |  | 5655|   387k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7845|   387k|      }
 7846|   387k|    OP(ENDFOR, 0):
  ------------------
  |  | 5638|   387k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   387k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   387k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   387k|    goto loop; \
  |  | 5642|   387k|    op_##name
  ------------------
 7847|   386k|      {
 7848|   386k|	int offset = GET_FOR_LOOP_BCPROT_OFFSET();
  ------------------
  |  | 6881|   386k|#define GET_FOR_LOOP_BCPROT_OFFSET() GETSTACK_IVAL_PTR(R_BCNodeStackTop - 5)
  |  |  ------------------
  |  |  |  | 4841|   386k|#define GETSTACK_IVAL_PTR(s) ((s)->u.ival)
  |  |  ------------------
  ------------------
 7849|   386k|	DECLNK_stack(R_BCNodeStackBase + offset);
 7850|   386k|	SEXP seq = GET_FOR_LOOP_SEQ();
  ------------------
  |  | 6878|   386k|#define GET_FOR_LOOP_SEQ() GETSTACK_SXPVAL(-4)
  |  |  ------------------
  |  |  |  | 4901|   386k|#define GETSTACK_SXPVAL(i) GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|   386k|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7851|   386k|	DECREMENT_LINKS(seq);
  ------------------
  |  |  545|   386k|#define DECREMENT_LINKS(x) do {			\
  |  |  546|   386k|	SEXP dl__x__ = (x);			\
  |  |  547|   386k|	DECREMENT_NAMED(dl__x__);		\
  |  |  ------------------
  |  |  |  |  223|   386k|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (223:43): [Folded, False: 386k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  548|   386k|	DECREMENT_REFCNT(dl__x__);		\
  |  |  549|   386k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (549:14): [Folded, False: 386k]
  |  |  ------------------
  ------------------
 7852|   386k|	R_BCNodeStackTop -= FOR_LOOP_STATE_SIZE - 1;
  ------------------
  |  | 6875|   386k|#define FOR_LOOP_STATE_SIZE 5
  ------------------
 7853|   386k|	SETSTACK(-1, R_NilValue);
  ------------------
  |  | 4905|   386k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4858|   386k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|   386k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|   386k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 386k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|   386k|    SEXP __v__ = (v); \
  |  |  |  | 4861|   386k|    (s)->tag = 0; \
  |  |  |  | 4862|   386k|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|   386k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 386k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7854|   386k|	NEXT();
  ------------------
  |  | 5655|   386k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7855|   386k|      }
 7856|   386k|    OP(SETLOOPVAL, 0):
  ------------------
  |  | 5638|   386k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   386k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   386k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   386k|    goto loop; \
  |  | 5642|   386k|    op_##name
  ------------------
 7857|      0|      BCNPOP_IGNORE_VALUE(); SETSTACK(-1, R_NilValue); NEXT();
  ------------------
  |  | 5519|      0|#define BCNPOP_IGNORE_VALUE() R_BCNodeStackTop--
  ------------------
                    BCNPOP_IGNORE_VALUE(); SETSTACK(-1, R_NilValue); NEXT();
  ------------------
  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                    BCNPOP_IGNORE_VALUE(); SETSTACK(-1, R_NilValue); NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7858|  1.49k|    OP(INVISIBLE,0): R_Visible = FALSE; NEXT();
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|  1.49k|    op_##name
  ------------------
                  OP(INVISIBLE,0): R_Visible = FALSE; NEXT();
  ------------------
  |  | 5655|  1.49k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7859|  3.10M|    OP(LDCONST, 1):
  ------------------
  |  | 5638|  1.49k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.49k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.49k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.49k|    goto loop; \
  |  | 5642|  3.10M|    op_##name
  ------------------
 7860|  3.10M|      {
 7861|  3.10M|	R_Visible = TRUE;
 7862|  3.10M|	SEXP value = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|  3.10M|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 7863|  3.10M|	int type = TYPEOF(value);
 7864|  3.10M|	switch(type) {
  ------------------
  |  Branch (7864:9): [True: 1.17M, False: 1.92M]
  ------------------
 7865|  3.36k|	case REALSXP:
  ------------------
  |  |  124|  3.36k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (7865:2): [True: 3.36k, False: 3.09M]
  ------------------
 7866|  3.36k|	    if (IS_SIMPLE_SCALAR(value, REALSXP)) {
  ------------------
  |  |  218|  3.36k|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (218:6): [True: 3.36k, False: 2]
  |  |  |  Branch (218:28): [True: 3.36k, False: 0]
  |  |  ------------------
  ------------------
 7867|  3.36k|		BCNPUSH_REAL(REAL0(value)[0]);
  ------------------
  |  | 5462|  3.36k|#define BCNPUSH_REAL(v) do { \
  |  | 5463|  3.36k|  double __value__ = (v); \
  |  | 5464|  3.36k|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5465|  3.36k|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5465:7): [True: 0, False: 3.36k]
  |  |  ------------------
  |  | 5466|  3.36k|  __ntop__[-1].u.dval = __value__; \
  |  | 5467|  3.36k|  __ntop__[-1].tag = REALSXP; \
  |  |  ------------------
  |  |  |  |  124|  3.36k|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  | 5468|  3.36k|  R_BCNodeStackTop = __ntop__; \
  |  | 5469|  3.36k|} while (0)
  |  |  ------------------
  |  |  |  Branch (5469:10): [Folded, False: 3.36k]
  |  |  ------------------
  ------------------
 7868|  3.36k|		NEXT();
  ------------------
  |  | 5655|  3.36k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7869|  3.36k|	    }
 7870|  3.36k|	    break;
 7871|  1.16M|	case INTSXP:
  ------------------
  |  |  123|  1.16M|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (7871:2): [True: 1.16M, False: 1.93M]
  ------------------
 7872|  1.16M|	    if (IS_SIMPLE_SCALAR(value, INTSXP)) {
  ------------------
  |  |  218|  1.16M|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (218:6): [True: 1.16M, False: 8]
  |  |  |  Branch (218:28): [True: 1.16M, False: 0]
  |  |  ------------------
  ------------------
 7873|  1.16M|		BCNPUSH_INTEGER(INTEGER0(value)[0]);
  ------------------
  |  | 5471|  1.16M|#define BCNPUSH_INTEGER(v) do { \
  |  | 5472|  1.16M|  int __value__ = (v); \
  |  | 5473|  1.16M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5474|  1.16M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5474:7): [True: 0, False: 1.16M]
  |  |  ------------------
  |  | 5475|  1.16M|  __ntop__[-1].u.ival = __value__; \
  |  | 5476|  1.16M|  __ntop__[-1].tag = INTSXP; \
  |  |  ------------------
  |  |  |  |  123|  1.16M|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  | 5477|  1.16M|  R_BCNodeStackTop = __ntop__; \
  |  | 5478|  1.16M|} while (0)
  |  |  ------------------
  |  |  |  Branch (5478:10): [Folded, False: 1.16M]
  |  |  ------------------
  ------------------
 7874|  1.16M|		NEXT();
  ------------------
  |  | 5655|  1.16M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7875|  1.16M|	    }
 7876|  1.16M|	    break;
 7877|     28|	case LGLSXP:
  ------------------
  |  |  121|     28|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (7877:2): [True: 28, False: 3.10M]
  ------------------
 7878|     28|	    if (IS_SIMPLE_SCALAR(value, LGLSXP)) {
  ------------------
  |  |  218|     28|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (218:6): [True: 28, False: 0]
  |  |  |  Branch (218:28): [True: 28, False: 0]
  |  |  ------------------
  ------------------
 7879|     28|		BCNPUSH_LOGICAL(LOGICAL0(value)[0]);
  ------------------
  |  | 5480|     28|#define BCNPUSH_LOGICAL(v) do { \
  |  | 5481|     28|  int __value__ = (v); \
  |  | 5482|     28|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5483|     28|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5483:7): [True: 0, False: 28]
  |  |  ------------------
  |  | 5484|     28|  __ntop__[-1].u.ival = __value__; \
  |  | 5485|     28|  __ntop__[-1].tag = LGLSXP; \
  |  |  ------------------
  |  |  |  |  121|     28|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  | 5486|     28|  R_BCNodeStackTop = __ntop__; \
  |  | 5487|     28|} while (0)
  |  |  ------------------
  |  |  |  Branch (5487:10): [Folded, False: 28]
  |  |  ------------------
  ------------------
 7880|     28|		NEXT();
  ------------------
  |  | 5655|     28|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7881|     28|	    }
 7882|     28|	    break;
 7883|  3.10M|	}
 7884|  1.92M|	if (R_check_constants < 0)
  ------------------
  |  Branch (7884:6): [True: 0, False: 1.92M]
  ------------------
 7885|      0|	    value = duplicate(value);
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 7886|  1.92M|	MARK_NOT_MUTABLE(value);
 7887|  1.92M|	BCNPUSH(value);
  ------------------
  |  | 5449|  1.92M|#define BCNPUSH(v) do { \
  |  | 5450|  1.92M|  SEXP __value__ = (v); \
  |  | 5451|  1.92M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5452|  1.92M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5452:7): [True: 0, False: 1.92M]
  |  |  ------------------
  |  | 5453|  1.92M|  SETSTACK(0, __value__); \
  |  |  ------------------
  |  |  |  | 4905|  1.92M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  1.92M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  1.92M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  1.92M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.92M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  1.92M|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|  1.92M|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  1.92M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  1.92M|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.92M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5454|  1.92M|  R_BCNodeStackTop = __ntop__; \
  |  | 5455|  1.92M|} while (0)
  |  |  ------------------
  |  |  |  Branch (5455:10): [Folded, False: 1.92M]
  |  |  ------------------
  ------------------
 7888|  1.92M|	NEXT();
  ------------------
  |  | 5655|  1.92M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7889|  1.92M|      }
 7890|  2.34M|    OP(LDNULL, 0): R_Visible = TRUE; BCNPUSH(R_NilValue); NEXT();
  ------------------
  |  | 5638|  1.92M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.92M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.92M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.92M|    goto loop; \
  |  | 5642|  2.34M|    op_##name
  ------------------
                  OP(LDNULL, 0): R_Visible = TRUE; BCNPUSH(R_NilValue); NEXT();
  ------------------
  |  | 5449|  2.34M|#define BCNPUSH(v) do { \
  |  | 5450|  2.34M|  SEXP __value__ = (v); \
  |  | 5451|  2.34M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5452|  2.34M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5452:7): [True: 0, False: 2.34M]
  |  |  ------------------
  |  | 5453|  2.34M|  SETSTACK(0, __value__); \
  |  |  ------------------
  |  |  |  | 4905|  2.34M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  2.34M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  2.34M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  2.34M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 2.34M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  2.34M|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|  2.34M|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  2.34M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  2.34M|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 2.34M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5454|  2.34M|  R_BCNodeStackTop = __ntop__; \
  |  | 5455|  2.34M|} while (0)
  |  |  ------------------
  |  |  |  Branch (5455:10): [Folded, False: 2.34M]
  |  |  ------------------
  ------------------
                  OP(LDNULL, 0): R_Visible = TRUE; BCNPUSH(R_NilValue); NEXT();
  ------------------
  |  | 5655|  2.34M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7891|  2.34M|    OP(LDTRUE, 0): R_Visible = TRUE; BCNPUSH_LOGICAL(TRUE); NEXT();
  ------------------
  |  | 5638|  2.34M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  2.34M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  2.34M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  2.34M|    goto loop; \
  |  | 5642|  2.34M|    op_##name
  ------------------
                  OP(LDTRUE, 0): R_Visible = TRUE; BCNPUSH_LOGICAL(TRUE); NEXT();
  ------------------
  |  | 5480|    166|#define BCNPUSH_LOGICAL(v) do { \
  |  | 5481|    166|  int __value__ = (v); \
  |  | 5482|    166|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5483|    166|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5483:7): [True: 0, False: 166]
  |  |  ------------------
  |  | 5484|    166|  __ntop__[-1].u.ival = __value__; \
  |  | 5485|    166|  __ntop__[-1].tag = LGLSXP; \
  |  |  ------------------
  |  |  |  |  121|    166|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  | 5486|    166|  R_BCNodeStackTop = __ntop__; \
  |  | 5487|    166|} while (0)
  |  |  ------------------
  |  |  |  Branch (5487:10): [Folded, False: 166]
  |  |  ------------------
  ------------------
                  OP(LDTRUE, 0): R_Visible = TRUE; BCNPUSH_LOGICAL(TRUE); NEXT();
  ------------------
  |  | 5655|    166|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7892|    198|    OP(LDFALSE, 0): R_Visible = TRUE; BCNPUSH_LOGICAL(FALSE); NEXT();
  ------------------
  |  | 5638|    168|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    168|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    168|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    168|    goto loop; \
  |  | 5642|    198|    op_##name
  ------------------
                  OP(LDFALSE, 0): R_Visible = TRUE; BCNPUSH_LOGICAL(FALSE); NEXT();
  ------------------
  |  | 5480|    198|#define BCNPUSH_LOGICAL(v) do { \
  |  | 5481|    198|  int __value__ = (v); \
  |  | 5482|    198|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5483|    198|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5483:7): [True: 0, False: 198]
  |  |  ------------------
  |  | 5484|    198|  __ntop__[-1].u.ival = __value__; \
  |  | 5485|    198|  __ntop__[-1].tag = LGLSXP; \
  |  |  ------------------
  |  |  |  |  121|    198|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  | 5486|    198|  R_BCNodeStackTop = __ntop__; \
  |  | 5487|    198|} while (0)
  |  |  ------------------
  |  |  |  Branch (5487:10): [Folded, False: 198]
  |  |  ------------------
  ------------------
                  OP(LDFALSE, 0): R_Visible = TRUE; BCNPUSH_LOGICAL(FALSE); NEXT();
  ------------------
  |  | 5655|    198|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7893|  21.0M|    OP(GETVAR, 1): DO_GETVAR(FALSE, FALSE);
  ------------------
  |  | 5638|    200|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    200|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    200|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    200|    goto loop; \
  |  | 5642|  21.0M|    op_##name
  ------------------
                  OP(GETVAR, 1): DO_GETVAR(FALSE, FALSE);
  ------------------
  |  | 5921|  21.0M|#define DO_GETVAR(dd,keepmiss) do { \
  |  | 5922|  21.0M|    int sidx = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|  21.0M|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 5923|  21.0M|    R_Visible = TRUE;	     \
  |  | 5924|  21.0M|    if (!dd && smallcache) {						\
  |  |  ------------------
  |  |  |  Branch (5924:9): [True: 21.0M, Folded]
  |  |  |  Branch (5924:16): [True: 21.0M, False: 2.25k]
  |  |  ------------------
  |  | 5925|  21.0M|	SEXP cell = GET_SMALLCACHE_BINDING_CELL(vcache, sidx);		\
  |  |  ------------------
  |  |  |  | 5771|  21.0M|#  define GET_SMALLCACHE_BINDING_CELL(vcache, sidx) VCACHE(sidx)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5768|  21.0M|#  define VCACHE(i) GETSTACK_SXPVAL_PTR(vcache + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4839|  21.0M|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5926|  21.0M|	if (cell == R_NilValue) {					\
  |  |  ------------------
  |  |  |  Branch (5926:6): [True: 14.4M, False: 6.59M]
  |  |  ------------------
  |  | 5927|  14.4M|	    /* make sure local variable cells are cached */		\
  |  | 5928|  14.4M|	    SEXP symbol = GETCONST(constants, sidx);			\
  |  |  ------------------
  |  |  |  | 5550|  14.4M|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5929|  14.4M|	    cell = GET_BINDING_CELL_CACHE(symbol, rho, vcache, sidx);	\
  |  | 5930|  14.4M|	}								\
  |  | 5931|  21.0M|	/* handle immediate binings */					\
  |  | 5932|  21.0M|	switch (BNDCELL_TAG(cell)) {					\
  |  |  ------------------
  |  |  |  Branch (5932:10): [True: 2.16k, False: 21.0M]
  |  |  ------------------
  |  | 5933|      0|	case REALSXP: BCNPUSH_REAL(BNDCELL_DVAL(cell)); NEXT();		\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	case REALSXP: BCNPUSH_REAL(BNDCELL_DVAL(cell)); NEXT();		\
  |  |  ------------------
  |  |  |  | 5462|      0|#define BCNPUSH_REAL(v) do { \
  |  |  |  | 5463|      0|  double __value__ = (v); \
  |  |  |  | 5464|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5465|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5465:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5466|      0|  __ntop__[-1].u.dval = __value__; \
  |  |  |  | 5467|      0|  __ntop__[-1].tag = REALSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  | 5468|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5469|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5469:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	case REALSXP: BCNPUSH_REAL(BNDCELL_DVAL(cell)); NEXT();		\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5933:2): [True: 0, False: 21.0M]
  |  |  ------------------
  |  | 5934|  2.16k|	case INTSXP: BCNPUSH_INTEGER(BNDCELL_IVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  |  123|  2.16k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	case INTSXP: BCNPUSH_INTEGER(BNDCELL_IVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5471|  2.16k|#define BCNPUSH_INTEGER(v) do { \
  |  |  |  | 5472|  2.16k|  int __value__ = (v); \
  |  |  |  | 5473|  2.16k|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5474|  2.16k|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5474:7): [True: 0, False: 2.16k]
  |  |  |  |  ------------------
  |  |  |  | 5475|  2.16k|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5476|  2.16k|  __ntop__[-1].tag = INTSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|  2.16k|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 5477|  2.16k|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5478|  2.16k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5478:10): [Folded, False: 2.16k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	case INTSXP: BCNPUSH_INTEGER(BNDCELL_IVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5655|  2.16k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5934:2): [True: 2.16k, False: 21.0M]
  |  |  ------------------
  |  | 5935|  2.16k|	case LGLSXP: BCNPUSH_LOGICAL(BNDCELL_LVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  |  121|  2.16k|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |               	case LGLSXP: BCNPUSH_LOGICAL(BNDCELL_LVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5480|  2.16k|#define BCNPUSH_LOGICAL(v) do { \
  |  |  |  | 5481|  2.16k|  int __value__ = (v); \
  |  |  |  | 5482|  2.16k|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5483|  2.16k|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5483:7): [True: 0, False: 2.16k]
  |  |  |  |  ------------------
  |  |  |  | 5484|  2.16k|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5485|  2.16k|  __ntop__[-1].tag = LGLSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|  2.16k|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 5486|  2.16k|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5487|  2.16k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5487:10): [Folded, False: 2.16k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	case LGLSXP: BCNPUSH_LOGICAL(BNDCELL_LVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5655|  2.16k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5935:2): [True: 4, False: 21.0M]
  |  |  ------------------
  |  | 5936|  21.0M|	}								\
  |  | 5937|  21.0M|	SEXP value = CAR(cell);						\
  |  | 5938|  21.0M|	int type = TYPEOF(value);					\
  |  | 5939|  21.0M|	/* extract value of forced promises */				\
  |  | 5940|  21.0M|	if (type == PROMSXP) {						\
  |  |  ------------------
  |  |  |  |  116|  21.0M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (5940:6): [True: 8.59M, False: 12.4M]
  |  |  ------------------
  |  | 5941|  8.59M|	    if (PROMISE_IS_EVALUATED(value)) {				\
  |  |  ------------------
  |  |  |  Branch (5941:10): [True: 2.33M, False: 6.26M]
  |  |  ------------------
  |  | 5942|  2.33M|		switch (PROMISE_TAG(value)) {				\
  |  |  ------------------
  |  |  |  Branch (5942:11): [True: 0, False: 2.33M]
  |  |  ------------------
  |  | 5943|      0|		case REALSXP: BCNPUSH_REAL(PROMISE_DVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               		case REALSXP: BCNPUSH_REAL(PROMISE_DVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5462|      0|#define BCNPUSH_REAL(v) do { \
  |  |  |  | 5463|      0|  double __value__ = (v); \
  |  |  |  | 5464|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5465|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5465:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5466|      0|  __ntop__[-1].u.dval = __value__; \
  |  |  |  | 5467|      0|  __ntop__[-1].tag = REALSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  | 5468|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5469|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5469:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               		case REALSXP: BCNPUSH_REAL(PROMISE_DVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5943:3): [True: 0, False: 2.33M]
  |  |  ------------------
  |  | 5944|      0|		case INTSXP: BCNPUSH_INTEGER(PROMISE_IVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               		case INTSXP: BCNPUSH_INTEGER(PROMISE_IVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5471|      0|#define BCNPUSH_INTEGER(v) do { \
  |  |  |  | 5472|      0|  int __value__ = (v); \
  |  |  |  | 5473|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5474|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5474:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5475|      0|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5476|      0|  __ntop__[-1].tag = INTSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 5477|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5478|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5478:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               		case INTSXP: BCNPUSH_INTEGER(PROMISE_IVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5944:3): [True: 0, False: 2.33M]
  |  |  ------------------
  |  | 5945|      0|		case LGLSXP: BCNPUSH_LOGICAL(PROMISE_LVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |               		case LGLSXP: BCNPUSH_LOGICAL(PROMISE_LVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5480|      0|#define BCNPUSH_LOGICAL(v) do { \
  |  |  |  | 5481|      0|  int __value__ = (v); \
  |  |  |  | 5482|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5483|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5483:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5484|      0|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5485|      0|  __ntop__[-1].tag = LGLSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 5486|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5487|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5487:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               		case LGLSXP: BCNPUSH_LOGICAL(PROMISE_LVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5945:3): [True: 0, False: 2.33M]
  |  |  ------------------
  |  | 5946|  2.33M|		}							\
  |  | 5947|  2.33M|		value = PRVALUE(value);					\
  |  | 5948|  2.33M|		type = TYPEOF(value);					\
  |  | 5949|  2.33M|	    }								\
  |  | 5950|  8.59M|	}								\
  |  | 5951|  21.0M|	/* try fast handling of some types; for these the */		\
  |  | 5952|  21.0M|	/* cell won't be R_NilValue or an active binding */		\
  |  | 5953|  21.0M|	switch(type) {							\
  |  | 5954|  6.49k|	case REALSXP:							\
  |  |  ------------------
  |  |  |  |  124|  6.49k|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5954:2): [True: 6.49k, False: 21.0M]
  |  |  ------------------
  |  | 5955|   786k|	case INTSXP:							\
  |  |  ------------------
  |  |  |  |  123|   786k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (5955:2): [True: 780k, False: 20.2M]
  |  |  ------------------
  |  | 5956|  1.56M|	case LGLSXP:							\
  |  |  ------------------
  |  |  |  |  121|  1.56M|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (5956:2): [True: 781k, False: 20.2M]
  |  |  ------------------
  |  | 5957|  1.56M|	case CPLXSXP:							\
  |  |  ------------------
  |  |  |  |  125|  1.56M|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |  |  Branch (5957:2): [True: 0, False: 21.0M]
  |  |  ------------------
  |  | 5958|  5.06M|	case STRSXP:							\
  |  |  ------------------
  |  |  |  |  126|  5.06M|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (5958:2): [True: 3.49M, False: 17.5M]
  |  |  ------------------
  |  | 5959|  13.1M|	case VECSXP:							\
  |  |  ------------------
  |  |  |  |  131|  13.1M|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (5959:2): [True: 8.12M, False: 12.9M]
  |  |  ------------------
  |  | 5960|  13.1M|	case RAWSXP:							\
  |  |  ------------------
  |  |  |  |  136|  13.1M|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (5960:2): [True: 0, False: 21.0M]
  |  |  ------------------
  |  | 5961|  13.1M|	    BCNPUSH(value);						\
  |  |  ------------------
  |  |  |  | 5449|  13.1M|#define BCNPUSH(v) do { \
  |  |  |  | 5450|  13.1M|  SEXP __value__ = (v); \
  |  |  |  | 5451|  13.1M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|  13.1M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 13.1M]
  |  |  |  |  ------------------
  |  |  |  | 5453|  13.1M|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  13.1M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  13.1M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  13.1M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  13.1M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 13.1M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  13.1M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  13.1M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  13.1M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  13.1M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 13.1M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|  13.1M|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|  13.1M|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 13.1M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5962|  13.1M|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|  13.1M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5963|  13.1M|	case SYMSXP:							\
  |  |  ------------------
  |  |  |  |  112|  13.1M|#define SYMSXP	     1	  /* symbols */
  |  |  ------------------
  |  |  |  Branch (5963:2): [True: 459, False: 21.0M]
  |  |  ------------------
  |  | 5964|  19.4M|	case PROMSXP:							\
  |  |  ------------------
  |  |  |  |  116|  19.4M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (5964:2): [True: 6.26M, False: 14.7M]
  |  |  ------------------
  |  | 5965|  19.4M|	    break;							\
  |  | 5966|  13.1M|	default:							\
  |  |  ------------------
  |  |  |  Branch (5966:2): [True: 1.59M, False: 19.4M]
  |  |  ------------------
  |  | 5967|  1.59M|	    if (cell != R_NilValue && ! IS_ACTIVE_BINDING(cell)) {	\
  |  |  ------------------
  |  |  |  Branch (5967:10): [True: 1.57M, False: 22.2k]
  |  |  |  Branch (5967:32): [True: 1.57M, False: 0]
  |  |  ------------------
  |  | 5968|  1.57M|		BCNPUSH(value);						\
  |  |  ------------------
  |  |  |  | 5449|  1.57M|#define BCNPUSH(v) do { \
  |  |  |  | 5450|  1.57M|  SEXP __value__ = (v); \
  |  |  |  | 5451|  1.57M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|  1.57M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 1.57M]
  |  |  |  |  ------------------
  |  |  |  | 5453|  1.57M|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  1.57M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  1.57M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  1.57M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  1.57M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.57M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  1.57M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  1.57M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  1.57M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  1.57M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.57M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|  1.57M|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|  1.57M|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 1.57M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5969|  1.57M|		NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|  1.57M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5970|  1.57M|	    }								\
  |  | 5971|  21.0M|	}								\
  |  | 5972|  21.0M|    }									\
  |  | 5973|  21.0M|    SEXP symbol = GETCONST(constants, sidx);				\
  |  |  ------------------
  |  |  |  | 5550|  6.28M|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5974|  6.28M|    SEXP value = findVarEX(symbol, rho, dd, vcache, sidx);		\
  |  | 5975|  6.28M|    if (! keepmiss && TYPEOF(value) == PROMSXP &&			\
  |  |  ------------------
  |  |  |  |  116|  12.5M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (5975:9): [True: 6.28M, Folded]
  |  |  |  Branch (5975:23): [True: 6.26M, False: 18.5k]
  |  |  ------------------
  |  | 5976|  6.28M|	! PRSEEN(value) && ! PROMISE_IS_EVALUATED(value) &&		\
  |  |  ------------------
  |  |  |  Branch (5976:2): [True: 6.26M, False: 0]
  |  |  |  Branch (5976:21): [True: 6.26M, False: 5.01k]
  |  |  ------------------
  |  | 5977|  6.28M|	TYPEOF(PRCODE(value)) == BCODESXP) {				\
  |  |  ------------------
  |  |  |  |  133|  6.26M|#define BCODESXP    21    /* byte code */
  |  |  ------------------
  |  |  |  Branch (5977:2): [True: 3.52M, False: 2.73M]
  |  |  ------------------
  |  | 5978|  3.52M|	START_BCFRAME_PROM(value);					\
  |  |  ------------------
  |  |  |  | 7498|  3.52M|#define START_BCFRAME_PROM(prom) do {				\
  |  |  |  | 7499|  3.52M|	struct bcEval_locals locals =				\
  |  |  |  | 7500|  3.52M|	    setup_bcframe_prom(prom);				\
  |  |  |  | 7501|  3.52M|	SAVE_BCEVAL_LOCALS(BCFRAME_LOCALS());			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 7267|  3.52M|#define SAVE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  |  |  | 7268|  3.52M|	(loc)->body = body;			\
  |  |  |  |  |  | 7269|  3.52M|	(loc)->rho = rho;			\
  |  |  |  |  |  | 7270|  3.52M|	(loc)->vcache = vcache;			\
  |  |  |  |  |  | 7271|  3.52M|	(loc)->smallcache = smallcache;		\
  |  |  |  |  |  | 7272|  3.52M|	(loc)->pc = pc;				\
  |  |  |  |  |  | 7273|  3.52M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (7273:14): [Folded, False: 3.52M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7502|  3.52M|	RESTORE_BCEVAL_LOCALS(&locals);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 7275|  3.52M|#define RESTORE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  |  |  | 7276|  3.52M|	body = (loc)->body;			\
  |  |  |  |  |  | 7277|  3.52M|	codebase = BCCODE(body);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5659|  3.52M|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  736|  3.52M|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 7278|  3.52M|	constants = BCCONSTS(body);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5548|  3.52M|    (R_bcconsts_t) {((SEXP const *) DATAPTR_RO(BCODE_CONSTS(e)))}
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  737|  3.52M|#define BCODE_CONSTS(x) CDR(x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 7279|  3.52M|	rho = (loc)->rho;			\
  |  |  |  |  |  | 7280|  3.52M|	vcache = (loc)->vcache;			\
  |  |  |  |  |  | 7281|  3.52M|	smallcache = (loc)->smallcache;		\
  |  |  |  |  |  | 7282|  3.52M|	pc = (loc)->pc;				\
  |  |  |  |  |  | 7283|  3.52M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (7283:14): [Folded, False: 3.52M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7503|  3.52M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (7503:14): [Folded, False: 3.52M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5979|  3.52M|	NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|  3.52M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5980|  3.52M|	/* return cleanup is in DO_GETVAR_FORCE_PROMISE_RETURN */	\
  |  | 5981|  3.52M|    }									\
  |  | 5982|  6.28M|    BCNPUSH(getvar(symbol, rho, dd, keepmiss, vcache, sidx));		\
  |  |  ------------------
  |  |  |  | 5449|  6.28M|#define BCNPUSH(v) do { \
  |  |  |  | 5450|  6.28M|  SEXP __value__ = (v); \
  |  |  |  | 5451|  6.28M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|  6.28M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 6.28M]
  |  |  |  |  ------------------
  |  |  |  | 5453|  6.28M|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  6.28M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  6.28M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  6.28M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  6.28M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 6.28M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  6.28M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  6.28M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  6.28M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  6.28M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 6.28M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|  6.28M|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|  6.28M|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 6.28M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5983|  6.28M|    NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|  6.28M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5984|  6.28M|} while (0)
  |  |  ------------------
  |  |  |  Branch (5984:10): [Folded, False: 6.28M]
  |  |  ------------------
  ------------------
 7894|  6.28M|    OP(DDVAL, 1): DO_GETVAR(TRUE, FALSE);
  ------------------
  |  | 5638|  6.28M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  6.28M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  6.28M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  6.28M|    goto loop; \
  |  | 5642|  6.28M|    op_##name
  ------------------
                  OP(DDVAL, 1): DO_GETVAR(TRUE, FALSE);
  ------------------
  |  | 5921|      0|#define DO_GETVAR(dd,keepmiss) do { \
  |  | 5922|      0|    int sidx = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 5923|      0|    R_Visible = TRUE;	     \
  |  | 5924|      0|    if (!dd && smallcache) {						\
  |  |  ------------------
  |  |  |  Branch (5924:9): [Folded, False: 0]
  |  |  |  Branch (5924:16): [True: 0, False: 0]
  |  |  ------------------
  |  | 5925|      0|	SEXP cell = GET_SMALLCACHE_BINDING_CELL(vcache, sidx);		\
  |  |  ------------------
  |  |  |  | 5771|      0|#  define GET_SMALLCACHE_BINDING_CELL(vcache, sidx) VCACHE(sidx)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5768|      0|#  define VCACHE(i) GETSTACK_SXPVAL_PTR(vcache + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4839|      0|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5926|      0|	if (cell == R_NilValue) {					\
  |  |  ------------------
  |  |  |  Branch (5926:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5927|      0|	    /* make sure local variable cells are cached */		\
  |  | 5928|      0|	    SEXP symbol = GETCONST(constants, sidx);			\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5929|      0|	    cell = GET_BINDING_CELL_CACHE(symbol, rho, vcache, sidx);	\
  |  | 5930|      0|	}								\
  |  | 5931|      0|	/* handle immediate binings */					\
  |  | 5932|      0|	switch (BNDCELL_TAG(cell)) {					\
  |  |  ------------------
  |  |  |  Branch (5932:10): [True: 0, False: 0]
  |  |  ------------------
  |  | 5933|      0|	case REALSXP: BCNPUSH_REAL(BNDCELL_DVAL(cell)); NEXT();		\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	case REALSXP: BCNPUSH_REAL(BNDCELL_DVAL(cell)); NEXT();		\
  |  |  ------------------
  |  |  |  | 5462|      0|#define BCNPUSH_REAL(v) do { \
  |  |  |  | 5463|      0|  double __value__ = (v); \
  |  |  |  | 5464|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5465|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5465:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5466|      0|  __ntop__[-1].u.dval = __value__; \
  |  |  |  | 5467|      0|  __ntop__[-1].tag = REALSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  | 5468|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5469|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5469:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	case REALSXP: BCNPUSH_REAL(BNDCELL_DVAL(cell)); NEXT();		\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5933:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5934|      0|	case INTSXP: BCNPUSH_INTEGER(BNDCELL_IVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	case INTSXP: BCNPUSH_INTEGER(BNDCELL_IVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5471|      0|#define BCNPUSH_INTEGER(v) do { \
  |  |  |  | 5472|      0|  int __value__ = (v); \
  |  |  |  | 5473|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5474|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5474:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5475|      0|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5476|      0|  __ntop__[-1].tag = INTSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 5477|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5478|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5478:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	case INTSXP: BCNPUSH_INTEGER(BNDCELL_IVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5934:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5935|      0|	case LGLSXP: BCNPUSH_LOGICAL(BNDCELL_LVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |               	case LGLSXP: BCNPUSH_LOGICAL(BNDCELL_LVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5480|      0|#define BCNPUSH_LOGICAL(v) do { \
  |  |  |  | 5481|      0|  int __value__ = (v); \
  |  |  |  | 5482|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5483|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5483:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5484|      0|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5485|      0|  __ntop__[-1].tag = LGLSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 5486|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5487|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5487:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	case LGLSXP: BCNPUSH_LOGICAL(BNDCELL_LVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5935:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5936|      0|	}								\
  |  | 5937|      0|	SEXP value = CAR(cell);						\
  |  | 5938|      0|	int type = TYPEOF(value);					\
  |  | 5939|      0|	/* extract value of forced promises */				\
  |  | 5940|      0|	if (type == PROMSXP) {						\
  |  |  ------------------
  |  |  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (5940:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5941|      0|	    if (PROMISE_IS_EVALUATED(value)) {				\
  |  |  ------------------
  |  |  |  Branch (5941:10): [True: 0, False: 0]
  |  |  ------------------
  |  | 5942|      0|		switch (PROMISE_TAG(value)) {				\
  |  |  ------------------
  |  |  |  Branch (5942:11): [True: 0, False: 0]
  |  |  ------------------
  |  | 5943|      0|		case REALSXP: BCNPUSH_REAL(PROMISE_DVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               		case REALSXP: BCNPUSH_REAL(PROMISE_DVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5462|      0|#define BCNPUSH_REAL(v) do { \
  |  |  |  | 5463|      0|  double __value__ = (v); \
  |  |  |  | 5464|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5465|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5465:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5466|      0|  __ntop__[-1].u.dval = __value__; \
  |  |  |  | 5467|      0|  __ntop__[-1].tag = REALSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  | 5468|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5469|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5469:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               		case REALSXP: BCNPUSH_REAL(PROMISE_DVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5943:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 5944|      0|		case INTSXP: BCNPUSH_INTEGER(PROMISE_IVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               		case INTSXP: BCNPUSH_INTEGER(PROMISE_IVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5471|      0|#define BCNPUSH_INTEGER(v) do { \
  |  |  |  | 5472|      0|  int __value__ = (v); \
  |  |  |  | 5473|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5474|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5474:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5475|      0|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5476|      0|  __ntop__[-1].tag = INTSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 5477|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5478|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5478:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               		case INTSXP: BCNPUSH_INTEGER(PROMISE_IVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5944:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 5945|      0|		case LGLSXP: BCNPUSH_LOGICAL(PROMISE_LVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |               		case LGLSXP: BCNPUSH_LOGICAL(PROMISE_LVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5480|      0|#define BCNPUSH_LOGICAL(v) do { \
  |  |  |  | 5481|      0|  int __value__ = (v); \
  |  |  |  | 5482|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5483|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5483:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5484|      0|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5485|      0|  __ntop__[-1].tag = LGLSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 5486|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5487|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5487:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               		case LGLSXP: BCNPUSH_LOGICAL(PROMISE_LVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5945:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 5946|      0|		}							\
  |  | 5947|      0|		value = PRVALUE(value);					\
  |  | 5948|      0|		type = TYPEOF(value);					\
  |  | 5949|      0|	    }								\
  |  | 5950|      0|	}								\
  |  | 5951|      0|	/* try fast handling of some types; for these the */		\
  |  | 5952|      0|	/* cell won't be R_NilValue or an active binding */		\
  |  | 5953|      0|	switch(type) {							\
  |  | 5954|      0|	case REALSXP:							\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5954:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5955|      0|	case INTSXP:							\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (5955:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5956|      0|	case LGLSXP:							\
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (5956:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5957|      0|	case CPLXSXP:							\
  |  |  ------------------
  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |  |  Branch (5957:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5958|      0|	case STRSXP:							\
  |  |  ------------------
  |  |  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (5958:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5959|      0|	case VECSXP:							\
  |  |  ------------------
  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (5959:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5960|      0|	case RAWSXP:							\
  |  |  ------------------
  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (5960:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5961|      0|	    BCNPUSH(value);						\
  |  |  ------------------
  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5962|      0|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5963|      0|	case SYMSXP:							\
  |  |  ------------------
  |  |  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  |  |  ------------------
  |  |  |  Branch (5963:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5964|      0|	case PROMSXP:							\
  |  |  ------------------
  |  |  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (5964:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5965|      0|	    break;							\
  |  | 5966|      0|	default:							\
  |  |  ------------------
  |  |  |  Branch (5966:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5967|      0|	    if (cell != R_NilValue && ! IS_ACTIVE_BINDING(cell)) {	\
  |  |  ------------------
  |  |  |  Branch (5967:10): [True: 0, False: 0]
  |  |  |  Branch (5967:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 5968|      0|		BCNPUSH(value);						\
  |  |  ------------------
  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5969|      0|		NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5970|      0|	    }								\
  |  | 5971|      0|	}								\
  |  | 5972|      0|    }									\
  |  | 5973|      0|    SEXP symbol = GETCONST(constants, sidx);				\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5974|      0|    SEXP value = findVarEX(symbol, rho, dd, vcache, sidx);		\
  |  | 5975|      0|    if (! keepmiss && TYPEOF(value) == PROMSXP &&			\
  |  |  ------------------
  |  |  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (5975:9): [True: 0, Folded]
  |  |  |  Branch (5975:23): [True: 0, False: 0]
  |  |  ------------------
  |  | 5976|      0|	! PRSEEN(value) && ! PROMISE_IS_EVALUATED(value) &&		\
  |  |  ------------------
  |  |  |  Branch (5976:2): [True: 0, False: 0]
  |  |  |  Branch (5976:21): [True: 0, False: 0]
  |  |  ------------------
  |  | 5977|      0|	TYPEOF(PRCODE(value)) == BCODESXP) {				\
  |  |  ------------------
  |  |  |  |  133|      0|#define BCODESXP    21    /* byte code */
  |  |  ------------------
  |  |  |  Branch (5977:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5978|      0|	START_BCFRAME_PROM(value);					\
  |  |  ------------------
  |  |  |  | 7498|      0|#define START_BCFRAME_PROM(prom) do {				\
  |  |  |  | 7499|      0|	struct bcEval_locals locals =				\
  |  |  |  | 7500|      0|	    setup_bcframe_prom(prom);				\
  |  |  |  | 7501|      0|	SAVE_BCEVAL_LOCALS(BCFRAME_LOCALS());			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 7267|      0|#define SAVE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  |  |  | 7268|      0|	(loc)->body = body;			\
  |  |  |  |  |  | 7269|      0|	(loc)->rho = rho;			\
  |  |  |  |  |  | 7270|      0|	(loc)->vcache = vcache;			\
  |  |  |  |  |  | 7271|      0|	(loc)->smallcache = smallcache;		\
  |  |  |  |  |  | 7272|      0|	(loc)->pc = pc;				\
  |  |  |  |  |  | 7273|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (7273:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7502|      0|	RESTORE_BCEVAL_LOCALS(&locals);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 7275|      0|#define RESTORE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  |  |  | 7276|      0|	body = (loc)->body;			\
  |  |  |  |  |  | 7277|      0|	codebase = BCCODE(body);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5659|      0|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  736|      0|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 7278|      0|	constants = BCCONSTS(body);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5548|      0|    (R_bcconsts_t) {((SEXP const *) DATAPTR_RO(BCODE_CONSTS(e)))}
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  737|      0|#define BCODE_CONSTS(x) CDR(x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 7279|      0|	rho = (loc)->rho;			\
  |  |  |  |  |  | 7280|      0|	vcache = (loc)->vcache;			\
  |  |  |  |  |  | 7281|      0|	smallcache = (loc)->smallcache;		\
  |  |  |  |  |  | 7282|      0|	pc = (loc)->pc;				\
  |  |  |  |  |  | 7283|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (7283:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7503|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (7503:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5979|      0|	NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5980|      0|	/* return cleanup is in DO_GETVAR_FORCE_PROMISE_RETURN */	\
  |  | 5981|      0|    }									\
  |  | 5982|      0|    BCNPUSH(getvar(symbol, rho, dd, keepmiss, vcache, sidx));		\
  |  |  ------------------
  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5983|      0|    NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5984|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (5984:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 7895|  8.91M|    OP(SETVAR, 1):
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|  8.91M|    op_##name
  ------------------
 7896|  8.91M|      {
 7897|  8.91M|	int sidx = GETOP();
  ------------------
  |  | 5656|  8.91M|#define GETOP() (*pc++).i
  ------------------
 7898|  8.91M|	SEXP loc;
 7899|  8.91M|	if (smallcache)
  ------------------
  |  Branch (7899:6): [True: 8.91M, False: 2.79k]
  ------------------
 7900|  8.91M|	    loc = GET_SMALLCACHE_BINDING_CELL(vcache, sidx);
  ------------------
  |  | 5771|  8.91M|#  define GET_SMALLCACHE_BINDING_CELL(vcache, sidx) VCACHE(sidx)
  |  |  ------------------
  |  |  |  | 5768|  8.91M|#  define VCACHE(i) GETSTACK_SXPVAL_PTR(vcache + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|  8.91M|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7901|  2.79k|	else {
 7902|  2.79k|	    SEXP symbol = GETCONST(constants, sidx);
  ------------------
  |  | 5550|  2.79k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 7903|  2.79k|	    loc = GET_BINDING_CELL_CACHE(symbol, rho, vcache, sidx);
 7904|  2.79k|	}
 7905|       |
 7906|  8.91M|	R_bcstack_t *s = R_BCNodeStackTop - 1;
 7907|  8.91M|	int tag = s->tag;
 7908|       |
 7909|  8.91M|	if (tag == BNDCELL_TAG_WR(loc))
  ------------------
  |  | 5682|  8.91M|#define BNDCELL_TAG_WR(v) (BINDING_IS_LOCKED(v) ? 0 : BNDCELL_TAG(v))
  |  |  ------------------
  |  |  |  Branch (5682:28): [True: 0, False: 8.91M]
  |  |  ------------------
  ------------------
  |  Branch (7909:6): [True: 8.91M, False: 2.59k]
  ------------------
 7910|  8.91M|	    switch (tag) {
  ------------------
  |  Branch (7910:14): [True: 338, False: 8.91M]
  ------------------
 7911|      0|	    case REALSXP: SET_BNDCELL_DVAL(loc, s->u.dval); NEXT();
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
              	    case REALSXP: SET_BNDCELL_DVAL(loc, s->u.dval); NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
  |  Branch (7911:6): [True: 0, False: 8.91M]
  ------------------
 7912|    336|	    case INTSXP: SET_BNDCELL_IVAL(loc, s->u.ival); NEXT();
  ------------------
  |  |  123|    336|#define INTSXP	    13	  /* integer vectors */
  ------------------
              	    case INTSXP: SET_BNDCELL_IVAL(loc, s->u.ival); NEXT();
  ------------------
  |  | 5655|    336|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
  |  Branch (7912:6): [True: 336, False: 8.91M]
  ------------------
 7913|    338|	    case LGLSXP: SET_BNDCELL_LVAL(loc, s->u.ival); NEXT();
  ------------------
  |  |  121|    338|#define LGLSXP	    10	  /* logical vectors */
  ------------------
              	    case LGLSXP: SET_BNDCELL_LVAL(loc, s->u.ival); NEXT();
  ------------------
  |  | 5655|    338|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
  |  Branch (7913:6): [True: 2, False: 8.91M]
  ------------------
 7914|  8.91M|	    }
 7915|  2.59k|	else if (BNDCELL_WRITABLE(loc))
  ------------------
  |  | 5685|  2.59k|    (v != R_NilValue &&	 ! BINDING_IS_LOCKED(v) && ! IS_ACTIVE_BINDING(v))
  |  |  ------------------
  |  |  |  Branch (5685:6): [True: 39, False: 2.55k]
  |  |  |  Branch (5685:26): [True: 39, False: 0]
  |  |  |  Branch (5685:52): [True: 39, False: 0]
  |  |  ------------------
  ------------------
 7916|     39|	    switch (tag) {
  ------------------
  |  Branch (7916:14): [True: 39, False: 0]
  ------------------
 7917|      1|	    case REALSXP: NEW_BNDCELL_DVAL(loc, s->u.dval); NEXT();
  ------------------
  |  |  124|      1|#define REALSXP	    14	  /* real variables */
  ------------------
              	    case REALSXP: NEW_BNDCELL_DVAL(loc, s->u.dval); NEXT();
  ------------------
  |  | 5655|      1|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
  |  Branch (7917:6): [True: 1, False: 38]
  ------------------
 7918|     35|	    case INTSXP: NEW_BNDCELL_IVAL(loc, s->u.ival); NEXT();
  ------------------
  |  |  123|     35|#define INTSXP	    13	  /* integer vectors */
  ------------------
              	    case INTSXP: NEW_BNDCELL_IVAL(loc, s->u.ival); NEXT();
  ------------------
  |  | 5655|     35|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
  |  Branch (7918:6): [True: 34, False: 5]
  ------------------
 7919|     39|	    case LGLSXP: NEW_BNDCELL_LVAL(loc, s->u.ival); NEXT();
  ------------------
  |  |  121|     39|#define LGLSXP	    10	  /* logical vectors */
  ------------------
              	    case LGLSXP: NEW_BNDCELL_LVAL(loc, s->u.ival); NEXT();
  ------------------
  |  | 5655|     39|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
  |  Branch (7919:6): [True: 4, False: 35]
  ------------------
 7920|     39|	    }
 7921|       |
 7922|  8.91M|	SEXP value = GETSTACK(-1);
  ------------------
  |  | 4903|  8.91M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|  8.91M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 2.55k, False: 8.91M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7923|  8.91M|	INCREMENT_NAMED(value);
  ------------------
  |  |  222|  8.91M|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 8.91M]
  |  |  ------------------
  ------------------
 7924|  8.91M|	if (! SET_BINDING_VALUE(loc, value)) {
  ------------------
  |  Branch (7924:6): [True: 8.90M, False: 6.91k]
  ------------------
 7925|  8.90M|	    SEXP symbol = GETCONST(constants, sidx);
  ------------------
  |  | 5550|  8.90M|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 7926|  8.90M|	    PROTECT(value);
  ------------------
  |  |  357|  8.90M|#define PROTECT(s)	Rf_protect(s)
  ------------------
 7927|  8.90M|	    defineVar(symbol, value, rho);
  ------------------
  |  |  905|  8.90M|#define defineVar		Rf_defineVar
  ------------------
 7928|  8.90M|	    UNPROTECT(1);
  ------------------
  |  |  358|  8.90M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 7929|  8.90M|	}
 7930|  8.91M|	NEXT();
  ------------------
  |  | 5655|  8.91M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7931|  8.91M|      }
 7932|  8.91M|    OP(GETFUN, 1):
  ------------------
  |  | 5638|  8.91M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  8.91M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  8.91M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  8.91M|    goto loop; \
  |  | 5642|  8.91M|    op_##name
  ------------------
 7933|  5.83M|      {
 7934|       |	/* get the function */
 7935|  5.83M|	SEXP symbol = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|  5.83M|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 7936|  5.83M|	SEXP value = findFun(symbol, rho);
  ------------------
  |  |  915|  5.83M|#define findFun			Rf_findFun
  ------------------
 7937|  5.83M|	INIT_CALL_FRAME(value);
  ------------------
  |  | 6039|  5.83M|#define INIT_CALL_FRAME(fun) do { \
  |  | 6040|  5.83M|	BCNPUSH(fun);		\
  |  |  ------------------
  |  |  |  | 5449|  5.83M|#define BCNPUSH(v) do { \
  |  |  |  | 5450|  5.83M|  SEXP __value__ = (v); \
  |  |  |  | 5451|  5.83M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|  5.83M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 5.83M]
  |  |  |  |  ------------------
  |  |  |  | 5453|  5.83M|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  5.83M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  5.83M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  5.83M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  5.83M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 5.83M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  5.83M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  5.83M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  5.83M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  5.83M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 5.83M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|  5.83M|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|  5.83M|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 5.83M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6041|  5.83M|	INIT_CALL_FRAME_ARGS();	\
  |  |  ------------------
  |  |  |  | 6031|  5.83M|#define INIT_CALL_FRAME_ARGS() do { \
  |  |  |  | 6032|  5.83M|	BCNSTACKCHECK(2);	  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5521|  5.83M|#define BCNSTACKCHECK(n)  do {						\
  |  |  |  |  |  | 5522|  5.83M|	if (R_BCNodeStackTop + (n) > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5522:6): [True: 0, False: 5.83M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5523|  5.83M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5523:14): [Folded, False: 5.83M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6033|  5.83M|	SETSTACK(0, R_NilValue);  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  5.83M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  5.83M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  5.83M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  5.83M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 5.83M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  5.83M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  5.83M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  5.83M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  5.83M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 5.83M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6034|  5.83M|	SETSTACK(1, R_NilValue);  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  5.83M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  5.83M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  5.83M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  5.83M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 5.83M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  5.83M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  5.83M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  5.83M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  5.83M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 5.83M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6035|  5.83M|	R_BCNodeStackTop += 2;	  \
  |  |  |  | 6036|  5.83M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6036:14): [Folded, False: 5.83M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6042|  5.83M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6042:14): [Folded, False: 5.83M]
  |  |  ------------------
  ------------------
 7938|  5.83M|	if(RTRACE(value)) {
  ------------------
  |  Branch (7938:5): [True: 0, False: 5.83M]
  ------------------
 7939|      0|	  Rprintf("trace: ");
 7940|      0|	  PrintValue(symbol);
  ------------------
  |  | 1013|      0|#define PrintValue		Rf_PrintValue
  ------------------
 7941|      0|	}
 7942|  5.83M|	NEXT();
  ------------------
  |  | 5655|  5.83M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7943|  5.83M|      }
 7944|  5.83M|    OP(GETGLOBFUN, 1):
  ------------------
  |  | 5638|  5.83M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  5.83M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  5.83M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  5.83M|    goto loop; \
  |  | 5642|  5.83M|    op_##name
  ------------------
 7945|      0|      {
 7946|       |	/* get the function */
 7947|      0|	SEXP symbol = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 7948|      0|	SEXP value = findFun(symbol, R_GlobalEnv);
  ------------------
  |  |  915|      0|#define findFun			Rf_findFun
  ------------------
 7949|      0|	INIT_CALL_FRAME(value);
  ------------------
  |  | 6039|      0|#define INIT_CALL_FRAME(fun) do { \
  |  | 6040|      0|	BCNPUSH(fun);		\
  |  |  ------------------
  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6041|      0|	INIT_CALL_FRAME_ARGS();	\
  |  |  ------------------
  |  |  |  | 6031|      0|#define INIT_CALL_FRAME_ARGS() do { \
  |  |  |  | 6032|      0|	BCNSTACKCHECK(2);	  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5521|      0|#define BCNSTACKCHECK(n)  do {						\
  |  |  |  |  |  | 5522|      0|	if (R_BCNodeStackTop + (n) > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5522:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5523|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5523:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6033|      0|	SETSTACK(0, R_NilValue);  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6034|      0|	SETSTACK(1, R_NilValue);  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6035|      0|	R_BCNodeStackTop += 2;	  \
  |  |  |  | 6036|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6036:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6042|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6042:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 7950|      0|	if(RTRACE(value)) {
  ------------------
  |  Branch (7950:5): [True: 0, False: 0]
  ------------------
 7951|      0|	  Rprintf("trace: ");
 7952|      0|	  PrintValue(symbol);
  ------------------
  |  | 1013|      0|#define PrintValue		Rf_PrintValue
  ------------------
 7953|      0|	}
 7954|      0|	NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7955|      0|      }
 7956|      2|    OP(GETSYMFUN, 1):
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
 7957|      0|      {
 7958|       |	/* get the function */
 7959|      0|	SEXP symbol = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 7960|      0|	SEXP value = SYMVALUE(symbol);
 7961|      0|	if (TYPEOF(value) == PROMSXP) {
  ------------------
  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (7961:6): [True: 0, False: 0]
  ------------------
 7962|      0|	    ENSURE_PROMISE_IS_EVALUATED(value);
  ------------------
  |  |  946|      0|#define ENSURE_PROMISE_IS_EVALUATED(x) do {	\
  |  |  947|      0|	SEXP __x__ = (x);			\
  |  |  948|      0|	if (! PROMISE_IS_EVALUATED(__x__))	\
  |  |  ------------------
  |  |  |  Branch (948:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|	    forcePromise(__x__);		\
  |  |  950|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (950:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 7963|      0|	    value = PRVALUE(value);
 7964|      0|	}
 7965|      0|	if(RTRACE(value)) {
  ------------------
  |  Branch (7965:5): [True: 0, False: 0]
  ------------------
 7966|      0|	  Rprintf("trace: ");
 7967|      0|	  PrintValue(symbol);
  ------------------
  |  | 1013|      0|#define PrintValue		Rf_PrintValue
  ------------------
 7968|      0|	}
 7969|      0|	INIT_CALL_FRAME(value);
  ------------------
  |  | 6039|      0|#define INIT_CALL_FRAME(fun) do { \
  |  | 6040|      0|	BCNPUSH(fun);		\
  |  |  ------------------
  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6041|      0|	INIT_CALL_FRAME_ARGS();	\
  |  |  ------------------
  |  |  |  | 6031|      0|#define INIT_CALL_FRAME_ARGS() do { \
  |  |  |  | 6032|      0|	BCNSTACKCHECK(2);	  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5521|      0|#define BCNSTACKCHECK(n)  do {						\
  |  |  |  |  |  | 5522|      0|	if (R_BCNodeStackTop + (n) > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5522:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5523|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5523:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6033|      0|	SETSTACK(0, R_NilValue);  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6034|      0|	SETSTACK(1, R_NilValue);  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6035|      0|	R_BCNodeStackTop += 2;	  \
  |  |  |  | 6036|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6036:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6042|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6042:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 7970|      0|	NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7971|      0|      }
 7972|  8.13M|    OP(GETBUILTIN, 1):
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|  8.13M|    op_##name
  ------------------
 7973|  8.13M|      {
 7974|       |	/* get the function */
 7975|  8.13M|	SEXP symbol = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|  8.13M|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 7976|  8.13M|	SEXP value = getPrimitive(symbol, BUILTINSXP);
  ------------------
  |  |  119|  8.13M|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
 7977|       |//#define REPORT_OVERRIDEN_BUILTINS
 7978|       |#ifdef REPORT_OVERRIDEN_BUILTINS
 7979|       |	if (value != findFun(symbol, rho)) {
 7980|       |	    Rprintf("Possibly overridden builtin: %s\n", PRIMNAME(value));
 7981|       |	}
 7982|       |#endif
 7983|  8.13M|	if (RTRACE(value)) {
  ------------------
  |  Branch (7983:6): [True: 0, False: 8.13M]
  ------------------
 7984|      0|	  Rprintf("trace: ");
 7985|      0|	  PrintValue(symbol);
  ------------------
  |  | 1013|      0|#define PrintValue		Rf_PrintValue
  ------------------
 7986|      0|	}
 7987|  8.13M|	INIT_CALL_FRAME(value);
  ------------------
  |  | 6039|  8.13M|#define INIT_CALL_FRAME(fun) do { \
  |  | 6040|  8.13M|	BCNPUSH(fun);		\
  |  |  ------------------
  |  |  |  | 5449|  8.13M|#define BCNPUSH(v) do { \
  |  |  |  | 5450|  8.13M|  SEXP __value__ = (v); \
  |  |  |  | 5451|  8.13M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|  8.13M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 8.13M]
  |  |  |  |  ------------------
  |  |  |  | 5453|  8.13M|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  8.13M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  8.13M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  8.13M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  8.13M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 8.13M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  8.13M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  8.13M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  8.13M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  8.13M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 8.13M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|  8.13M|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|  8.13M|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 8.13M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6041|  8.13M|	INIT_CALL_FRAME_ARGS();	\
  |  |  ------------------
  |  |  |  | 6031|  8.13M|#define INIT_CALL_FRAME_ARGS() do { \
  |  |  |  | 6032|  8.13M|	BCNSTACKCHECK(2);	  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5521|  8.13M|#define BCNSTACKCHECK(n)  do {						\
  |  |  |  |  |  | 5522|  8.13M|	if (R_BCNodeStackTop + (n) > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5522:6): [True: 0, False: 8.13M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5523|  8.13M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5523:14): [Folded, False: 8.13M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6033|  8.13M|	SETSTACK(0, R_NilValue);  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  8.13M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  8.13M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  8.13M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  8.13M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 8.13M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  8.13M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  8.13M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  8.13M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  8.13M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 8.13M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6034|  8.13M|	SETSTACK(1, R_NilValue);  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  8.13M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  8.13M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  8.13M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  8.13M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 8.13M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  8.13M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  8.13M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  8.13M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  8.13M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 8.13M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6035|  8.13M|	R_BCNodeStackTop += 2;	  \
  |  |  |  | 6036|  8.13M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6036:14): [Folded, False: 8.13M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6042|  8.13M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6042:14): [Folded, False: 8.13M]
  |  |  ------------------
  ------------------
 7988|  8.13M|	NEXT();
  ------------------
  |  | 5655|  8.13M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 7989|  8.13M|      }
 7990|  8.13M|    OP(GETINTLBUILTIN, 1):
  ------------------
  |  | 5638|  8.13M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  8.13M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  8.13M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  8.13M|    goto loop; \
  |  | 5642|  8.13M|    op_##name
  ------------------
 7991|  2.73M|      {
 7992|       |	/* get the function */
 7993|  2.73M|	SEXP symbol = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|  2.73M|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 7994|  2.73M|	SEXP value = INTERNAL(symbol);
 7995|  2.73M|	if (TYPEOF(value) != BUILTINSXP)
  ------------------
  |  |  119|  2.73M|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (7995:6): [True: 0, False: 2.73M]
  ------------------
 7996|      0|	  error(_("there is no .Internal function '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	  error(_("there is no .Internal function '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 7997|      0|		CHAR(PRINTNAME(symbol)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 7998|  2.73M|	INIT_CALL_FRAME(value);
  ------------------
  |  | 6039|  2.73M|#define INIT_CALL_FRAME(fun) do { \
  |  | 6040|  2.73M|	BCNPUSH(fun);		\
  |  |  ------------------
  |  |  |  | 5449|  2.73M|#define BCNPUSH(v) do { \
  |  |  |  | 5450|  2.73M|  SEXP __value__ = (v); \
  |  |  |  | 5451|  2.73M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|  2.73M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 2.73M]
  |  |  |  |  ------------------
  |  |  |  | 5453|  2.73M|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  2.73M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  2.73M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  2.73M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  2.73M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 2.73M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  2.73M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  2.73M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  2.73M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  2.73M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 2.73M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|  2.73M|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|  2.73M|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 2.73M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6041|  2.73M|	INIT_CALL_FRAME_ARGS();	\
  |  |  ------------------
  |  |  |  | 6031|  2.73M|#define INIT_CALL_FRAME_ARGS() do { \
  |  |  |  | 6032|  2.73M|	BCNSTACKCHECK(2);	  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5521|  2.73M|#define BCNSTACKCHECK(n)  do {						\
  |  |  |  |  |  | 5522|  2.73M|	if (R_BCNodeStackTop + (n) > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5522:6): [True: 0, False: 2.73M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5523|  2.73M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5523:14): [Folded, False: 2.73M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6033|  2.73M|	SETSTACK(0, R_NilValue);  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  2.73M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  2.73M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  2.73M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  2.73M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 2.73M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  2.73M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  2.73M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  2.73M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  2.73M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 2.73M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6034|  2.73M|	SETSTACK(1, R_NilValue);  \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  2.73M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  2.73M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  2.73M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  2.73M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 2.73M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  2.73M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  2.73M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  2.73M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  2.73M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 2.73M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6035|  2.73M|	R_BCNodeStackTop += 2;	  \
  |  |  |  | 6036|  2.73M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6036:14): [Folded, False: 2.73M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6042|  2.73M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6042:14): [Folded, False: 2.73M]
  |  |  ------------------
  ------------------
 7999|  2.73M|	NEXT();
  ------------------
  |  | 5655|  2.73M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8000|  2.73M|      }
 8001|  2.73M|    OP(CHECKFUN, 0):
  ------------------
  |  | 5638|  2.73M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  2.73M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  2.73M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  2.73M|    goto loop; \
  |  | 5642|  2.73M|    op_##name
  ------------------
 8002|  1.41k|      {
 8003|       |	/* check then the value on the stack is a function */
 8004|  1.41k|	SEXP value = GETSTACK(-1);
  ------------------
  |  | 4903|  1.41k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|  1.41k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.41k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8005|  1.41k|	if (TYPEOF(value) != CLOSXP && TYPEOF(value) != BUILTINSXP &&
  ------------------
  |  |  114|  2.82k|#define CLOSXP	     3	  /* closures */
  ------------------
              	if (TYPEOF(value) != CLOSXP && TYPEOF(value) != BUILTINSXP &&
  ------------------
  |  |  119|  1.41k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (8005:6): [True: 0, False: 1.41k]
  |  Branch (8005:33): [True: 0, False: 0]
  ------------------
 8006|      0|	    TYPEOF(value) != SPECIALSXP)
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (8006:6): [True: 0, False: 0]
  ------------------
 8007|      0|	  error(_("attempt to apply non-function"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	  error(_("attempt to apply non-function"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 8008|  1.41k|	INIT_CALL_FRAME_ARGS();
  ------------------
  |  | 6031|  1.41k|#define INIT_CALL_FRAME_ARGS() do { \
  |  | 6032|  1.41k|	BCNSTACKCHECK(2);	  \
  |  |  ------------------
  |  |  |  | 5521|  1.41k|#define BCNSTACKCHECK(n)  do {						\
  |  |  |  | 5522|  1.41k|	if (R_BCNodeStackTop + (n) > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5522:6): [True: 0, False: 1.41k]
  |  |  |  |  ------------------
  |  |  |  | 5523|  1.41k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5523:14): [Folded, False: 1.41k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6033|  1.41k|	SETSTACK(0, R_NilValue);  \
  |  |  ------------------
  |  |  |  | 4905|  1.41k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  1.41k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  1.41k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  1.41k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.41k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  1.41k|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|  1.41k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  1.41k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  1.41k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.41k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6034|  1.41k|	SETSTACK(1, R_NilValue);  \
  |  |  ------------------
  |  |  |  | 4905|  1.41k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  1.41k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  1.41k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  1.41k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.41k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  1.41k|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|  1.41k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  1.41k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  1.41k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.41k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6035|  1.41k|	R_BCNodeStackTop += 2;	  \
  |  | 6036|  1.41k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6036:14): [Folded, False: 1.41k]
  |  |  ------------------
  ------------------
 8009|  1.41k|	NEXT();
  ------------------
  |  | 5655|  1.41k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8010|  1.41k|      }
 8011|  5.07M|    OP(MAKEPROM, 1):
  ------------------
  |  | 5638|  1.41k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.41k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.41k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.41k|    goto loop; \
  |  | 5642|  5.07M|    op_##name
  ------------------
 8012|  5.07M|      {
 8013|  5.07M|	SEXP code = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|  5.07M|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8014|  5.07M|	switch (CALL_FRAME_FTYPE()) {
  ------------------
  |  | 5998|  5.07M|#define CALL_FRAME_FTYPE() TYPEOF(CALL_FRAME_FUN())
  |  |  ------------------
  |  |  |  | 5996|  5.07M|#define CALL_FRAME_FUN() GETSTACK(-3)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|  5.07M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|  5.07M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 5.07M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (5998:28): [True: 5.07M, False: 0]
  |  |  ------------------
  ------------------
 8015|  4.69M|	case CLOSXP:
  ------------------
  |  |  114|  4.69M|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (8015:2): [True: 4.69M, False: 385k]
  ------------------
 8016|  4.69M|	    PUSHCALLARG_RC(mkPROMISE(code, rho));
  ------------------
  |  | 6067|  4.69M|#define PUSHCALLARG_RC PUSHCALLARG
  |  |  ------------------
  |  |  |  | 6063|  4.69M|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  | 6054|  4.69M|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  |  |  | 6055|  4.69M|	SEXP __cell__ =							\
  |  |  |  |  |  | 6056|  4.69M|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6056:6): [Folded, False: 4.69M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6057|  4.69M|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|  4.69M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|  4.69M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 4.69M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|  2.73M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|  2.73M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|  2.73M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|  2.73M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 2.73M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|  2.73M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|  2.73M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|  2.73M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|  2.73M|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 2.73M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6057:6): [True: 2.73M, False: 1.95M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6058|  4.69M|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|  1.95M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|  1.95M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.95M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6059|  4.69M|	SETSTACK(-1, __cell__);						\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|  4.69M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|  4.69M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|  4.69M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|  4.69M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 4.69M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|  4.69M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|  4.69M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|  4.69M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|  4.69M|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 4.69M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6060|  4.69M|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6060:6): [Folded, False: 4.69M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6061|  4.69M|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  540|  4.69M|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  |  |  541|  4.69M|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  |  |  542|  4.69M|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  222|  4.69M|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 4.69M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  543|  4.69M|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  |  |  544|  4.69M|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 4.69M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6062|  4.69M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6062:14): [Folded, False: 4.69M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8017|  4.69M|	    break;
 8018|   385k|	case BUILTINSXP:
  ------------------
  |  |  119|   385k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (8018:2): [True: 385k, False: 4.69M]
  ------------------
 8019|   385k|	    if (TYPEOF(code) == BCODESXP)
  ------------------
  |  |  133|   385k|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (8019:10): [True: 385k, False: 0]
  ------------------
 8020|   385k|		PUSHCALLARG(bcEval(code, rho));
  ------------------
  |  | 6063|   385k|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  ------------------
  |  |  |  | 6054|   385k|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  | 6055|   385k|	SEXP __cell__ =							\
  |  |  |  | 6056|   385k|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6056:6): [Folded, False: 385k]
  |  |  |  |  ------------------
  |  |  |  | 6057|   385k|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|   385k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|   385k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 385k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|   385k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|   385k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|   385k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|   385k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 385k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|   385k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|   385k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|   385k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|   385k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 385k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6057:6): [True: 385k, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6058|   385k|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6059|   385k|	SETSTACK(-1, __cell__);						\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|   385k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|   385k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|   385k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|   385k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 385k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|   385k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|   385k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|   385k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|   385k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 385k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6060|   385k|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6060:6): [Folded, False: 385k]
  |  |  |  |  ------------------
  |  |  |  | 6061|   385k|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  540|   385k|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  541|   385k|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  542|   385k|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|   385k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 385k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  543|   385k|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  544|   385k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 385k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6062|   385k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6062:14): [Folded, False: 385k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8021|      0|	    else
 8022|       |		/* uncommon but possible, the compiler may decide not
 8023|       |		   to compile an argument expression */
 8024|   385k|		PUSHCALLARG(eval(code, rho));
  ------------------
  |  | 6063|      0|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  ------------------
  |  |  |  | 6054|      0|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  | 6055|      0|	SEXP __cell__ =							\
  |  |  |  | 6056|      0|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6056:6): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6057|      0|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6057:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6058|      0|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6059|      0|	SETSTACK(-1, __cell__);						\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6060|      0|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6060:6): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6061|      0|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  540|      0|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  541|      0|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  542|      0|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  543|      0|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  544|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6062|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6062:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8025|   385k|	    break;
 8026|    148|	case SPECIALSXP: break;
  ------------------
  |  |  118|    148|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (8026:2): [True: 148, False: 5.07M]
  ------------------
 8027|  5.07M|	}
 8028|  5.07M|	NEXT();
  ------------------
  |  | 5655|  5.07M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8029|  5.07M|      }
 8030|  5.07M|    OP(DOMISSING, 0):
  ------------------
  |  | 5638|  5.07M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  5.07M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  5.07M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  5.07M|    goto loop; \
  |  | 5642|  5.07M|    op_##name
  ------------------
 8031|    114|      {
 8032|    114|	SEXPTYPE ftype = CALL_FRAME_FTYPE();
  ------------------
  |  | 5998|    114|#define CALL_FRAME_FTYPE() TYPEOF(CALL_FRAME_FUN())
  |  |  ------------------
  |  |  |  | 5996|    114|#define CALL_FRAME_FUN() GETSTACK(-3)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|    114|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|    114|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 114]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8033|    114|	if (ftype != SPECIALSXP)
  ------------------
  |  |  118|    114|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (8033:6): [True: 114, False: 0]
  ------------------
 8034|    114|	  PUSHCALLARG(R_MissingArg);
  ------------------
  |  | 6063|    114|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  ------------------
  |  |  |  | 6054|    114|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  | 6055|    114|	SEXP __cell__ =							\
  |  |  |  | 6056|    114|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6056:6): [Folded, False: 114]
  |  |  |  |  ------------------
  |  |  |  | 6057|    114|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|    114|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|    114|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 114]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6057:6): [True: 0, False: 114]
  |  |  |  |  ------------------
  |  |  |  | 6058|    114|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|    114|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|    114|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 114]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6059|    114|	SETSTACK(-1, __cell__);						\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|    114|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|    114|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|    114|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|    114|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 114]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|    114|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|    114|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|    114|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|    114|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 114]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6060|    114|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6060:6): [Folded, False: 114]
  |  |  |  |  ------------------
  |  |  |  | 6061|    114|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  540|    114|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  541|    114|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  542|    114|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|    114|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 114]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  543|    114|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  544|    114|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 114]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6062|    114|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6062:14): [Folded, False: 114]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8035|    114|	NEXT();
  ------------------
  |  | 5655|    114|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8036|    114|      }
 8037|  5.40M|    OP(SETTAG, 1):
  ------------------
  |  | 5638|    116|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    116|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    116|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    116|    goto loop; \
  |  | 5642|  5.40M|    op_##name
  ------------------
 8038|  5.40M|      {
 8039|  5.40M|	SEXPTYPE ftype = CALL_FRAME_FTYPE();
  ------------------
  |  | 5998|  5.40M|#define CALL_FRAME_FTYPE() TYPEOF(CALL_FRAME_FUN())
  |  |  ------------------
  |  |  |  | 5996|  5.40M|#define CALL_FRAME_FUN() GETSTACK(-3)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|  5.40M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|  5.40M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 5.40M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8040|  5.40M|	int tagidx = GETOP();
  ------------------
  |  | 5656|  5.40M|#define GETOP() (*pc++).i
  ------------------
 8041|  5.40M|	if (ftype != SPECIALSXP) {
  ------------------
  |  |  118|  5.40M|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (8041:6): [True: 5.40M, False: 0]
  ------------------
 8042|  5.40M|	    SEXP tag = GETCONST(constants, tagidx);
  ------------------
  |  | 5550|  5.40M|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8043|  5.40M|	    SETCALLARG_TAG(tag);
  ------------------
  |  | 6071|  5.40M|#define SETCALLARG_TAG(t) do {			\
  |  | 6072|  5.40M|	SEXP __tag__ = (t);			\
  |  | 6073|  5.40M|	if (__tag__ != R_NilValue) {		\
  |  |  ------------------
  |  |  |  Branch (6073:6): [True: 5.40M, False: 0]
  |  |  ------------------
  |  | 6074|  5.40M|	    SEXP __cell__ = GETSTACK(-1);	\
  |  |  ------------------
  |  |  |  | 4903|  5.40M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|  5.40M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 5.40M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6075|  5.40M|	    if (__cell__ != R_NilValue)		   \
  |  |  ------------------
  |  |  |  Branch (6075:10): [True: 5.40M, False: 0]
  |  |  ------------------
  |  | 6076|  5.40M|		SET_TAG(__cell__, CreateTag(__tag__));	\
  |  |  ------------------
  |  |  |  |  904|  5.40M|#define CreateTag		Rf_CreateTag
  |  |  ------------------
  |  | 6077|  5.40M|	}						\
  |  | 6078|  5.40M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6078:14): [Folded, False: 5.40M]
  |  |  ------------------
  ------------------
 8044|  5.40M|	}
 8045|  5.40M|	NEXT();
  ------------------
  |  | 5655|  5.40M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8046|  5.40M|      }
 8047|  5.40M|    OP(DODOTS, 0):
  ------------------
  |  | 5638|  5.40M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  5.40M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  5.40M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  5.40M|    goto loop; \
  |  | 5642|  5.40M|    op_##name
  ------------------
 8048|  1.54M|      {
 8049|  1.54M|	SEXPTYPE ftype = CALL_FRAME_FTYPE();
  ------------------
  |  | 5998|  1.54M|#define CALL_FRAME_FTYPE() TYPEOF(CALL_FRAME_FUN())
  |  |  ------------------
  |  |  |  | 5996|  1.54M|#define CALL_FRAME_FUN() GETSTACK(-3)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|  1.54M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|  1.54M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.54M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8050|  1.54M|	if (ftype != SPECIALSXP) {
  ------------------
  |  |  118|  1.54M|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (8050:6): [True: 1.54M, False: 0]
  ------------------
 8051|  1.54M|	  SEXP h = R_findVar(R_DotsSymbol, rho);
 8052|  1.54M|	  if (TYPEOF(h) == DOTSXP || h == R_NilValue) {
  ------------------
  |  |  127|  3.09M|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (8052:8): [True: 1.54M, False: 1.16k]
  |  Branch (8052:31): [True: 0, False: 1.16k]
  ------------------
 8053|  1.54M|	    PROTECT(h);
  ------------------
  |  |  357|  1.54M|#define PROTECT(s)	Rf_protect(s)
  ------------------
 8054|  3.09M|	    for (; h != R_NilValue; h = CDR(h)) {
  ------------------
  |  Branch (8054:13): [True: 1.54M, False: 1.54M]
  ------------------
 8055|  1.54M|	      SEXP val;
 8056|  1.54M|	      if (ftype == BUILTINSXP)
  ------------------
  |  |  119|  1.54M|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (8056:12): [True: 1.16M, False: 385k]
  ------------------
 8057|  1.16M|	        val = eval(CAR(h), rho);
  ------------------
  |  |  913|  1.16M|#define eval			Rf_eval
  ------------------
 8058|   385k|	      else if (CAR(h) == R_MissingArg)
  ------------------
  |  Branch (8058:17): [True: 0, False: 385k]
  ------------------
 8059|      0|	        val = CAR(h);
 8060|   385k|	      else
 8061|   385k|	        val = mkPROMISE(CAR(h), rho);
  ------------------
  |  | 1957|   385k|# define mkPROMISE		Rf_mkPROMISE
  ------------------
 8062|  1.54M|	      PUSHCALLARG(val);
  ------------------
  |  | 6063|  1.54M|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  ------------------
  |  |  |  | 6054|  1.54M|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  | 6055|  1.54M|	SEXP __cell__ =							\
  |  |  |  | 6056|  1.54M|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6056:6): [Folded, False: 1.54M]
  |  |  |  |  ------------------
  |  |  |  | 6057|  1.54M|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|  1.54M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|  1.54M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.54M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  1.54M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  1.54M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  1.54M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  1.54M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.54M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  1.54M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  1.54M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  1.54M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  1.54M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.54M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6057:6): [True: 1.54M, False: 2.20k]
  |  |  |  |  ------------------
  |  |  |  | 6058|  1.54M|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|  2.20k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|  2.20k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 2.20k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6059|  1.54M|	SETSTACK(-1, __cell__);						\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  1.54M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  1.54M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  1.54M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  1.54M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.54M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  1.54M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  1.54M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  1.54M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  1.54M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.54M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6060|  1.54M|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6060:6): [Folded, False: 1.54M]
  |  |  |  |  ------------------
  |  |  |  | 6061|  1.54M|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  540|  1.54M|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  541|  1.54M|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  542|  1.54M|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|  1.54M|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 1.54M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  543|  1.54M|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  544|  1.54M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 1.54M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6062|  1.54M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6062:14): [Folded, False: 1.54M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8063|  1.54M|	      SETCALLARG_TAG(TAG(h));
  ------------------
  |  | 6071|  1.54M|#define SETCALLARG_TAG(t) do {			\
  |  | 6072|  1.54M|	SEXP __tag__ = (t);			\
  |  | 6073|  1.54M|	if (__tag__ != R_NilValue) {		\
  |  |  ------------------
  |  |  |  Branch (6073:6): [True: 1.54M, False: 3.71k]
  |  |  ------------------
  |  | 6074|  1.54M|	    SEXP __cell__ = GETSTACK(-1);	\
  |  |  ------------------
  |  |  |  | 4903|  1.54M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|  1.54M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.54M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6075|  1.54M|	    if (__cell__ != R_NilValue)		   \
  |  |  ------------------
  |  |  |  Branch (6075:10): [True: 1.54M, False: 0]
  |  |  ------------------
  |  | 6076|  1.54M|		SET_TAG(__cell__, CreateTag(__tag__));	\
  |  |  ------------------
  |  |  |  |  904|  1.54M|#define CreateTag		Rf_CreateTag
  |  |  ------------------
  |  | 6077|  1.54M|	}						\
  |  | 6078|  1.54M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6078:14): [Folded, False: 1.54M]
  |  |  ------------------
  ------------------
 8064|  1.54M|	    }
 8065|  1.54M|	    UNPROTECT(1); /* h */
  ------------------
  |  |  358|  1.54M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 8066|  1.54M|	  }
 8067|  1.16k|	  else if (h != R_MissingArg)
  ------------------
  |  Branch (8067:13): [True: 0, False: 1.16k]
  ------------------
 8068|      0|	    error(_("'...' used in an incorrect context"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("'...' used in an incorrect context"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 8069|  1.54M|	}
 8070|  1.54M|	NEXT();
  ------------------
  |  | 5655|  1.54M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8071|  1.54M|      }
 8072|  15.5M|    OP(PUSHARG, 0): PUSHCALLARG(BCNPOP()); NEXT();
  ------------------
  |  | 5638|  1.54M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.54M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.54M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.54M|    goto loop; \
  |  | 5642|  15.5M|    op_##name
  ------------------
                  OP(PUSHARG, 0): PUSHCALLARG(BCNPOP()); NEXT();
  ------------------
  |  | 6063|  15.5M|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  ------------------
  |  |  |  | 6054|  15.5M|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  | 6055|  15.5M|	SEXP __cell__ =							\
  |  |  |  | 6056|  31.0M|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (309:29): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6056:6): [Folded, False: 15.5M]
  |  |  |  |  |  Branch (6056:43): [True: 2.52k, False: 15.5M]
  |  |  |  |  ------------------
  |  |  |  | 6057|  15.5M|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|  15.5M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|  15.5M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 15.5M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  10.4M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  10.4M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  10.4M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  10.4M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 10.4M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  10.4M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  10.4M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  10.4M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  10.4M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 10.4M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6057:6): [True: 10.4M, False: 5.06M]
  |  |  |  |  ------------------
  |  |  |  | 6058|  15.5M|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|  5.06M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|  5.06M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 5.06M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6059|  15.5M|	SETSTACK(-1, __cell__);						\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  15.5M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  15.5M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  15.5M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  15.5M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 15.5M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  15.5M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  15.5M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  15.5M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  15.5M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 15.5M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6060|  15.5M|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6060:6): [Folded, False: 15.5M]
  |  |  |  |  ------------------
  |  |  |  | 6061|  15.5M|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  540|  15.5M|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  541|  15.5M|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  542|  15.5M|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|  15.5M|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 15.5M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  543|  15.5M|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  544|  15.5M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 15.5M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6062|  15.5M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6062:14): [Folded, False: 15.5M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                  OP(PUSHARG, 0): PUSHCALLARG(BCNPOP()); NEXT();
  ------------------
  |  | 5655|  15.5M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8073|  15.5M|    OP(PUSHCONSTARG, 1):
  ------------------
  |  | 5638|  15.5M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  15.5M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  15.5M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  15.5M|    goto loop; \
  |  | 5642|  15.5M|    op_##name
  ------------------
 8074|  2.33M|      {
 8075|  2.33M|	SEXP value = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|  2.33M|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8076|  2.33M|	if (R_check_constants < 0)
  ------------------
  |  Branch (8076:6): [True: 0, False: 2.33M]
  ------------------
 8077|      0|	    value = duplicate(value);
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 8078|  2.33M|	MARK_NOT_MUTABLE(value);
 8079|  2.33M|	PUSHCALLARG(value);
  ------------------
  |  | 6063|  2.33M|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  ------------------
  |  |  |  | 6054|  2.33M|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  | 6055|  2.33M|	SEXP __cell__ =							\
  |  |  |  | 6056|  2.33M|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6056:6): [Folded, False: 2.33M]
  |  |  |  |  ------------------
  |  |  |  | 6057|  2.33M|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|  2.33M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|  2.33M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 2.33M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|   390k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|   390k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|   390k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|   390k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 390k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|   390k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|   390k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|   390k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|   390k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 390k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6057:6): [True: 390k, False: 1.94M]
  |  |  |  |  ------------------
  |  |  |  | 6058|  2.33M|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|  1.94M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|  1.94M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.94M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6059|  2.33M|	SETSTACK(-1, __cell__);						\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  2.33M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  2.33M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  2.33M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  2.33M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 2.33M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  2.33M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  2.33M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  2.33M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  2.33M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 2.33M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6060|  2.33M|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6060:6): [Folded, False: 2.33M]
  |  |  |  |  ------------------
  |  |  |  | 6061|  2.33M|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  540|  2.33M|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  541|  2.33M|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  542|  2.33M|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|  2.33M|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 2.33M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  543|  2.33M|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  544|  2.33M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 2.33M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6062|  2.33M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6062:14): [Folded, False: 2.33M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8080|  2.33M|	NEXT();
  ------------------
  |  | 5655|  2.33M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8081|  2.33M|      }
 8082|  2.33M|    OP(PUSHNULLARG, 0): PUSHCALLARG(R_NilValue); NEXT();
  ------------------
  |  | 5638|  2.33M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  2.33M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  2.33M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  2.33M|    goto loop; \
  |  | 5642|  2.33M|    op_##name
  ------------------
                  OP(PUSHNULLARG, 0): PUSHCALLARG(R_NilValue); NEXT();
  ------------------
  |  | 6063|  1.93M|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  ------------------
  |  |  |  | 6054|  1.93M|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  | 6055|  1.93M|	SEXP __cell__ =							\
  |  |  |  | 6056|  1.93M|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6056:6): [Folded, False: 1.93M]
  |  |  |  |  ------------------
  |  |  |  | 6057|  1.93M|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|  1.93M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|  1.93M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.93M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|   771k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|   771k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|   771k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|   771k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 771k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|   771k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|   771k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|   771k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|   771k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 771k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6057:6): [True: 771k, False: 1.15M]
  |  |  |  |  ------------------
  |  |  |  | 6058|  1.93M|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|  1.15M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|  1.15M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.15M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6059|  1.93M|	SETSTACK(-1, __cell__);						\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  1.93M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  1.93M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  1.93M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  1.93M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.93M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  1.93M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  1.93M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  1.93M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  1.93M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.93M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6060|  1.93M|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6060:6): [Folded, False: 1.93M]
  |  |  |  |  ------------------
  |  |  |  | 6061|  1.93M|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  540|  1.93M|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  541|  1.93M|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  542|  1.93M|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|  1.93M|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 1.93M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  543|  1.93M|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  544|  1.93M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 1.93M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6062|  1.93M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6062:14): [Folded, False: 1.93M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                  OP(PUSHNULLARG, 0): PUSHCALLARG(R_NilValue); NEXT();
  ------------------
  |  | 5655|  1.93M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8083|  1.93M|    OP(PUSHTRUEARG, 0): PUSHCALLARG(R_TrueValue); NEXT();
  ------------------
  |  | 5638|  1.93M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.93M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.93M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.93M|    goto loop; \
  |  | 5642|  1.93M|    op_##name
  ------------------
                  OP(PUSHTRUEARG, 0): PUSHCALLARG(R_TrueValue); NEXT();
  ------------------
  |  | 6063|   779k|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  ------------------
  |  |  |  | 6054|   779k|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  | 6055|   779k|	SEXP __cell__ =							\
  |  |  |  | 6056|   779k|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6056:6): [Folded, False: 779k]
  |  |  |  |  ------------------
  |  |  |  | 6057|   779k|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|   779k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|   779k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 779k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|    653|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|    653|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|    653|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|    653|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 653]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|    653|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|    653|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|    653|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|    653|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 653]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6057:6): [True: 653, False: 778k]
  |  |  |  |  ------------------
  |  |  |  | 6058|   779k|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|   778k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|   778k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 778k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6059|   779k|	SETSTACK(-1, __cell__);						\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|   779k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|   779k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|   779k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|   779k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 779k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|   779k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|   779k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|   779k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|   779k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 779k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6060|   779k|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6060:6): [Folded, False: 779k]
  |  |  |  |  ------------------
  |  |  |  | 6061|   779k|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  540|   779k|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  541|   779k|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  542|   779k|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|   779k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 779k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  543|   779k|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  544|   779k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 779k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6062|   779k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6062:14): [Folded, False: 779k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                  OP(PUSHTRUEARG, 0): PUSHCALLARG(R_TrueValue); NEXT();
  ------------------
  |  | 5655|   779k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8084|   779k|    OP(PUSHFALSEARG, 0): PUSHCALLARG(R_FalseValue); NEXT();
  ------------------
  |  | 5638|   779k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   779k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   779k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   779k|    goto loop; \
  |  | 5642|   779k|    op_##name
  ------------------
                  OP(PUSHFALSEARG, 0): PUSHCALLARG(R_FalseValue); NEXT();
  ------------------
  |  | 6063|  7.95k|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  ------------------
  |  |  |  | 6054|  7.95k|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  | 6055|  7.95k|	SEXP __cell__ =							\
  |  |  |  | 6056|  7.95k|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6056:6): [Folded, False: 7.95k]
  |  |  |  |  ------------------
  |  |  |  | 6057|  7.95k|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|  7.95k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|  7.95k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 7.95k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      4|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      4|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      4|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      4|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 4]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      4|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      4|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      4|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      4|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 4]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6057:6): [True: 4, False: 7.95k]
  |  |  |  |  ------------------
  |  |  |  | 6058|  7.95k|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|  7.95k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|  7.95k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 7.95k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6059|  7.95k|	SETSTACK(-1, __cell__);						\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  7.95k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  7.95k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  7.95k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  7.95k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 7.95k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  7.95k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  7.95k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  7.95k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  7.95k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 7.95k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6060|  7.95k|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6060:6): [Folded, False: 7.95k]
  |  |  |  |  ------------------
  |  |  |  | 6061|  7.95k|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  540|  7.95k|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  541|  7.95k|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  542|  7.95k|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|  7.95k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 7.95k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  543|  7.95k|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  544|  7.95k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 7.95k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6062|  7.95k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6062:14): [Folded, False: 7.95k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                  OP(PUSHFALSEARG, 0): PUSHCALLARG(R_FalseValue); NEXT();
  ------------------
  |  | 5655|  7.95k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8085|  5.06M|    OP(CALL, 1):
  ------------------
  |  | 5638|  7.95k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  7.95k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  7.95k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  7.95k|    goto loop; \
  |  | 5642|  5.06M|    op_##name
  ------------------
 8086|  5.06M|      {
 8087|  5.06M|	SEXP fun = CALL_FRAME_FUN();
  ------------------
  |  | 5996|  5.06M|#define CALL_FRAME_FUN() GETSTACK(-3)
  |  |  ------------------
  |  |  |  | 4903|  5.06M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|  5.06M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 5.06M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8088|  5.06M|	SEXP call = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|  5.06M|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8089|  5.06M|	SEXP args;
 8090|  5.06M|	SEXP value = NULL;
 8091|  5.06M|	int flag;
 8092|  5.06M|	switch (TYPEOF(fun)) {
 8093|  1.54M|	case BUILTINSXP:
  ------------------
  |  |  119|  1.54M|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (8093:2): [True: 1.54M, False: 3.51M]
  ------------------
 8094|  1.54M|	  args = BUILTIN_CALL_FRAME_ARGS();
 8095|  1.54M|	  checkForMissings(args, call);
 8096|  1.54M|	  flag = PRIMPRINT(fun);
  ------------------
  |  | 1350|  1.54M|#define PRIMPRINT(x)	(((R_FunTab[PRIMOFFSET(x)].eval)/100)%10)
  |  |  ------------------
  |  |  |  |  913|  1.54M|#define eval			Rf_eval
  |  |  ------------------
  ------------------
 8097|  1.54M|	  R_Visible = flag != 1;
 8098|  1.54M|	  value = PRIMFUN(fun) (call, fun, args, rho);
  ------------------
  |  | 1345|  1.54M|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 8099|  1.54M|	  if (flag < 2) R_Visible = flag != 1;
  ------------------
  |  Branch (8099:8): [True: 1.54M, False: 0]
  ------------------
 8100|  1.54M|	  break;
 8101|  1.11k|	case SPECIALSXP:
  ------------------
  |  |  118|  1.11k|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (8101:2): [True: 1.11k, False: 5.06M]
  ------------------
 8102|  1.11k|	  flag = PRIMPRINT(fun);
  ------------------
  |  | 1350|  1.11k|#define PRIMPRINT(x)	(((R_FunTab[PRIMOFFSET(x)].eval)/100)%10)
  |  |  ------------------
  |  |  |  |  913|  1.11k|#define eval			Rf_eval
  |  |  ------------------
  ------------------
 8103|  1.11k|	  R_Visible = flag != 1;
 8104|  1.11k|	  value = PRIMFUN(fun) (call, fun, markSpecialArgs(CDR(call)), rho);
  ------------------
  |  | 1345|  1.11k|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 8105|  1.11k|	  if (flag < 2) R_Visible = flag != 1;
  ------------------
  |  Branch (8105:8): [True: 0, False: 1.11k]
  ------------------
 8106|  1.11k|	  break;
 8107|  3.51M|	case CLOSXP:
  ------------------
  |  |  114|  3.51M|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (8107:2): [True: 3.51M, False: 1.54M]
  ------------------
 8108|  3.51M|	  args = CLOSURE_CALL_FRAME_ARGS();
 8109|  3.51M|	  if (INLINE_CLOSURE_CALL_OK(fun)) {
  ------------------
  |  | 7524|  3.51M|    (! R_disable_bytecode && TYPEOF(BODY(fun)) == BCODESXP &&	\
  |  |  ------------------
  |  |  |  |  133|  7.02M|#define BCODESXP    21    /* byte code */
  |  |  ------------------
  |  |  |  Branch (7524:6): [True: 3.51M, False: 0]
  |  |  |  Branch (7524:30): [True: 3.51M, False: 12]
  |  |  ------------------
  |  | 7525|  3.51M|     R_BCVersionOK(BODY(fun)) && ! RDEBUG(fun) &&		\
  |  |  ------------------
  |  |  |  Branch (7525:6): [True: 3.51M, False: 0]
  |  |  |  Branch (7525:34): [True: 3.51M, False: 0]
  |  |  ------------------
  |  | 7526|  3.51M|     ! RSTEP(fun) && ! RDEBUG(rho) &&				\
  |  |  ------------------
  |  |  |  Branch (7526:6): [True: 3.51M, False: 0]
  |  |  |  Branch (7526:22): [True: 3.51M, False: 0]
  |  |  ------------------
  |  | 7527|  3.51M|     R_GlobalContext->callflag != CTXT_GENERIC)
  |  |  ------------------
  |  |  |  Branch (7527:6): [True: 3.51M, False: 0]
  |  |  ------------------
  ------------------
 8110|  3.51M|	      START_BCFRAME_CALL();
  ------------------
  |  | 7434|  3.51M|#define START_BCFRAME_CALL() do {				\
  |  | 7435|  3.51M|	BC_CHECK_SIGINT();					\
  |  |  ------------------
  |  |  |  | 6281|  3.51M|#define BC_CHECK_SIGINT() do {			\
  |  |  |  | 6282|  3.51M|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   45|  3.51M|#define BC_COUNT_DELTA 127
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6282:6): [True: 145, False: 3.51M]
  |  |  |  |  ------------------
  |  |  |  | 6283|    145|	    bc_check_sigint();			\
  |  |  |  | 6284|    145|	    evalcount = 0;			\
  |  |  |  | 6285|    145|	}					\
  |  |  |  | 6286|  3.51M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6286:14): [Folded, False: 3.51M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 7436|  3.51M|	struct bcEval_locals locals =				\
  |  | 7437|  3.51M|	    setup_bcframe_call(call, fun, args, rho);		\
  |  | 7438|  3.51M|	SAVE_BCEVAL_LOCALS(BCFRAME_LOCALS());			\
  |  |  ------------------
  |  |  |  | 7267|  3.51M|#define SAVE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  | 7268|  3.51M|	(loc)->body = body;			\
  |  |  |  | 7269|  3.51M|	(loc)->rho = rho;			\
  |  |  |  | 7270|  3.51M|	(loc)->vcache = vcache;			\
  |  |  |  | 7271|  3.51M|	(loc)->smallcache = smallcache;		\
  |  |  |  | 7272|  3.51M|	(loc)->pc = pc;				\
  |  |  |  | 7273|  3.51M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (7273:14): [Folded, False: 3.51M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 7439|  3.51M|	RESTORE_BCEVAL_LOCALS(&locals);				\
  |  |  ------------------
  |  |  |  | 7275|  3.51M|#define RESTORE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  | 7276|  3.51M|	body = (loc)->body;			\
  |  |  |  | 7277|  3.51M|	codebase = BCCODE(body);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5659|  3.51M|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  736|  3.51M|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7278|  3.51M|	constants = BCCONSTS(body);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5548|  3.51M|    (R_bcconsts_t) {((SEXP const *) DATAPTR_RO(BCODE_CONSTS(e)))}
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  737|  3.51M|#define BCODE_CONSTS(x) CDR(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7279|  3.51M|	rho = (loc)->rho;			\
  |  |  |  | 7280|  3.51M|	vcache = (loc)->vcache;			\
  |  |  |  | 7281|  3.51M|	smallcache = (loc)->smallcache;		\
  |  |  |  | 7282|  3.51M|	pc = (loc)->pc;				\
  |  |  |  | 7283|  3.51M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (7283:14): [Folded, False: 3.51M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 7440|  3.51M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (7440:14): [Folded, False: 3.51M]
  |  |  ------------------
  ------------------
 8111|  3.51M|	      volatile SEXP vbody = body; // keep gcc -Wclobbered happy
 8112|  3.51M|	      if (SETJMP(BCFRAME_CNTXT()->cjmpbuf)) {
  ------------------
  |  | 1162|  3.51M|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (8112:12): [True: 386k, False: 3.12M]
  ------------------
 8113|   386k|		  RCNTXT *pcntxt = BCFRAME_CNTXT();
  ------------------
  |  | 7333|   386k|#define BCFRAME_CNTXT() (R_BCFrame->pcntxt)
  ------------------
 8114|   386k|		  if (! pcntxt->jumptarget) {
  ------------------
  |  Branch (8114:9): [True: 386k, False: 0]
  ------------------
 8115|       |		      /* ignores intermediate jumps for on.exits */
 8116|   386k|		      pcntxt->returnValue =
 8117|   386k|			  SEXP_TO_STACKVAL(R_ReturnedValue);
  ------------------
  |  | 2598|   386k|#define SEXP_TO_STACKVAL(x) ((R_bcstack_t) { .tag = 0, .u.sxpval = (x) })
  ------------------
 8118|   386k|		  }
 8119|      0|		  else
 8120|       |		      /* might be better so use something less
 8121|       |			 segfault-prone than NULL here and elsewhere */
 8122|      0|		      pcntxt->returnValue =
 8123|      0|			  SEXP_TO_STACKVAL(NULL); /* undefined */
  ------------------
  |  | 2598|      0|#define SEXP_TO_STACKVAL(x) ((R_bcstack_t) { .tag = 0, .u.sxpval = (x) })
  ------------------
 8124|       |		  /* do NOT put on the stack -- it might be a NULL pointer */
 8125|   386k|		  DO_INLINE_CLOSURE_CALL_RETURN();
  ------------------
  |  | 7480|   386k|#define DO_INLINE_CLOSURE_CALL_RETURN() do {			\
  |  | 7481|   386k|	RESTORE_BCEVAL_LOCALS(BCFRAME_LOCALS());		\
  |  |  ------------------
  |  |  |  | 7275|   386k|#define RESTORE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  | 7276|   386k|	body = (loc)->body;			\
  |  |  |  | 7277|   386k|	codebase = BCCODE(body);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5659|   386k|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  736|   386k|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7278|   386k|	constants = BCCONSTS(body);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5548|   386k|    (R_bcconsts_t) {((SEXP const *) DATAPTR_RO(BCODE_CONSTS(e)))}
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  737|   386k|#define BCODE_CONSTS(x) CDR(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7279|   386k|	rho = (loc)->rho;			\
  |  |  |  | 7280|   386k|	vcache = (loc)->vcache;			\
  |  |  |  | 7281|   386k|	smallcache = (loc)->smallcache;		\
  |  |  |  | 7282|   386k|	pc = (loc)->pc;				\
  |  |  |  | 7283|   386k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (7283:14): [Folded, False: 386k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 7482|   386k|	finish_inline_closure_call();				\
  |  | 7483|   386k|	NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|   386k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 7484|   386k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (7484:14): [Folded, False: 386k]
  |  |  ------------------
  ------------------
 8126|   386k|	      }
 8127|  3.12M|	      else {
 8128|  3.12M|		  body = vbody; // keep gcc -Wclobbered happy
 8129|  3.12M|		  NEXT();
  ------------------
  |  | 5655|  3.12M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8130|       |		  /* return cleanup is in DO_INLINE_CLOSURE_CALL_RETURN */
 8131|  3.12M|	      }
 8132|  3.51M|	  }
 8133|     12|	  else
 8134|     12|	      value = applyClosure(call, fun, args, rho, R_NilValue, TRUE);
  ------------------
  |  |  879|     12|#define applyClosure		Rf_applyClosure
  ------------------
 8135|  3.51M|	  break;
 8136|      0|	default: error(_("bad function"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	default: error(_("bad function"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (8136:2): [True: 0, False: 5.06M]
  ------------------
 8137|  5.06M|	}
 8138|  1.54M|	POP_CALL_FRAME(value);
  ------------------
  |  | 6045|  1.54M|#define POP_CALL_FRAME(value) POP_CALL_FRAME_PLUS(0, value)
  |  |  ------------------
  |  |  |  | 6047|  1.54M|#define POP_CALL_FRAME_PLUS(n, value) do {	\
  |  |  |  | 6048|  1.54M|	R_BCNodeStackTop -= (2 + (n));		\
  |  |  |  | 6049|  1.54M|	SETSTACK(-1, value);			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  1.54M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  1.54M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  1.54M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  1.54M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.54M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  1.54M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  1.54M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  1.54M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  1.54M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.54M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6050|  1.54M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6050:14): [Folded, False: 1.54M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8139|  1.54M|	NEXT();
  ------------------
  |  | 5655|  1.54M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8140|  1.54M|      }
 8141|  10.8M|    OP(CALLBUILTIN, 1):
  ------------------
  |  | 5638|  1.54M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.54M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.54M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.54M|    goto loop; \
  |  | 5642|  10.8M|    op_##name
  ------------------
 8142|  10.8M|      {
 8143|  10.8M|	SEXP fun = CALL_FRAME_FUN();
  ------------------
  |  | 5996|  10.8M|#define CALL_FRAME_FUN() GETSTACK(-3)
  |  |  ------------------
  |  |  |  | 4903|  10.8M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|  10.8M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 10.8M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8144|  10.8M|	SEXP call = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|  10.8M|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8145|  10.8M|	SEXP args = BUILTIN_CALL_FRAME_ARGS();
 8146|  10.8M|	int flag;
 8147|  10.8M|	const void *vmax = vmaxget();
 8148|  10.8M|	if (TYPEOF(fun) != BUILTINSXP)
  ------------------
  |  |  119|  10.8M|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (8148:6): [True: 0, False: 10.8M]
  ------------------
 8149|      0|	  error(_("not a BUILTIN function"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	  error(_("not a BUILTIN function"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 8150|  10.8M|	flag = PRIMPRINT(fun);
  ------------------
  |  | 1350|  10.8M|#define PRIMPRINT(x)	(((R_FunTab[PRIMOFFSET(x)].eval)/100)%10)
  |  |  ------------------
  |  |  |  |  913|  10.8M|#define eval			Rf_eval
  |  |  ------------------
  ------------------
 8151|  10.8M|	R_Visible = flag != 1;
 8152|  10.8M|	SEXP value;
 8153|  10.8M|	if (R_Profiling && IS_TRUE_BUILTIN(fun)) {
  ------------------
  |  | 6942|      0|#define IS_TRUE_BUILTIN(x) ((R_FunTab[PRIMOFFSET(x)].eval % 100 )/10 == 0)
  |  |  ------------------
  |  |  |  |  913|      0|#define eval			Rf_eval
  |  |  ------------------
  |  |  |  Branch (6942:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (8153:6): [True: 0, False: 10.8M]
  ------------------
 8154|      0|	    RCNTXT cntxt;
 8155|      0|	    SEXP oldref = R_Srcref;
 8156|      0|	    begincontext(&cntxt, CTXT_BUILTIN, call,
  ------------------
  |  | 1864|      0|# define begincontext		Rf_begincontext
  ------------------
 8157|      0|			 R_BaseEnv, R_BaseEnv, R_NilValue, R_NilValue);
 8158|      0|	    R_Srcref = NULL;
 8159|      0|	    value = PRIMFUN(fun) (call, fun, args, rho);
  ------------------
  |  | 1345|      0|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 8160|      0|	    R_Srcref = oldref;
 8161|      0|	    endcontext(&cntxt);
  ------------------
  |  | 1895|      0|# define endcontext		Rf_endcontext
  ------------------
 8162|  10.8M|	} else {
 8163|  10.8M|	    value = PRIMFUN(fun) (call, fun, args, rho);
  ------------------
  |  | 1345|  10.8M|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 8164|  10.8M|	}
 8165|  10.8M|	if (flag < 2) R_Visible = flag != 1;
  ------------------
  |  Branch (8165:6): [True: 10.8M, False: 4.52k]
  ------------------
 8166|  10.8M|	vmaxset(vmax);
 8167|  10.8M|	POP_CALL_FRAME(value);
  ------------------
  |  | 6045|  10.8M|#define POP_CALL_FRAME(value) POP_CALL_FRAME_PLUS(0, value)
  |  |  ------------------
  |  |  |  | 6047|  10.8M|#define POP_CALL_FRAME_PLUS(n, value) do {	\
  |  |  |  | 6048|  10.8M|	R_BCNodeStackTop -= (2 + (n));		\
  |  |  |  | 6049|  10.8M|	SETSTACK(-1, value);			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  10.8M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  10.8M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  10.8M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  10.8M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 10.8M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  10.8M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  10.8M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  10.8M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  10.8M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 10.8M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6050|  10.8M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6050:14): [Folded, False: 10.8M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8168|  10.8M|	NEXT();
  ------------------
  |  | 5655|  10.8M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8169|  10.8M|      }
 8170|  10.8M|    OP(CALLSPECIAL, 1):
  ------------------
  |  | 5638|  10.8M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  10.8M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  10.8M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  10.8M|    goto loop; \
  |  | 5642|  10.8M|    op_##name
  ------------------
 8171|  11.5k|      {
 8172|  11.5k|	SEXP call = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|  11.5k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8173|  11.5k|	SEXP symbol = CAR(call);
 8174|  11.5k|	SEXP fun = getPrimitive(symbol, SPECIALSXP);
  ------------------
  |  |  118|  11.5k|#define SPECIALSXP   7	  /* special forms */
  ------------------
 8175|  11.5k|	int flag;
 8176|  11.5k|	const void *vmax = vmaxget();
 8177|  11.5k|	if (RTRACE(fun)) {
  ------------------
  |  Branch (8177:6): [True: 0, False: 11.5k]
  ------------------
 8178|      0|	  Rprintf("trace: ");
 8179|      0|	  PrintValue(symbol);
  ------------------
  |  | 1013|      0|#define PrintValue		Rf_PrintValue
  ------------------
 8180|      0|	}
 8181|  11.5k|	flag = PRIMPRINT(fun);
  ------------------
  |  | 1350|  11.5k|#define PRIMPRINT(x)	(((R_FunTab[PRIMOFFSET(x)].eval)/100)%10)
  |  |  ------------------
  |  |  |  |  913|  11.5k|#define eval			Rf_eval
  |  |  ------------------
  ------------------
 8182|  11.5k|	R_Visible = flag != 1;
 8183|  11.5k|	SEXP value = PRIMFUN(fun) (call, fun, markSpecialArgs(CDR(call)), rho);
  ------------------
  |  | 1345|  11.5k|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 8184|  11.5k|	if (flag < 2) R_Visible = flag != 1;
  ------------------
  |  Branch (8184:6): [True: 9.78k, False: 1.73k]
  ------------------
 8185|  11.5k|	vmaxset(vmax);
 8186|  11.5k|	BCNPUSH(value);
  ------------------
  |  | 5449|  11.5k|#define BCNPUSH(v) do { \
  |  | 5450|  11.5k|  SEXP __value__ = (v); \
  |  | 5451|  11.5k|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5452|  11.5k|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5452:7): [True: 0, False: 11.5k]
  |  |  ------------------
  |  | 5453|  11.5k|  SETSTACK(0, __value__); \
  |  |  ------------------
  |  |  |  | 4905|  11.5k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  11.5k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  11.5k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  11.5k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 11.5k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  11.5k|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|  11.5k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  11.5k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  11.5k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 11.5k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5454|  11.5k|  R_BCNodeStackTop = __ntop__; \
  |  | 5455|  11.5k|} while (0)
  |  |  ------------------
  |  |  |  Branch (5455:10): [Folded, False: 11.5k]
  |  |  ------------------
  ------------------
 8187|  11.5k|	NEXT();
  ------------------
  |  | 5655|  11.5k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8188|  11.5k|      }
 8189|  2.70M|    OP(MAKECLOSURE, 1):
  ------------------
  |  | 5638|  11.5k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  11.5k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  11.5k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  11.5k|    goto loop; \
  |  | 5642|  2.70M|    op_##name
  ------------------
 8190|  2.70M|      {
 8191|  2.70M|	SEXP fb = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|  2.70M|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8192|  2.70M|	SEXP forms = VECTOR_ELT(fb, 0);
 8193|  2.70M|	SEXP body = VECTOR_ELT(fb, 1);
 8194|  2.70M|	SEXP value = mkCLOSXP(forms, body, rho);
  ------------------
  |  | 1955|  2.70M|# define mkCLOSXP		Rf_mkCLOSXP
  ------------------
 8195|       |	/* The LENGTH check below allows for byte code object created
 8196|       |	   by older versions of the compiler that did not record a
 8197|       |	   source attribute. */
 8198|       |	/* FIXME: bump bc version and don't check LENGTH? */
 8199|  2.70M|	if (LENGTH(fb) > 2) {
  ------------------
  |  Branch (8199:6): [True: 2.70M, False: 0]
  ------------------
 8200|  2.70M|	  SEXP srcref = VECTOR_ELT(fb, 2);
 8201|  2.70M|	  if (!isNull(srcref)) setAttrib(value, R_SrcrefSymbol, srcref);
  ------------------
  |  |  956|  2.70M|#define isNull			Rf_isNull
  ------------------
              	  if (!isNull(srcref)) setAttrib(value, R_SrcrefSymbol, srcref);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  |  Branch (8201:8): [True: 0, False: 2.70M]
  ------------------
 8202|  2.70M|	}
 8203|  2.70M|	R_Visible = TRUE;
 8204|  2.70M|	BCNPUSH(value);
  ------------------
  |  | 5449|  2.70M|#define BCNPUSH(v) do { \
  |  | 5450|  2.70M|  SEXP __value__ = (v); \
  |  | 5451|  2.70M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5452|  2.70M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5452:7): [True: 0, False: 2.70M]
  |  |  ------------------
  |  | 5453|  2.70M|  SETSTACK(0, __value__); \
  |  |  ------------------
  |  |  |  | 4905|  2.70M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  2.70M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  2.70M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  2.70M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 2.70M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  2.70M|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|  2.70M|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  2.70M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  2.70M|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 2.70M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5454|  2.70M|  R_BCNodeStackTop = __ntop__; \
  |  | 5455|  2.70M|} while (0)
  |  |  ------------------
  |  |  |  Branch (5455:10): [Folded, False: 2.70M]
  |  |  ------------------
  ------------------
 8205|  2.70M|	NEXT();
  ------------------
  |  | 5655|  2.70M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8206|  2.70M|      }
 8207|  2.70M|    OP(UMINUS, 1): FastUnary(-, R_SubSym);
  ------------------
  |  | 5638|  2.70M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  2.70M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  2.70M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  2.70M|    goto loop; \
  |  | 5642|  2.70M|    op_##name
  ------------------
                  OP(UMINUS, 1): FastUnary(-, R_SubSym);
  ------------------
  |  | 5176|     14|#define FastUnary(op, opsym) do {					\
  |  | 5177|     14|	R_bcstack_t vvx;						\
  |  | 5178|     14|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 1, &vvx);	\
  |  | 5179|     14|	if (vx->tag == REALSXP) {					\
  |  |  ------------------
  |  |  |  |  124|     14|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5179:6): [True: 0, False: 14]
  |  |  ------------------
  |  | 5180|      0|	    SKIP_OP();							\
  |  |  ------------------
  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 5181|      0|	    SETSTACK_REAL(-1, op vx->u.dval);				\
  |  |  ------------------
  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5182|      0|	    R_Visible = TRUE;						\
  |  | 5183|      0|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5184|      0|	}								\
  |  | 5185|     14|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|     28|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5185:11): [True: 0, False: 14]
  |  |  |  Branch (5185:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 5186|      0|	    SKIP_OP();							\
  |  |  ------------------
  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 5187|      0|	    SETSTACK_INTEGER(-1, op vx->u.ival);			\
  |  |  ------------------
  |  |  |  | 4909|      0|#define SETSTACK_INTEGER(i, v) SETSTACK_INTEGER_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4871|      0|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  |  |  | 4872|      0|    int __v__ = (v); \
  |  |  |  |  |  | 4873|      0|    (s)->tag = INTSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4874|      0|    (s)->u.ival = __v__; \
  |  |  |  |  |  | 4875|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4875:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5188|      0|	    R_Visible = TRUE;						\
  |  | 5189|      0|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5190|      0|	}								\
  |  | 5191|     14|	Arith1(opsym);							\
  |  |  ------------------
  |  |  |  | 5115|     14|#define Arith1(opsym) do {		\
  |  |  |  | 5116|     14|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5550|     14|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  ------------------
  |  |  |  | 5117|     14|  SEXP x = GETSTACK(-1); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|     14|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|     14|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 14]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5118|     14|  SETSTACK(-1, cmp_arith1(call, opsym, x, rho)); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|     14|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|     14|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|     14|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|     14|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 14]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|     14|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|     14|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|     14|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|     14|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 14]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5119|     14|  R_Visible = TRUE; \
  |  |  |  | 5120|     14|  NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|     14|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5121|     14|} while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5121:9): [Folded, False: 14]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5192|     14|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5192:14): [Folded, False: 14]
  |  |  ------------------
  ------------------
 8208|     16|    OP(UPLUS, 1): FastUnary(+, R_AddSym);
  ------------------
  |  | 5638|     16|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|     16|    opinfo[name##_OP].argc = (n); \
  |  | 5640|     16|    opinfo[name##_OP].instname = #name; \
  |  | 5641|     16|    goto loop; \
  |  | 5642|     16|    op_##name
  ------------------
                  OP(UPLUS, 1): FastUnary(+, R_AddSym);
  ------------------
  |  | 5176|      0|#define FastUnary(op, opsym) do {					\
  |  | 5177|      0|	R_bcstack_t vvx;						\
  |  | 5178|      0|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 1, &vvx);	\
  |  | 5179|      0|	if (vx->tag == REALSXP) {					\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5179:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5180|      0|	    SKIP_OP();							\
  |  |  ------------------
  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 5181|      0|	    SETSTACK_REAL(-1, op vx->u.dval);				\
  |  |  ------------------
  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5182|      0|	    R_Visible = TRUE;						\
  |  | 5183|      0|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5184|      0|	}								\
  |  | 5185|      0|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5185:11): [True: 0, False: 0]
  |  |  |  Branch (5185:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 5186|      0|	    SKIP_OP();							\
  |  |  ------------------
  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 5187|      0|	    SETSTACK_INTEGER(-1, op vx->u.ival);			\
  |  |  ------------------
  |  |  |  | 4909|      0|#define SETSTACK_INTEGER(i, v) SETSTACK_INTEGER_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4871|      0|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  |  |  | 4872|      0|    int __v__ = (v); \
  |  |  |  |  |  | 4873|      0|    (s)->tag = INTSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4874|      0|    (s)->u.ival = __v__; \
  |  |  |  |  |  | 4875|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4875:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5188|      0|	    R_Visible = TRUE;						\
  |  | 5189|      0|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5190|      0|	}								\
  |  | 5191|      0|	Arith1(opsym);							\
  |  |  ------------------
  |  |  |  | 5115|      0|#define Arith1(opsym) do {		\
  |  |  |  | 5116|      0|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  ------------------
  |  |  |  | 5117|      0|  SEXP x = GETSTACK(-1); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5118|      0|  SETSTACK(-1, cmp_arith1(call, opsym, x, rho)); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5119|      0|  R_Visible = TRUE; \
  |  |  |  | 5120|      0|  NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5121|      0|} while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5121:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5192|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5192:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8209|    651|    OP(ADD, 1): FastBinary(R_ADD, PLUSOP, R_AddSym);
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|    651|    op_##name
  ------------------
                  OP(ADD, 1): FastBinary(R_ADD, PLUSOP, R_AddSym);
  ------------------
  |  | 5194|    651|#define FastBinary(op,opval,opsym) do {					\
  |  | 5195|    651|	{								\
  |  | 5196|    651|	    R_bcstack_t *sx = R_BCNodeStackTop - 2;			\
  |  | 5197|    651|	    R_bcstack_t *sy = R_BCNodeStackTop - 1;			\
  |  | 5198|    651|	    if (sx->tag == REALSXP && sy->tag == REALSXP)		\
  |  |  ------------------
  |  |  |  |  124|  1.30k|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (sx->tag == REALSXP && sy->tag == REALSXP)		\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5198:10): [True: 0, False: 651]
  |  |  |  Branch (5198:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 5199|    651|		DO_FAST_BINOP(op, sx->u.dval, sy->u.dval);		\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5200|    651|	}								\
  |  | 5201|    651|	R_bcstack_t vvx, vvy;						\
  |  | 5202|    651|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 2, &vvx);	\
  |  | 5203|    651|	R_bcstack_t *vy = bcStackScalar(R_BCNodeStackTop - 1, &vvy);	\
  |  | 5204|    651|	if (vx->tag == REALSXP) {					\
  |  |  ------------------
  |  |  |  |  124|    651|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5204:6): [True: 649, False: 2]
  |  |  ------------------
  |  | 5205|    649|	    if (vy->tag == REALSXP)					\
  |  |  ------------------
  |  |  |  |  124|    649|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5205:10): [True: 259, False: 390]
  |  |  ------------------
  |  | 5206|    649|		DO_FAST_BINOP(op, vx->u.dval, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 5157|    259|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|    259|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|    259|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|    259|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|    259|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|    259|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|    259|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|    259|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|    259|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|    259|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|    259|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 259]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|    259|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|    259|	R_Visible = TRUE;			\
  |  |  |  | 5162|    259|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|    259|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|    259|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 259]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5207|    649|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |  123|    780|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|    390|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5207:15): [True: 390, False: 0]
  |  |  |  Branch (5207:36): [True: 390, False: 0]
  |  |  ------------------
  |  | 5208|    390|		DO_FAST_BINOP(op, vx->u.dval, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 5157|    390|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|    390|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|    390|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|    390|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|    390|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|    390|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|    390|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|    390|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|    390|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|    390|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|    390|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 390]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|    390|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|    390|	R_Visible = TRUE;			\
  |  |  |  | 5162|    390|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|    390|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|    390|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 390]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5209|    649|	}								\
  |  | 5210|    651|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|      2|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5210:11): [True: 2, False: 0]
  |  |  |  Branch (5210:32): [True: 2, False: 0]
  |  |  ------------------
  |  | 5211|      2|	    int ix = vx->u.ival;					\
  |  | 5212|      2|	    if (vy->tag == REALSXP)					\
  |  |  ------------------
  |  |  |  |  124|      2|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5212:10): [True: 0, False: 2]
  |  |  ------------------
  |  | 5213|      2|		DO_FAST_BINOP(op, ix, vy->u.dval);			\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5214|      2|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5214:15): [True: 0, False: 2]
  |  |  |  Branch (5214:36): [True: 0, False: 0]
  |  |  ------------------
  |  | 5215|      0|		int iy = vy->u.ival;					\
  |  | 5216|      0|		if (opval == DIVOP || opval == POWOP)			\
  |  |  ------------------
  |  |  |  Branch (5216:7): [Folded, False: 0]
  |  |  |  Branch (5216:25): [Folded, False: 0]
  |  |  ------------------
  |  | 5217|      0|		    DO_FAST_BINOP(op, (double) ix, (double) iy);	\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5218|      0|		else							\
  |  | 5219|      0|		    DO_FAST_BINOP_INT(op, ix, iy);			\
  |  |  ------------------
  |  |  |  | 5165|      0|#define DO_FAST_BINOP_INT(fun, a, b) do {		\
  |  |  |  | 5166|      0|	double dval = fun((double) (a), (double) (b));	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 8209|      0|    OP(ADD, 1): FastBinary(R_ADD, PLUSOP, R_AddSym);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5225|      0|#define R_ADD(x, y) ((x) + (y))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5167|      0|	if (dval <= INT_MAX && dval >= INT_MIN + 1) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5167:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (5167:25): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5168|      0|	    SKIP_OP();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5169|      0|	    SETSTACK_INTEGER(-2, (int) dval);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4909|      0|#define SETSTACK_INTEGER(i, v) SETSTACK_INTEGER_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4871|      0|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4872|      0|    int __v__ = (v); \
  |  |  |  |  |  |  |  | 4873|      0|    (s)->tag = INTSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4874|      0|    (s)->u.ival = __v__; \
  |  |  |  |  |  |  |  | 4875|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4875:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5170|      0|	    R_BCNodeStackTop--;				\
  |  |  |  | 5171|      0|	    R_Visible = TRUE;				\
  |  |  |  | 5172|      0|	    NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5173|      0|	}						\
  |  |  |  | 5174|      0|    } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5174:13): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5220|      0|	    }								\
  |  | 5221|      2|	}								\
  |  | 5222|    651|	Arith2(opval, opsym);						\
  |  |  ------------------
  |  |  |  | 5124|    651|#define Arith2(opval,opsym) NewBuiltin2(cmp_arith2,opval,opsym,rho)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5105|    651|#define NewBuiltin2(do_fun,opval,opsym,rho) do {	\
  |  |  |  |  |  | 5106|    651|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5550|    651|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5107|    651|  SEXP x = GETSTACK(-2); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|    651|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|    651|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 651]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5108|    651|  SEXP y = GETSTACK(-1); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|    651|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|    651|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 651]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5109|    651|  SETSTACK(-2, do_fun(call, opval, opsym, x, y,rho));	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|    651|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|    651|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|    651|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|    651|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 651]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|    651|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|    651|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|    651|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|    651|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 651]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5110|    651|  R_BCNodeStackTop--; \
  |  |  |  |  |  | 5111|    651|  R_Visible = TRUE; \
  |  |  |  |  |  | 5112|    651|  NEXT(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5655|    651|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5113|    651|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5113:9): [Folded, False: 651]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5223|    651|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5223:14): [Folded, False: 651]
  |  |  ------------------
  ------------------
 8210|    653|    OP(SUB, 1): FastBinary(R_SUB, MINUSOP, R_SubSym);
  ------------------
  |  | 5638|    653|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    653|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    653|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    653|    goto loop; \
  |  | 5642|    653|    op_##name
  ------------------
                  OP(SUB, 1): FastBinary(R_SUB, MINUSOP, R_SubSym);
  ------------------
  |  | 5194|    457|#define FastBinary(op,opval,opsym) do {					\
  |  | 5195|    457|	{								\
  |  | 5196|    457|	    R_bcstack_t *sx = R_BCNodeStackTop - 2;			\
  |  | 5197|    457|	    R_bcstack_t *sy = R_BCNodeStackTop - 1;			\
  |  | 5198|    457|	    if (sx->tag == REALSXP && sy->tag == REALSXP)		\
  |  |  ------------------
  |  |  |  |  124|    914|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (sx->tag == REALSXP && sy->tag == REALSXP)		\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5198:10): [True: 0, False: 457]
  |  |  |  Branch (5198:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 5199|    457|		DO_FAST_BINOP(op, sx->u.dval, sy->u.dval);		\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5200|    457|	}								\
  |  | 5201|    457|	R_bcstack_t vvx, vvy;						\
  |  | 5202|    457|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 2, &vvx);	\
  |  | 5203|    457|	R_bcstack_t *vy = bcStackScalar(R_BCNodeStackTop - 1, &vvy);	\
  |  | 5204|    457|	if (vx->tag == REALSXP) {					\
  |  |  ------------------
  |  |  |  |  124|    457|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5204:6): [True: 2, False: 455]
  |  |  ------------------
  |  | 5205|      2|	    if (vy->tag == REALSXP)					\
  |  |  ------------------
  |  |  |  |  124|      2|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5205:10): [True: 0, False: 2]
  |  |  ------------------
  |  | 5206|      2|		DO_FAST_BINOP(op, vx->u.dval, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5207|      2|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      2|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5207:15): [True: 2, False: 0]
  |  |  |  Branch (5207:36): [True: 2, False: 0]
  |  |  ------------------
  |  | 5208|      2|		DO_FAST_BINOP(op, vx->u.dval, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 5157|      2|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      2|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      2|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      2|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      2|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      2|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      2|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      2|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      2|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      2|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      2|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      2|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      2|	R_Visible = TRUE;			\
  |  |  |  | 5162|      2|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      2|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      2|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5209|      2|	}								\
  |  | 5210|    457|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|    910|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|    391|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5210:11): [True: 391, False: 64]
  |  |  |  Branch (5210:32): [True: 391, False: 0]
  |  |  ------------------
  |  | 5211|    391|	    int ix = vx->u.ival;					\
  |  | 5212|    391|	    if (vy->tag == REALSXP)					\
  |  |  ------------------
  |  |  |  |  124|    391|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5212:10): [True: 3, False: 388]
  |  |  ------------------
  |  | 5213|    391|		DO_FAST_BINOP(op, ix, vy->u.dval);			\
  |  |  ------------------
  |  |  |  | 5157|      3|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      3|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      3|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      3|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      3|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      3|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      3|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      3|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      3|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      3|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      3|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 3]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      3|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      3|	R_Visible = TRUE;			\
  |  |  |  | 5162|      3|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      3|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      3|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 3]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5214|    391|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|    776|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|    372|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5214:15): [True: 372, False: 16]
  |  |  |  Branch (5214:36): [True: 372, False: 0]
  |  |  ------------------
  |  | 5215|    372|		int iy = vy->u.ival;					\
  |  | 5216|    372|		if (opval == DIVOP || opval == POWOP)			\
  |  |  ------------------
  |  |  |  Branch (5216:7): [Folded, False: 0]
  |  |  |  Branch (5216:25): [Folded, False: 0]
  |  |  ------------------
  |  | 5217|    372|		    DO_FAST_BINOP(op, (double) ix, (double) iy);	\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5218|    372|		else							\
  |  | 5219|    372|		    DO_FAST_BINOP_INT(op, ix, iy);			\
  |  |  ------------------
  |  |  |  | 5165|    372|#define DO_FAST_BINOP_INT(fun, a, b) do {		\
  |  |  |  | 5166|    372|	double dval = fun((double) (a), (double) (b));	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 8210|    372|    OP(SUB, 1): FastBinary(R_SUB, MINUSOP, R_SubSym);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5226|    372|#define R_SUB(x, y) ((x) - (y))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5167|    372|	if (dval <= INT_MAX && dval >= INT_MIN + 1) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5167:6): [True: 372, False: 0]
  |  |  |  |  |  Branch (5167:25): [True: 372, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5168|    372|	    SKIP_OP();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|    372|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5169|    372|	    SETSTACK_INTEGER(-2, (int) dval);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4909|    372|#define SETSTACK_INTEGER(i, v) SETSTACK_INTEGER_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4871|    372|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4872|    372|    int __v__ = (v); \
  |  |  |  |  |  |  |  | 4873|    372|    (s)->tag = INTSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  123|    372|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4874|    372|    (s)->u.ival = __v__; \
  |  |  |  |  |  |  |  | 4875|    372|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4875:10): [Folded, False: 372]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5170|    372|	    R_BCNodeStackTop--;				\
  |  |  |  | 5171|    372|	    R_Visible = TRUE;				\
  |  |  |  | 5172|    372|	    NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|    372|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5173|    372|	}						\
  |  |  |  | 5174|    372|    } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5174:13): [Folded, False: 372]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5220|    372|	    }								\
  |  | 5221|    391|	}								\
  |  | 5222|    457|	Arith2(opval, opsym);						\
  |  |  ------------------
  |  |  |  | 5124|    457|#define Arith2(opval,opsym) NewBuiltin2(cmp_arith2,opval,opsym,rho)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5105|    457|#define NewBuiltin2(do_fun,opval,opsym,rho) do {	\
  |  |  |  |  |  | 5106|    457|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5550|    457|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5107|    457|  SEXP x = GETSTACK(-2); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|    457|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|    457|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 457]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5108|    457|  SEXP y = GETSTACK(-1); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|    457|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|    457|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 64, False: 393]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5109|    457|  SETSTACK(-2, do_fun(call, opval, opsym, x, y,rho));	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|    457|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|    457|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|    457|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|    457|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 457]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|    457|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|    457|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|    457|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|    457|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 457]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5110|    457|  R_BCNodeStackTop--; \
  |  |  |  |  |  | 5111|    457|  R_Visible = TRUE; \
  |  |  |  |  |  | 5112|    457|  NEXT(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5655|    457|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5113|    457|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5113:9): [Folded, False: 457]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5223|    457|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5223:14): [Folded, False: 457]
  |  |  ------------------
  ------------------
 8211|  1.00k|    OP(MUL, 1): FastBinary(R_MUL, TIMESOP, R_MulSym);
  ------------------
  |  | 5638|    459|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    459|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    459|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    459|    goto loop; \
  |  | 5642|  1.00k|    op_##name
  ------------------
                  OP(MUL, 1): FastBinary(R_MUL, TIMESOP, R_MulSym);
  ------------------
  |  | 5194|  1.00k|#define FastBinary(op,opval,opsym) do {					\
  |  | 5195|  1.00k|	{								\
  |  | 5196|  1.00k|	    R_bcstack_t *sx = R_BCNodeStackTop - 2;			\
  |  | 5197|  1.00k|	    R_bcstack_t *sy = R_BCNodeStackTop - 1;			\
  |  | 5198|  1.00k|	    if (sx->tag == REALSXP && sy->tag == REALSXP)		\
  |  |  ------------------
  |  |  |  |  124|  2.00k|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (sx->tag == REALSXP && sy->tag == REALSXP)		\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5198:10): [True: 0, False: 1.00k]
  |  |  |  Branch (5198:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 5199|  1.00k|		DO_FAST_BINOP(op, sx->u.dval, sy->u.dval);		\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5200|  1.00k|	}								\
  |  | 5201|  1.00k|	R_bcstack_t vvx, vvy;						\
  |  | 5202|  1.00k|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 2, &vvx);	\
  |  | 5203|  1.00k|	R_bcstack_t *vy = bcStackScalar(R_BCNodeStackTop - 1, &vvy);	\
  |  | 5204|  1.00k|	if (vx->tag == REALSXP) {					\
  |  |  ------------------
  |  |  |  |  124|  1.00k|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5204:6): [True: 0, False: 1.00k]
  |  |  ------------------
  |  | 5205|      0|	    if (vy->tag == REALSXP)					\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5205:10): [True: 0, False: 0]
  |  |  ------------------
  |  | 5206|      0|		DO_FAST_BINOP(op, vx->u.dval, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5207|      0|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5207:15): [True: 0, False: 0]
  |  |  |  Branch (5207:36): [True: 0, False: 0]
  |  |  ------------------
  |  | 5208|      0|		DO_FAST_BINOP(op, vx->u.dval, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5209|      0|	}								\
  |  | 5210|  1.00k|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|  2.00k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|  1.00k|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5210:11): [True: 1.00k, False: 0]
  |  |  |  Branch (5210:32): [True: 1.00k, False: 0]
  |  |  ------------------
  |  | 5211|  1.00k|	    int ix = vx->u.ival;					\
  |  | 5212|  1.00k|	    if (vy->tag == REALSXP)					\
  |  |  ------------------
  |  |  |  |  124|  1.00k|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5212:10): [True: 0, False: 1.00k]
  |  |  ------------------
  |  | 5213|  1.00k|		DO_FAST_BINOP(op, ix, vy->u.dval);			\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5214|  1.00k|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|  2.00k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|  1.00k|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5214:15): [True: 1.00k, False: 0]
  |  |  |  Branch (5214:36): [True: 1.00k, False: 0]
  |  |  ------------------
  |  | 5215|  1.00k|		int iy = vy->u.ival;					\
  |  | 5216|  1.00k|		if (opval == DIVOP || opval == POWOP)			\
  |  |  ------------------
  |  |  |  Branch (5216:7): [Folded, False: 0]
  |  |  |  Branch (5216:25): [Folded, False: 0]
  |  |  ------------------
  |  | 5217|  1.00k|		    DO_FAST_BINOP(op, (double) ix, (double) iy);	\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5218|  1.00k|		else							\
  |  | 5219|  1.00k|		    DO_FAST_BINOP_INT(op, ix, iy);			\
  |  |  ------------------
  |  |  |  | 5165|  1.00k|#define DO_FAST_BINOP_INT(fun, a, b) do {		\
  |  |  |  | 5166|  1.00k|	double dval = fun((double) (a), (double) (b));	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 8211|  1.00k|    OP(MUL, 1): FastBinary(R_MUL, TIMESOP, R_MulSym);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5227|  1.00k|#define R_MUL(x, y) ((x) * (y))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5167|  1.00k|	if (dval <= INT_MAX && dval >= INT_MIN + 1) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5167:6): [True: 1.00k, False: 0]
  |  |  |  |  |  Branch (5167:25): [True: 1.00k, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5168|  1.00k|	    SKIP_OP();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|  1.00k|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5169|  1.00k|	    SETSTACK_INTEGER(-2, (int) dval);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4909|  1.00k|#define SETSTACK_INTEGER(i, v) SETSTACK_INTEGER_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4871|  1.00k|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4872|  1.00k|    int __v__ = (v); \
  |  |  |  |  |  |  |  | 4873|  1.00k|    (s)->tag = INTSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  123|  1.00k|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4874|  1.00k|    (s)->u.ival = __v__; \
  |  |  |  |  |  |  |  | 4875|  1.00k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4875:10): [Folded, False: 1.00k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5170|  1.00k|	    R_BCNodeStackTop--;				\
  |  |  |  | 5171|  1.00k|	    R_Visible = TRUE;				\
  |  |  |  | 5172|  1.00k|	    NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|  1.00k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5173|  1.00k|	}						\
  |  |  |  | 5174|  1.00k|    } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5174:13): [Folded, False: 1.00k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5220|  1.00k|	    }								\
  |  | 5221|  1.00k|	}								\
  |  | 5222|  1.00k|	Arith2(opval, opsym);						\
  |  |  ------------------
  |  |  |  | 5124|  1.00k|#define Arith2(opval,opsym) NewBuiltin2(cmp_arith2,opval,opsym,rho)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5105|  1.00k|#define NewBuiltin2(do_fun,opval,opsym,rho) do {	\
  |  |  |  |  |  | 5106|  1.00k|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5550|  1.00k|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5107|  1.00k|  SEXP x = GETSTACK(-2); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|  1.00k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|  1.00k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.00k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5108|  1.00k|  SEXP y = GETSTACK(-1); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|  1.00k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|  1.00k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.00k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5109|  1.00k|  SETSTACK(-2, do_fun(call, opval, opsym, x, y,rho));	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|  1.00k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|  1.00k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|  1.00k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|  1.00k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.00k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|  1.00k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|  1.00k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|  1.00k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|  1.00k|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.00k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5110|  1.00k|  R_BCNodeStackTop--; \
  |  |  |  |  |  | 5111|  1.00k|  R_Visible = TRUE; \
  |  |  |  |  |  | 5112|  1.00k|  NEXT(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5655|  1.00k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5113|  1.00k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5113:9): [Folded, False: 1.00k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5223|  1.00k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5223:14): [Folded, False: 1.00k]
  |  |  ------------------
  ------------------
 8212|  1.00k|    OP(DIV, 1): FastBinary(R_DIV, DIVOP, R_DivSym);
  ------------------
  |  | 5638|  1.00k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.00k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.00k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.00k|    goto loop; \
  |  | 5642|  1.00k|    op_##name
  ------------------
                  OP(DIV, 1): FastBinary(R_DIV, DIVOP, R_DivSym);
  ------------------
  |  | 5194|      0|#define FastBinary(op,opval,opsym) do {					\
  |  | 5195|      0|	{								\
  |  | 5196|      0|	    R_bcstack_t *sx = R_BCNodeStackTop - 2;			\
  |  | 5197|      0|	    R_bcstack_t *sy = R_BCNodeStackTop - 1;			\
  |  | 5198|      0|	    if (sx->tag == REALSXP && sy->tag == REALSXP)		\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (sx->tag == REALSXP && sy->tag == REALSXP)		\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5198:10): [True: 0, False: 0]
  |  |  |  Branch (5198:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 5199|      0|		DO_FAST_BINOP(op, sx->u.dval, sy->u.dval);		\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5200|      0|	}								\
  |  | 5201|      0|	R_bcstack_t vvx, vvy;						\
  |  | 5202|      0|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 2, &vvx);	\
  |  | 5203|      0|	R_bcstack_t *vy = bcStackScalar(R_BCNodeStackTop - 1, &vvy);	\
  |  | 5204|      0|	if (vx->tag == REALSXP) {					\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5204:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5205|      0|	    if (vy->tag == REALSXP)					\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5205:10): [True: 0, False: 0]
  |  |  ------------------
  |  | 5206|      0|		DO_FAST_BINOP(op, vx->u.dval, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5207|      0|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5207:15): [True: 0, False: 0]
  |  |  |  Branch (5207:36): [True: 0, False: 0]
  |  |  ------------------
  |  | 5208|      0|		DO_FAST_BINOP(op, vx->u.dval, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5209|      0|	}								\
  |  | 5210|      0|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5210:11): [True: 0, False: 0]
  |  |  |  Branch (5210:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 5211|      0|	    int ix = vx->u.ival;					\
  |  | 5212|      0|	    if (vy->tag == REALSXP)					\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5212:10): [True: 0, False: 0]
  |  |  ------------------
  |  | 5213|      0|		DO_FAST_BINOP(op, ix, vy->u.dval);			\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5214|      0|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5214:15): [True: 0, False: 0]
  |  |  |  Branch (5214:36): [True: 0, False: 0]
  |  |  ------------------
  |  | 5215|      0|		int iy = vy->u.ival;					\
  |  | 5216|      0|		if (opval == DIVOP || opval == POWOP)			\
  |  |  ------------------
  |  |  |  Branch (5216:7): [True: 0, Folded]
  |  |  |  Branch (5216:25): [Folded, False: 0]
  |  |  ------------------
  |  | 5217|      0|		    DO_FAST_BINOP(op, (double) ix, (double) iy);	\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5218|      0|		else							\
  |  | 5219|      0|		    DO_FAST_BINOP_INT(op, ix, iy);			\
  |  |  ------------------
  |  |  |  | 5165|      0|#define DO_FAST_BINOP_INT(fun, a, b) do {		\
  |  |  |  | 5166|      0|	double dval = fun((double) (a), (double) (b));	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 8212|      0|    OP(DIV, 1): FastBinary(R_DIV, DIVOP, R_DivSym);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5228|      0|#define R_DIV(x, y) ((x) / (y))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5167|      0|	if (dval <= INT_MAX && dval >= INT_MIN + 1) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5167:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (5167:25): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5168|      0|	    SKIP_OP();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5169|      0|	    SETSTACK_INTEGER(-2, (int) dval);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4909|      0|#define SETSTACK_INTEGER(i, v) SETSTACK_INTEGER_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4871|      0|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4872|      0|    int __v__ = (v); \
  |  |  |  |  |  |  |  | 4873|      0|    (s)->tag = INTSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4874|      0|    (s)->u.ival = __v__; \
  |  |  |  |  |  |  |  | 4875|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4875:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5170|      0|	    R_BCNodeStackTop--;				\
  |  |  |  | 5171|      0|	    R_Visible = TRUE;				\
  |  |  |  | 5172|      0|	    NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5173|      0|	}						\
  |  |  |  | 5174|      0|    } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5174:13): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5220|      0|	    }								\
  |  | 5221|      0|	}								\
  |  | 5222|      0|	Arith2(opval, opsym);						\
  |  |  ------------------
  |  |  |  | 5124|      0|#define Arith2(opval,opsym) NewBuiltin2(cmp_arith2,opval,opsym,rho)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5105|      0|#define NewBuiltin2(do_fun,opval,opsym,rho) do {	\
  |  |  |  |  |  | 5106|      0|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5107|      0|  SEXP x = GETSTACK(-2); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5108|      0|  SEXP y = GETSTACK(-1); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5109|      0|  SETSTACK(-2, do_fun(call, opval, opsym, x, y,rho));	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5110|      0|  R_BCNodeStackTop--; \
  |  |  |  |  |  | 5111|      0|  R_Visible = TRUE; \
  |  |  |  |  |  | 5112|      0|  NEXT(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5113|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5113:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5223|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5223:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8213|     64|    OP(EXPT, 1): FastBinary(R_POW, POWOP, R_ExptSym);
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|     64|    op_##name
  ------------------
                  OP(EXPT, 1): FastBinary(R_POW, POWOP, R_ExptSym);
  ------------------
  |  | 5194|     64|#define FastBinary(op,opval,opsym) do {					\
  |  | 5195|     64|	{								\
  |  | 5196|     64|	    R_bcstack_t *sx = R_BCNodeStackTop - 2;			\
  |  | 5197|     64|	    R_bcstack_t *sy = R_BCNodeStackTop - 1;			\
  |  | 5198|     64|	    if (sx->tag == REALSXP && sy->tag == REALSXP)		\
  |  |  ------------------
  |  |  |  |  124|    128|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (sx->tag == REALSXP && sy->tag == REALSXP)		\
  |  |  ------------------
  |  |  |  |  124|     64|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5198:10): [True: 64, False: 0]
  |  |  |  Branch (5198:32): [True: 0, False: 64]
  |  |  ------------------
  |  | 5199|     64|		DO_FAST_BINOP(op, sx->u.dval, sy->u.dval);		\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5200|     64|	}								\
  |  | 5201|     64|	R_bcstack_t vvx, vvy;						\
  |  | 5202|     64|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 2, &vvx);	\
  |  | 5203|     64|	R_bcstack_t *vy = bcStackScalar(R_BCNodeStackTop - 1, &vvy);	\
  |  | 5204|     64|	if (vx->tag == REALSXP) {					\
  |  |  ------------------
  |  |  |  |  124|     64|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5204:6): [True: 64, False: 0]
  |  |  ------------------
  |  | 5205|     64|	    if (vy->tag == REALSXP)					\
  |  |  ------------------
  |  |  |  |  124|     64|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5205:10): [True: 0, False: 64]
  |  |  ------------------
  |  | 5206|     64|		DO_FAST_BINOP(op, vx->u.dval, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5207|     64|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |  123|    128|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5207:15): [True: 0, False: 64]
  |  |  |  Branch (5207:36): [True: 0, False: 0]
  |  |  ------------------
  |  | 5208|     64|		DO_FAST_BINOP(op, vx->u.dval, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5209|     64|	}								\
  |  | 5210|     64|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5210:11): [True: 0, False: 0]
  |  |  |  Branch (5210:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 5211|      0|	    int ix = vx->u.ival;					\
  |  | 5212|      0|	    if (vy->tag == REALSXP)					\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5212:10): [True: 0, False: 0]
  |  |  ------------------
  |  | 5213|      0|		DO_FAST_BINOP(op, ix, vy->u.dval);			\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5214|      0|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5214:15): [True: 0, False: 0]
  |  |  |  Branch (5214:36): [True: 0, False: 0]
  |  |  ------------------
  |  | 5215|      0|		int iy = vy->u.ival;					\
  |  | 5216|      0|		if (opval == DIVOP || opval == POWOP)			\
  |  |  ------------------
  |  |  |  Branch (5216:7): [Folded, False: 0]
  |  |  |  Branch (5216:25): [True: 0, Folded]
  |  |  ------------------
  |  | 5217|      0|		    DO_FAST_BINOP(op, (double) ix, (double) iy);	\
  |  |  ------------------
  |  |  |  | 5157|      0|#define DO_FAST_BINOP(fun,a,b) do {		\
  |  |  |  | 5158|      0|	SKIP_OP();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5159|      0|	SETSTACK_REAL(-2, fun(a, b));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5160|      0|	R_BCNodeStackTop--;			\
  |  |  |  | 5161|      0|	R_Visible = TRUE;			\
  |  |  |  | 5162|      0|	NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5163|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5163:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5218|      0|		else							\
  |  | 5219|      0|		    DO_FAST_BINOP_INT(op, ix, iy);			\
  |  |  ------------------
  |  |  |  | 5165|      0|#define DO_FAST_BINOP_INT(fun, a, b) do {		\
  |  |  |  | 5166|      0|	double dval = fun((double) (a), (double) (b));	\
  |  |  |  | 5167|      0|	if (dval <= INT_MAX && dval >= INT_MIN + 1) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5167:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (5167:25): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5168|      0|	    SKIP_OP();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 5169|      0|	    SETSTACK_INTEGER(-2, (int) dval);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4909|      0|#define SETSTACK_INTEGER(i, v) SETSTACK_INTEGER_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4871|      0|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4872|      0|    int __v__ = (v); \
  |  |  |  |  |  |  |  | 4873|      0|    (s)->tag = INTSXP; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4874|      0|    (s)->u.ival = __v__; \
  |  |  |  |  |  |  |  | 4875|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4875:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5170|      0|	    R_BCNodeStackTop--;				\
  |  |  |  | 5171|      0|	    R_Visible = TRUE;				\
  |  |  |  | 5172|      0|	    NEXT();					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5173|      0|	}						\
  |  |  |  | 5174|      0|    } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5174:13): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5220|      0|	    }								\
  |  | 5221|      0|	}								\
  |  | 5222|     64|	Arith2(opval, opsym);						\
  |  |  ------------------
  |  |  |  | 5124|     64|#define Arith2(opval,opsym) NewBuiltin2(cmp_arith2,opval,opsym,rho)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5105|     64|#define NewBuiltin2(do_fun,opval,opsym,rho) do {	\
  |  |  |  |  |  | 5106|     64|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5550|     64|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5107|     64|  SEXP x = GETSTACK(-2); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|     64|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|     64|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 64, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5108|     64|  SEXP y = GETSTACK(-1); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|     64|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|     64|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 64]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5109|     64|  SETSTACK(-2, do_fun(call, opval, opsym, x, y,rho));	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|     64|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|     64|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|     64|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|     64|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 64]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|     64|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|     64|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|     64|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|     64|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 64]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5110|     64|  R_BCNodeStackTop--; \
  |  |  |  |  |  | 5111|     64|  R_Visible = TRUE; \
  |  |  |  |  |  | 5112|     64|  NEXT(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5655|     64|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5113|     64|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5113:9): [Folded, False: 64]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5223|     64|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5223:14): [Folded, False: 64]
  |  |  ------------------
  ------------------
 8214|     66|    OP(SQRT, 1): FastMath1(sqrt, R_SqrtSym);
  ------------------
  |  | 5638|     66|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|     66|    opinfo[name##_OP].argc = (n); \
  |  | 5640|     66|    opinfo[name##_OP].instname = #name; \
  |  | 5641|     66|    goto loop; \
  |  | 5642|     66|    op_##name
  ------------------
                  OP(SQRT, 1): FastMath1(sqrt, R_SqrtSym);
  ------------------
  |  | 5128|      0|#define FastMath1(fun, sym) do {					\
  |  | 5129|      0|	R_bcstack_t vvx;						\
  |  | 5130|      0|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 1, &vvx);	\
  |  | 5131|      0|	if (vx->tag == REALSXP) {					\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5131:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5132|      0|	    double dval = fun(vx->u.dval);				\
  |  | 5133|      0|	    if (ISNAN(dval)) {						\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5134|      0|		SEXP call = GETCONST(constants, GETOP());		\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5135|      0|		if (ISNAN(vx->u.dval)) dval = vx->u.dval;		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5136|      0|		else warningcall(call, R_MSG_NA);			\
  |  |  ------------------
  |  |  |  | 2013|      0|# define warningcall		Rf_warningcall
  |  |  ------------------
  |  |               		else warningcall(call, R_MSG_NA);			\
  |  |  ------------------
  |  |  |  | 5127|      0|#define R_MSG_NA	_("NaNs produced")
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5137|      0|	    }								\
  |  | 5138|      0|	    else SKIP_OP();						\
  |  |  ------------------
  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 5139|      0|	    SETSTACK_REAL(-1, dval);					\
  |  |  ------------------
  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5140|      0|	    R_Visible = TRUE;						\
  |  | 5141|      0|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5142|      0|	}								\
  |  | 5143|      0|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5143:11): [True: 0, False: 0]
  |  |  |  Branch (5143:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 5144|      0|	    double dval = fun((double) vx->u.ival);			\
  |  | 5145|      0|	    if (ISNAN(dval)) {						\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5146|      0|		SEXP call = GETCONST(constants, GETOP());		\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5147|      0|		warningcall(call, R_MSG_NA);				\
  |  |  ------------------
  |  |  |  | 2013|      0|# define warningcall		Rf_warningcall
  |  |  ------------------
  |  |               		warningcall(call, R_MSG_NA);				\
  |  |  ------------------
  |  |  |  | 5127|      0|#define R_MSG_NA	_("NaNs produced")
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5148|      0|	    }								\
  |  | 5149|      0|	    else SKIP_OP();						\
  |  |  ------------------
  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 5150|      0|	    SETSTACK_REAL(-1, dval);					\
  |  |  ------------------
  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5151|      0|	    R_Visible = TRUE;						\
  |  | 5152|      0|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5153|      0|	}								\
  |  | 5154|      0|	Builtin1(do_math1,sym,rho);					\
  |  |  ------------------
  |  |  |  | 5083|      0|#define Builtin1(do_fun,which,rho) do {					\
  |  |  |  | 5084|      0|	SEXP call = GETCONST(constants, GETOP());			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  ------------------
  |  |  |  | 5085|      0|	SETSTACK(-1, CONS_NR(GETSTACK(-1), R_NilValue));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5086|      0|	SETSTACK(-1, do_fun(call, getPrimitive(which, BUILTINSXP),	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5087|      0|			    GETSTACK(-1), rho));			\
  |  |  |  | 5088|      0|	R_Visible = TRUE;						\
  |  |  |  | 5089|      0|	NEXT();								\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5090|      0|    } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5090:13): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5155|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5155:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8215|      2|    OP(EXP, 1): FastMath1(exp, R_ExpSym);
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
                  OP(EXP, 1): FastMath1(exp, R_ExpSym);
  ------------------
  |  | 5128|      0|#define FastMath1(fun, sym) do {					\
  |  | 5129|      0|	R_bcstack_t vvx;						\
  |  | 5130|      0|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 1, &vvx);	\
  |  | 5131|      0|	if (vx->tag == REALSXP) {					\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5131:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5132|      0|	    double dval = fun(vx->u.dval);				\
  |  | 5133|      0|	    if (ISNAN(dval)) {						\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5134|      0|		SEXP call = GETCONST(constants, GETOP());		\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5135|      0|		if (ISNAN(vx->u.dval)) dval = vx->u.dval;		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5136|      0|		else warningcall(call, R_MSG_NA);			\
  |  |  ------------------
  |  |  |  | 2013|      0|# define warningcall		Rf_warningcall
  |  |  ------------------
  |  |               		else warningcall(call, R_MSG_NA);			\
  |  |  ------------------
  |  |  |  | 5127|      0|#define R_MSG_NA	_("NaNs produced")
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5137|      0|	    }								\
  |  | 5138|      0|	    else SKIP_OP();						\
  |  |  ------------------
  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 5139|      0|	    SETSTACK_REAL(-1, dval);					\
  |  |  ------------------
  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5140|      0|	    R_Visible = TRUE;						\
  |  | 5141|      0|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5142|      0|	}								\
  |  | 5143|      0|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5143:11): [True: 0, False: 0]
  |  |  |  Branch (5143:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 5144|      0|	    double dval = fun((double) vx->u.ival);			\
  |  | 5145|      0|	    if (ISNAN(dval)) {						\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5146|      0|		SEXP call = GETCONST(constants, GETOP());		\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5147|      0|		warningcall(call, R_MSG_NA);				\
  |  |  ------------------
  |  |  |  | 2013|      0|# define warningcall		Rf_warningcall
  |  |  ------------------
  |  |               		warningcall(call, R_MSG_NA);				\
  |  |  ------------------
  |  |  |  | 5127|      0|#define R_MSG_NA	_("NaNs produced")
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5148|      0|	    }								\
  |  | 5149|      0|	    else SKIP_OP();						\
  |  |  ------------------
  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 5150|      0|	    SETSTACK_REAL(-1, dval);					\
  |  |  ------------------
  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5151|      0|	    R_Visible = TRUE;						\
  |  | 5152|      0|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5153|      0|	}								\
  |  | 5154|      0|	Builtin1(do_math1,sym,rho);					\
  |  |  ------------------
  |  |  |  | 5083|      0|#define Builtin1(do_fun,which,rho) do {					\
  |  |  |  | 5084|      0|	SEXP call = GETCONST(constants, GETOP());			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  ------------------
  |  |  |  | 5085|      0|	SETSTACK(-1, CONS_NR(GETSTACK(-1), R_NilValue));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5086|      0|	SETSTACK(-1, do_fun(call, getPrimitive(which, BUILTINSXP),	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5087|      0|			    GETSTACK(-1), rho));			\
  |  |  |  | 5088|      0|	R_Visible = TRUE;						\
  |  |  |  | 5089|      0|	NEXT();								\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5090|      0|    } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5090:13): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5155|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5155:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8216|  1.54M|    OP(EQ, 1): FastRelop2(==, EQOP, R_EqSym);
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|  1.54M|    op_##name
  ------------------
                  OP(EQ, 1): FastRelop2(==, EQOP, R_EqSym);
  ------------------
  |  | 4987|  1.54M|#define FastRelop2(op,opval,opsym) do {					\
  |  | 4988|  1.54M|	R_bcstack_t vvx, vvy;						\
  |  | 4989|  1.54M|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 2, &vvx);	\
  |  | 4990|  1.54M|	R_bcstack_t *vy = bcStackScalar(R_BCNodeStackTop - 1, &vvy);	\
  |  | 4991|  1.54M|	if (vx->tag == REALSXP && ! ISNAN(vx->u.dval)) {		\
  |  |  ------------------
  |  |  |  |  124|  3.09M|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	if (vx->tag == REALSXP && ! ISNAN(vx->u.dval)) {		\
  |  |  ------------------
  |  |  |  |   76|    246|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4991:6): [True: 246, False: 1.54M]
  |  |  |  Branch (4991:28): [True: 246, False: 0]
  |  |  ------------------
  |  | 4992|    246|	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |  124|    492|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |   76|      2|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4992:10): [True: 2, False: 244]
  |  |  |  Branch (4992:32): [True: 2, False: 0]
  |  |  ------------------
  |  | 4993|    246|		DO_FAST_RELOP2(op, vx->u.dval, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 4969|      2|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|      2|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      2|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|      2|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|      2|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|      2|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|      4|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|      2|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|      2|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|      2|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      2|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|      2|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|      2|	else					\
  |  |  |  |  |  |  |  | 4883|      2|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|      2|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|      2|    R_BCNodeStackTop--; \
  |  |  |  | 4973|      2|    R_Visible = TRUE; \
  |  |  |  | 4974|      2|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      2|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|      2|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4994|    246|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |  123|    488|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|    244|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (4994:15): [True: 244, False: 0]
  |  |  |  Branch (4994:36): [True: 244, False: 0]
  |  |  ------------------
  |  | 4995|    244|		DO_FAST_RELOP2(op, vx->u.dval, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 4969|    244|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|    244|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|    244|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|    244|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|    244|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|    244|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|    488|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 31, False: 213]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|    244|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|    244|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|    244|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|    244|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 244]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|    244|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|    244|	else					\
  |  |  |  |  |  |  |  | 4883|    244|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 31, False: 213]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|    244|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 244]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|    244|    R_BCNodeStackTop--; \
  |  |  |  | 4973|    244|    R_Visible = TRUE; \
  |  |  |  | 4974|    244|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|    244|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|    244|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 244]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4996|    246|	}								\
  |  | 4997|  1.54M|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|  3.09M|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|   772k|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (4997:11): [True: 772k, False: 773k]
  |  |  |  Branch (4997:32): [True: 772k, False: 0]
  |  |  ------------------
  |  | 4998|   772k|	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |  124|  1.54M|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |   76|    231|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4998:10): [True: 231, False: 772k]
  |  |  |  Branch (4998:32): [True: 231, False: 0]
  |  |  ------------------
  |  | 4999|   772k|		DO_FAST_RELOP2(op, vx->u.ival, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 4969|    231|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|    231|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|    231|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|    231|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|    231|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|    231|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|    462|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 97, False: 134]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|    231|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|    231|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|    231|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|    231|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 231]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|    231|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|    231|	else					\
  |  |  |  |  |  |  |  | 4883|    231|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 97, False: 134]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|    231|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 231]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|    231|    R_BCNodeStackTop--; \
  |  |  |  | 4973|    231|    R_Visible = TRUE; \
  |  |  |  | 4974|    231|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|    231|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|    231|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 231]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5000|   772k|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|  1.54M|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|   772k|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5000:15): [True: 772k, False: 0]
  |  |  |  Branch (5000:36): [True: 772k, False: 0]
  |  |  ------------------
  |  | 5001|   772k|		DO_FAST_RELOP2(op, vx->u.ival, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 4969|   772k|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|   772k|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|   772k|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|   772k|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|   772k|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|   772k|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|  1.54M|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 387k, False: 385k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|   772k|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|   772k|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|   772k|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|   772k|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 772k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|   772k|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|   772k|	else					\
  |  |  |  |  |  |  |  | 4883|   772k|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 387k, False: 385k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|   772k|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 772k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|   772k|    R_BCNodeStackTop--; \
  |  |  |  | 4973|   772k|    R_Visible = TRUE; \
  |  |  |  | 4974|   772k|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|   772k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|   772k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 772k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5002|   772k|	    }								\
  |  | 5003|   772k|	}								\
  |  | 5004|  1.54M|	Relop2(opval, opsym);						\
  |  |  ------------------
  |  |  |  | 5125|  1.54M|#define Relop2(opval,opsym) NewBuiltin2(cmp_relop,opval,opsym,rho)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5105|  1.54M|#define NewBuiltin2(do_fun,opval,opsym,rho) do {	\
  |  |  |  |  |  | 5106|  1.54M|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5550|  1.54M|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5107|  1.54M|  SEXP x = GETSTACK(-2); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|  1.54M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|  1.54M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.54M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5108|  1.54M|  SEXP y = GETSTACK(-1); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|  1.54M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|  1.54M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 137, False: 1.54M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5109|  1.54M|  SETSTACK(-2, do_fun(call, opval, opsym, x, y,rho));	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|  1.54M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|  1.54M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|  1.54M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|  1.54M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.54M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|  1.54M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|  1.54M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|  1.54M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|  1.54M|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.54M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5110|  1.54M|  R_BCNodeStackTop--; \
  |  |  |  |  |  | 5111|  1.54M|  R_Visible = TRUE; \
  |  |  |  |  |  | 5112|  1.54M|  NEXT(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5655|  1.54M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5113|  1.54M|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5113:9): [Folded, False: 1.54M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5005|  1.54M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5005:14): [Folded, False: 1.54M]
  |  |  ------------------
  ------------------
 8217|  1.54M|    OP(NE, 1): FastRelop2(!=, NEOP, R_NeSym);
  ------------------
  |  | 5638|  1.54M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.54M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.54M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.54M|    goto loop; \
  |  | 5642|  1.54M|    op_##name
  ------------------
                  OP(NE, 1): FastRelop2(!=, NEOP, R_NeSym);
  ------------------
  |  | 4987|  2.63k|#define FastRelop2(op,opval,opsym) do {					\
  |  | 4988|  2.63k|	R_bcstack_t vvx, vvy;						\
  |  | 4989|  2.63k|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 2, &vvx);	\
  |  | 4990|  2.63k|	R_bcstack_t *vy = bcStackScalar(R_BCNodeStackTop - 1, &vvy);	\
  |  | 4991|  2.63k|	if (vx->tag == REALSXP && ! ISNAN(vx->u.dval)) {		\
  |  |  ------------------
  |  |  |  |  124|  5.27k|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	if (vx->tag == REALSXP && ! ISNAN(vx->u.dval)) {		\
  |  |  ------------------
  |  |  |  |   76|      2|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4991:6): [True: 2, False: 2.63k]
  |  |  |  Branch (4991:28): [True: 2, False: 0]
  |  |  ------------------
  |  | 4992|      2|	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |  124|      4|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4992:10): [True: 0, False: 2]
  |  |  |  Branch (4992:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 4993|      2|		DO_FAST_RELOP2(op, vx->u.dval, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 4969|      0|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|      0|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|      0|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|      0|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|      0|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|      0|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|      0|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|      0|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|      0|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|      0|	else					\
  |  |  |  |  |  |  |  | 4883|      0|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|      0|    R_BCNodeStackTop--; \
  |  |  |  | 4973|      0|    R_Visible = TRUE; \
  |  |  |  | 4974|      0|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4994|      2|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      2|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (4994:15): [True: 2, False: 0]
  |  |  |  Branch (4994:36): [True: 2, False: 0]
  |  |  ------------------
  |  | 4995|      2|		DO_FAST_RELOP2(op, vx->u.dval, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 4969|      2|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|      2|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      2|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|      2|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|      2|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|      2|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|      4|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|      2|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|      2|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|      2|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      2|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|      2|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|      2|	else					\
  |  |  |  |  |  |  |  | 4883|      2|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|      2|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|      2|    R_BCNodeStackTop--; \
  |  |  |  | 4973|      2|    R_Visible = TRUE; \
  |  |  |  | 4974|      2|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      2|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|      2|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4996|      2|	}								\
  |  | 4997|  2.63k|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|  5.27k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|  2.50k|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (4997:11): [True: 2.50k, False: 130]
  |  |  |  Branch (4997:32): [True: 2.50k, False: 0]
  |  |  ------------------
  |  | 4998|  2.50k|	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |  124|  5.01k|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |   76|     17|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4998:10): [True: 17, False: 2.48k]
  |  |  |  Branch (4998:32): [True: 17, False: 0]
  |  |  ------------------
  |  | 4999|  2.50k|		DO_FAST_RELOP2(op, vx->u.ival, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 4969|     17|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|     17|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|     17|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|     17|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|     17|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|     17|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|     34|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 0, False: 17]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|     17|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|     17|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|     17|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|     17|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 17]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|     17|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|     17|	else					\
  |  |  |  |  |  |  |  | 4883|     17|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 0, False: 17]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|     17|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 17]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|     17|    R_BCNodeStackTop--; \
  |  |  |  | 4973|     17|    R_Visible = TRUE; \
  |  |  |  | 4974|     17|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|     17|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|     17|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 17]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5000|  2.50k|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|  4.97k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|  2.48k|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5000:15): [True: 2.48k, False: 0]
  |  |  |  Branch (5000:36): [True: 2.48k, False: 0]
  |  |  ------------------
  |  | 5001|  2.48k|		DO_FAST_RELOP2(op, vx->u.ival, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 4969|  2.48k|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|  2.48k|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|  2.48k|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|  2.48k|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|  2.48k|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|  2.48k|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|  4.97k|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 14, False: 2.47k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|  2.48k|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|  2.48k|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|  2.48k|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|  2.48k|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 2.48k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|  2.48k|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|  2.48k|	else					\
  |  |  |  |  |  |  |  | 4883|  2.48k|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 14, False: 2.47k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|  2.48k|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 2.48k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|  2.48k|    R_BCNodeStackTop--; \
  |  |  |  | 4973|  2.48k|    R_Visible = TRUE; \
  |  |  |  | 4974|  2.48k|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|  2.48k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|  2.48k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 2.48k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5002|  2.48k|	    }								\
  |  | 5003|  2.50k|	}								\
  |  | 5004|  2.63k|	Relop2(opval, opsym);						\
  |  |  ------------------
  |  |  |  | 5125|  2.63k|#define Relop2(opval,opsym) NewBuiltin2(cmp_relop,opval,opsym,rho)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5105|  2.63k|#define NewBuiltin2(do_fun,opval,opsym,rho) do {	\
  |  |  |  |  |  | 5106|  2.63k|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5550|  2.63k|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5107|  2.63k|  SEXP x = GETSTACK(-2); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|  2.63k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|  2.63k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 2.63k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5108|  2.63k|  SEXP y = GETSTACK(-1); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|  2.63k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|  2.63k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 20, False: 2.61k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5109|  2.63k|  SETSTACK(-2, do_fun(call, opval, opsym, x, y,rho));	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|  2.63k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|  2.63k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|  2.63k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|  2.63k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 2.63k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|  2.63k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|  2.63k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|  2.63k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|  2.63k|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 2.63k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5110|  2.63k|  R_BCNodeStackTop--; \
  |  |  |  |  |  | 5111|  2.63k|  R_Visible = TRUE; \
  |  |  |  |  |  | 5112|  2.63k|  NEXT(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5655|  2.63k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5113|  2.63k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5113:9): [Folded, False: 2.63k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5005|  2.63k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5005:14): [Folded, False: 2.63k]
  |  |  ------------------
  ------------------
 8218|  2.64k|    OP(LT, 1): FastRelop2(<, LTOP, R_LtSym);
  ------------------
  |  | 5638|  2.64k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  2.64k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  2.64k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  2.64k|    goto loop; \
  |  | 5642|  2.64k|    op_##name
  ------------------
                  OP(LT, 1): FastRelop2(<, LTOP, R_LtSym);
  ------------------
  |  | 4987|     60|#define FastRelop2(op,opval,opsym) do {					\
  |  | 4988|     60|	R_bcstack_t vvx, vvy;						\
  |  | 4989|     60|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 2, &vvx);	\
  |  | 4990|     60|	R_bcstack_t *vy = bcStackScalar(R_BCNodeStackTop - 1, &vvy);	\
  |  | 4991|     60|	if (vx->tag == REALSXP && ! ISNAN(vx->u.dval)) {		\
  |  |  ------------------
  |  |  |  |  124|    120|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	if (vx->tag == REALSXP && ! ISNAN(vx->u.dval)) {		\
  |  |  ------------------
  |  |  |  |   76|      2|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4991:6): [True: 2, False: 58]
  |  |  |  Branch (4991:28): [True: 2, False: 0]
  |  |  ------------------
  |  | 4992|      2|	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |  124|      4|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4992:10): [True: 0, False: 2]
  |  |  |  Branch (4992:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 4993|      2|		DO_FAST_RELOP2(op, vx->u.dval, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 4969|      0|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|      0|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|      0|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|      0|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|      0|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|      0|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|      0|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|      0|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|      0|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|      0|	else					\
  |  |  |  |  |  |  |  | 4883|      0|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|      0|    R_BCNodeStackTop--; \
  |  |  |  | 4973|      0|    R_Visible = TRUE; \
  |  |  |  | 4974|      0|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4994|      2|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      2|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (4994:15): [True: 2, False: 0]
  |  |  |  Branch (4994:36): [True: 2, False: 0]
  |  |  ------------------
  |  | 4995|      2|		DO_FAST_RELOP2(op, vx->u.dval, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 4969|      2|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|      2|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      2|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|      2|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|      2|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|      2|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|      4|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|      2|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|      2|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|      2|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      2|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|      2|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|      2|	else					\
  |  |  |  |  |  |  |  | 4883|      2|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|      2|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|      2|    R_BCNodeStackTop--; \
  |  |  |  | 4973|      2|    R_Visible = TRUE; \
  |  |  |  | 4974|      2|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      2|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|      2|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4996|      2|	}								\
  |  | 4997|     60|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|    116|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|     32|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (4997:11): [True: 32, False: 26]
  |  |  |  Branch (4997:32): [True: 32, False: 0]
  |  |  ------------------
  |  | 4998|     32|	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |  124|     64|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |   76|     10|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4998:10): [True: 10, False: 22]
  |  |  |  Branch (4998:32): [True: 10, False: 0]
  |  |  ------------------
  |  | 4999|     32|		DO_FAST_RELOP2(op, vx->u.ival, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 4969|     10|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|     10|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|     10|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|     10|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|     10|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|     10|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|     20|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 0, False: 10]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|     10|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|     10|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|     10|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|     10|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 10]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|     10|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|     10|	else					\
  |  |  |  |  |  |  |  | 4883|     10|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 0, False: 10]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|     10|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 10]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|     10|    R_BCNodeStackTop--; \
  |  |  |  | 4973|     10|    R_Visible = TRUE; \
  |  |  |  | 4974|     10|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|     10|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|     10|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5000|     32|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|     44|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|     22|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5000:15): [True: 22, False: 0]
  |  |  |  Branch (5000:36): [True: 22, False: 0]
  |  |  ------------------
  |  | 5001|     22|		DO_FAST_RELOP2(op, vx->u.ival, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 4969|     22|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|     22|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|     22|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|     22|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|     22|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|     22|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|     44|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 12, False: 10]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|     22|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|     22|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|     22|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|     22|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 22]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|     22|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|     22|	else					\
  |  |  |  |  |  |  |  | 4883|     22|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 12, False: 10]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|     22|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 22]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|     22|    R_BCNodeStackTop--; \
  |  |  |  | 4973|     22|    R_Visible = TRUE; \
  |  |  |  | 4974|     22|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|     22|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|     22|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 22]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5002|     22|	    }								\
  |  | 5003|     32|	}								\
  |  | 5004|     60|	Relop2(opval, opsym);						\
  |  |  ------------------
  |  |  |  | 5125|     60|#define Relop2(opval,opsym) NewBuiltin2(cmp_relop,opval,opsym,rho)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5105|     60|#define NewBuiltin2(do_fun,opval,opsym,rho) do {	\
  |  |  |  |  |  | 5106|     60|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5550|     60|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5107|     60|  SEXP x = GETSTACK(-2); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|     60|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|     60|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 60]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5108|     60|  SEXP y = GETSTACK(-1); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|     60|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|     60|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 60]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5109|     60|  SETSTACK(-2, do_fun(call, opval, opsym, x, y,rho));	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|     60|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|     60|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|     60|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|     60|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 60]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|     60|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|     60|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|     60|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|     60|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 60]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5110|     60|  R_BCNodeStackTop--; \
  |  |  |  |  |  | 5111|     60|  R_Visible = TRUE; \
  |  |  |  |  |  | 5112|     60|  NEXT(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5655|     60|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5113|     60|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5113:9): [Folded, False: 60]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5005|     60|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5005:14): [Folded, False: 60]
  |  |  ------------------
  ------------------
 8219|     62|    OP(LE, 1): FastRelop2(<=, LEOP, R_LeSym);
  ------------------
  |  | 5638|     62|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|     62|    opinfo[name##_OP].argc = (n); \
  |  | 5640|     62|    opinfo[name##_OP].instname = #name; \
  |  | 5641|     62|    goto loop; \
  |  | 5642|     62|    op_##name
  ------------------
                  OP(LE, 1): FastRelop2(<=, LEOP, R_LeSym);
  ------------------
  |  | 4987|     14|#define FastRelop2(op,opval,opsym) do {					\
  |  | 4988|     14|	R_bcstack_t vvx, vvy;						\
  |  | 4989|     14|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 2, &vvx);	\
  |  | 4990|     14|	R_bcstack_t *vy = bcStackScalar(R_BCNodeStackTop - 1, &vvy);	\
  |  | 4991|     14|	if (vx->tag == REALSXP && ! ISNAN(vx->u.dval)) {		\
  |  |  ------------------
  |  |  |  |  124|     28|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	if (vx->tag == REALSXP && ! ISNAN(vx->u.dval)) {		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4991:6): [True: 0, False: 14]
  |  |  |  Branch (4991:28): [True: 0, False: 0]
  |  |  ------------------
  |  | 4992|      0|	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4992:10): [True: 0, False: 0]
  |  |  |  Branch (4992:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 4993|      0|		DO_FAST_RELOP2(op, vx->u.dval, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 4969|      0|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|      0|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|      0|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|      0|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|      0|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|      0|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|      0|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|      0|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|      0|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|      0|	else					\
  |  |  |  |  |  |  |  | 4883|      0|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|      0|    R_BCNodeStackTop--; \
  |  |  |  | 4973|      0|    R_Visible = TRUE; \
  |  |  |  | 4974|      0|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4994|      0|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (4994:15): [True: 0, False: 0]
  |  |  |  Branch (4994:36): [True: 0, False: 0]
  |  |  ------------------
  |  | 4995|      0|		DO_FAST_RELOP2(op, vx->u.dval, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 4969|      0|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|      0|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|      0|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|      0|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|      0|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|      0|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|      0|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|      0|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|      0|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|      0|	else					\
  |  |  |  |  |  |  |  | 4883|      0|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|      0|    R_BCNodeStackTop--; \
  |  |  |  | 4973|      0|    R_Visible = TRUE; \
  |  |  |  | 4974|      0|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4996|      0|	}								\
  |  | 4997|     14|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|     28|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|      6|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (4997:11): [True: 6, False: 8]
  |  |  |  Branch (4997:32): [True: 6, False: 0]
  |  |  ------------------
  |  | 4998|      6|	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |  124|     12|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |   76|      6|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4998:10): [True: 6, False: 0]
  |  |  |  Branch (4998:32): [True: 6, False: 0]
  |  |  ------------------
  |  | 4999|      6|		DO_FAST_RELOP2(op, vx->u.ival, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 4969|      6|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|      6|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      6|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|      6|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|      6|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|      6|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|     12|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 4, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|      6|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|      6|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|      6|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      6|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 6]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|      6|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|      6|	else					\
  |  |  |  |  |  |  |  | 4883|      6|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 4, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|      6|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 6]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|      6|    R_BCNodeStackTop--; \
  |  |  |  | 4973|      6|    R_Visible = TRUE; \
  |  |  |  | 4974|      6|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      6|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|      6|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 6]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5000|      6|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5000:15): [True: 0, False: 0]
  |  |  |  Branch (5000:36): [True: 0, False: 0]
  |  |  ------------------
  |  | 5001|      0|		DO_FAST_RELOP2(op, vx->u.ival, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 4969|      0|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|      0|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|      0|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|      0|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|      0|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|      0|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|      0|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|      0|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|      0|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|      0|	else					\
  |  |  |  |  |  |  |  | 4883|      0|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|      0|    R_BCNodeStackTop--; \
  |  |  |  | 4973|      0|    R_Visible = TRUE; \
  |  |  |  | 4974|      0|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5002|      0|	    }								\
  |  | 5003|      6|	}								\
  |  | 5004|     14|	Relop2(opval, opsym);						\
  |  |  ------------------
  |  |  |  | 5125|     14|#define Relop2(opval,opsym) NewBuiltin2(cmp_relop,opval,opsym,rho)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5105|     14|#define NewBuiltin2(do_fun,opval,opsym,rho) do {	\
  |  |  |  |  |  | 5106|     14|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5550|     14|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5107|     14|  SEXP x = GETSTACK(-2); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|     14|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|     14|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 14]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5108|     14|  SEXP y = GETSTACK(-1); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|     14|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|     14|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 8, False: 6]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5109|     14|  SETSTACK(-2, do_fun(call, opval, opsym, x, y,rho));	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|     14|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|     14|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|     14|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|     14|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 14]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|     14|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|     14|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|     14|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|     14|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 14]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5110|     14|  R_BCNodeStackTop--; \
  |  |  |  |  |  | 5111|     14|  R_Visible = TRUE; \
  |  |  |  |  |  | 5112|     14|  NEXT(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5655|     14|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5113|     14|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5113:9): [Folded, False: 14]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5005|     14|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5005:14): [Folded, False: 14]
  |  |  ------------------
  ------------------
 8220|    106|    OP(GE, 1): FastRelop2(>=, GEOP, R_GeSym);
  ------------------
  |  | 5638|     16|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|     16|    opinfo[name##_OP].argc = (n); \
  |  | 5640|     16|    opinfo[name##_OP].instname = #name; \
  |  | 5641|     16|    goto loop; \
  |  | 5642|    106|    op_##name
  ------------------
                  OP(GE, 1): FastRelop2(>=, GEOP, R_GeSym);
  ------------------
  |  | 4987|    106|#define FastRelop2(op,opval,opsym) do {					\
  |  | 4988|    106|	R_bcstack_t vvx, vvy;						\
  |  | 4989|    106|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 2, &vvx);	\
  |  | 4990|    106|	R_bcstack_t *vy = bcStackScalar(R_BCNodeStackTop - 1, &vvy);	\
  |  | 4991|    106|	if (vx->tag == REALSXP && ! ISNAN(vx->u.dval)) {		\
  |  |  ------------------
  |  |  |  |  124|    212|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	if (vx->tag == REALSXP && ! ISNAN(vx->u.dval)) {		\
  |  |  ------------------
  |  |  |  |   76|     66|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4991:6): [True: 66, False: 40]
  |  |  |  Branch (4991:28): [True: 66, False: 0]
  |  |  ------------------
  |  | 4992|     66|	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |  124|    132|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |   76|     66|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4992:10): [True: 66, False: 0]
  |  |  |  Branch (4992:32): [True: 66, False: 0]
  |  |  ------------------
  |  | 4993|     66|		DO_FAST_RELOP2(op, vx->u.dval, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 4969|     66|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|     66|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|     66|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|     66|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|     66|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|     66|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|    132|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 34, False: 32]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|     66|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|     66|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|     66|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|     66|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 66]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|     66|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|     66|	else					\
  |  |  |  |  |  |  |  | 4883|     66|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 34, False: 32]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|     66|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 66]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|     66|    R_BCNodeStackTop--; \
  |  |  |  | 4973|     66|    R_Visible = TRUE; \
  |  |  |  | 4974|     66|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|     66|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|     66|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 66]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4994|     66|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (4994:15): [True: 0, False: 0]
  |  |  |  Branch (4994:36): [True: 0, False: 0]
  |  |  ------------------
  |  | 4995|      0|		DO_FAST_RELOP2(op, vx->u.dval, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 4969|      0|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|      0|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|      0|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|      0|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|      0|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|      0|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|      0|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|      0|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|      0|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|      0|	else					\
  |  |  |  |  |  |  |  | 4883|      0|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|      0|    R_BCNodeStackTop--; \
  |  |  |  | 4973|      0|    R_Visible = TRUE; \
  |  |  |  | 4974|      0|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4996|     66|	}								\
  |  | 4997|    106|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|     80|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|     40|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (4997:11): [True: 40, False: 0]
  |  |  |  Branch (4997:32): [True: 40, False: 0]
  |  |  ------------------
  |  | 4998|     40|	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |  124|     80|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4998:10): [True: 0, False: 40]
  |  |  |  Branch (4998:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 4999|     40|		DO_FAST_RELOP2(op, vx->u.ival, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 4969|      0|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|      0|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|      0|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|      0|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|      0|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|      0|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|      0|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|      0|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|      0|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|      0|	else					\
  |  |  |  |  |  |  |  | 4883|      0|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|      0|    R_BCNodeStackTop--; \
  |  |  |  | 4973|      0|    R_Visible = TRUE; \
  |  |  |  | 4974|      0|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5000|     40|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|     80|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|     40|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5000:15): [True: 40, False: 0]
  |  |  |  Branch (5000:36): [True: 40, False: 0]
  |  |  ------------------
  |  | 5001|     40|		DO_FAST_RELOP2(op, vx->u.ival, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 4969|     40|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|     40|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|     40|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|     40|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|     40|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|     40|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|     80|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 36, False: 4]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|     40|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|     40|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|     40|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|     40|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 40]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|     40|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|     40|	else					\
  |  |  |  |  |  |  |  | 4883|     40|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 36, False: 4]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|     40|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 40]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|     40|    R_BCNodeStackTop--; \
  |  |  |  | 4973|     40|    R_Visible = TRUE; \
  |  |  |  | 4974|     40|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|     40|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|     40|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 40]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5002|     40|	    }								\
  |  | 5003|     40|	}								\
  |  | 5004|    106|	Relop2(opval, opsym);						\
  |  |  ------------------
  |  |  |  | 5125|    106|#define Relop2(opval,opsym) NewBuiltin2(cmp_relop,opval,opsym,rho)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5105|    106|#define NewBuiltin2(do_fun,opval,opsym,rho) do {	\
  |  |  |  |  |  | 5106|    106|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5550|    106|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5107|    106|  SEXP x = GETSTACK(-2); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|    106|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|    106|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 106]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5108|    106|  SEXP y = GETSTACK(-1); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|    106|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|    106|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 106]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5109|    106|  SETSTACK(-2, do_fun(call, opval, opsym, x, y,rho));	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|    106|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|    106|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|    106|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|    106|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 106]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|    106|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|    106|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|    106|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|    106|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 106]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5110|    106|  R_BCNodeStackTop--; \
  |  |  |  |  |  | 5111|    106|  R_Visible = TRUE; \
  |  |  |  |  |  | 5112|    106|  NEXT(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5655|    106|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5113|    106|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5113:9): [Folded, False: 106]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5005|    106|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5005:14): [Folded, False: 106]
  |  |  ------------------
  ------------------
 8221|  3.25k|    OP(GT, 1): FastRelop2(>, GTOP, R_GtSym);
  ------------------
  |  | 5638|    108|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    108|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    108|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    108|    goto loop; \
  |  | 5642|  3.25k|    op_##name
  ------------------
                  OP(GT, 1): FastRelop2(>, GTOP, R_GtSym);
  ------------------
  |  | 4987|  3.25k|#define FastRelop2(op,opval,opsym) do {					\
  |  | 4988|  3.25k|	R_bcstack_t vvx, vvy;						\
  |  | 4989|  3.25k|	R_bcstack_t *vx = bcStackScalar(R_BCNodeStackTop - 2, &vvx);	\
  |  | 4990|  3.25k|	R_bcstack_t *vy = bcStackScalar(R_BCNodeStackTop - 1, &vvy);	\
  |  | 4991|  3.25k|	if (vx->tag == REALSXP && ! ISNAN(vx->u.dval)) {		\
  |  |  ------------------
  |  |  |  |  124|  6.50k|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	if (vx->tag == REALSXP && ! ISNAN(vx->u.dval)) {		\
  |  |  ------------------
  |  |  |  |   76|    191|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4991:6): [True: 191, False: 3.06k]
  |  |  |  Branch (4991:28): [True: 191, False: 0]
  |  |  ------------------
  |  | 4992|    191|	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |  124|    382|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |   76|     35|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4992:10): [True: 35, False: 156]
  |  |  |  Branch (4992:32): [True: 35, False: 0]
  |  |  ------------------
  |  | 4993|    191|		DO_FAST_RELOP2(op, vx->u.dval, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 4969|     35|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|     35|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|     35|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|     35|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|     35|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|     35|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|     70|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 35, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|     35|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|     35|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|     35|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|     35|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 35]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|     35|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|     35|	else					\
  |  |  |  |  |  |  |  | 4883|     35|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 35, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|     35|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 35]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|     35|    R_BCNodeStackTop--; \
  |  |  |  | 4973|     35|    R_Visible = TRUE; \
  |  |  |  | 4974|     35|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|     35|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|     35|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 35]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4994|    191|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |  123|    312|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|    156|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (4994:15): [True: 156, False: 0]
  |  |  |  Branch (4994:36): [True: 156, False: 0]
  |  |  ------------------
  |  | 4995|    156|		DO_FAST_RELOP2(op, vx->u.dval, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 4969|    156|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|    156|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|    156|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|    156|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|    156|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|    156|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|    312|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 36, False: 120]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|    156|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|    156|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|    156|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|    156|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 156]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|    156|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|    156|	else					\
  |  |  |  |  |  |  |  | 4883|    156|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 36, False: 120]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|    156|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 156]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|    156|    R_BCNodeStackTop--; \
  |  |  |  | 4973|    156|    R_Visible = TRUE; \
  |  |  |  | 4974|    156|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|    156|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|    156|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 156]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4996|    191|	}								\
  |  | 4997|  3.25k|	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|  6.12k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	else if (vx->tag == INTSXP && vx->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|  2.87k|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (4997:11): [True: 2.87k, False: 183]
  |  |  |  Branch (4997:32): [True: 2.87k, False: 0]
  |  |  ------------------
  |  | 4998|  2.87k|	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |  124|  5.75k|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	    if (vy->tag == REALSXP && ! ISNAN(vy->u.dval))		\
  |  |  ------------------
  |  |  |  |   76|     43|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (4998:10): [True: 43, False: 2.83k]
  |  |  |  Branch (4998:32): [True: 43, False: 0]
  |  |  ------------------
  |  | 4999|  2.87k|		DO_FAST_RELOP2(op, vx->u.ival, vy->u.dval);		\
  |  |  ------------------
  |  |  |  | 4969|     43|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|     43|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|     43|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|     43|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|     43|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|     43|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|     86|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 25, False: 18]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|     43|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|     43|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|     43|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|     43|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 43]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|     43|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|     43|	else					\
  |  |  |  |  |  |  |  | 4883|     43|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 25, False: 18]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|     43|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 43]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|     43|    R_BCNodeStackTop--; \
  |  |  |  | 4973|     43|    R_Visible = TRUE; \
  |  |  |  | 4974|     43|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|     43|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|     43|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 43]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5000|  2.87k|	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |  123|  5.66k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	    else if (vy->tag == INTSXP && vy->u.ival != NA_INTEGER) {	\
  |  |  ------------------
  |  |  |  |   56|  2.83k|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (5000:15): [True: 2.83k, False: 0]
  |  |  |  Branch (5000:36): [True: 2.83k, False: 0]
  |  |  ------------------
  |  | 5001|  2.83k|		DO_FAST_RELOP2(op, vx->u.ival, vy->u.ival);		\
  |  |  ------------------
  |  |  |  | 4969|  2.83k|#define DO_FAST_RELOP2(op,a,b) do { \
  |  |  |  | 4970|  2.83k|    SKIP_OP(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5657|  2.83k|#define SKIP_OP() (pc++)
  |  |  |  |  ------------------
  |  |  |  | 4971|  2.83k|    SETSTACK_LOGICAL(-2, ((a) op (b)) ? TRUE : FALSE);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4911|  2.83k|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4877|  2.83k|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  |  |  |  |  | 4878|  5.66k|	int __v__ = (v);			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4878:15): [True: 660, False: 2.17k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4879|  2.83k|	(s)->tag = LGLSXP;			\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  121|  2.83k|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4880|  2.83k|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|  2.83k|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4880:6): [True: 0, False: 2.83k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4881|  2.83k|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4882|  2.83k|	else					\
  |  |  |  |  |  |  |  | 4883|  2.83k|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4883:20): [True: 660, False: 2.17k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4884|  2.83k|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4884:14): [Folded, False: 2.83k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4972|  2.83k|    R_BCNodeStackTop--; \
  |  |  |  | 4973|  2.83k|    R_Visible = TRUE; \
  |  |  |  | 4974|  2.83k|    NEXT(); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|  2.83k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 4975|  2.83k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4975:10): [Folded, False: 2.83k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5002|  2.83k|	    }								\
  |  | 5003|  2.87k|	}								\
  |  | 5004|  3.25k|	Relop2(opval, opsym);						\
  |  |  ------------------
  |  |  |  | 5125|  3.25k|#define Relop2(opval,opsym) NewBuiltin2(cmp_relop,opval,opsym,rho)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5105|  3.25k|#define NewBuiltin2(do_fun,opval,opsym,rho) do {	\
  |  |  |  |  |  | 5106|  3.25k|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5550|  3.25k|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5107|  3.25k|  SEXP x = GETSTACK(-2); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|  3.25k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|  3.25k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 3.25k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5108|  3.25k|  SEXP y = GETSTACK(-1); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|  3.25k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|  3.25k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 171, False: 3.08k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5109|  3.25k|  SETSTACK(-2, do_fun(call, opval, opsym, x, y,rho));	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|  3.25k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|  3.25k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|  3.25k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|  3.25k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 3.25k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|  3.25k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|  3.25k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|  3.25k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|  3.25k|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 3.25k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5110|  3.25k|  R_BCNodeStackTop--; \
  |  |  |  |  |  | 5111|  3.25k|  R_Visible = TRUE; \
  |  |  |  |  |  | 5112|  3.25k|  NEXT(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5655|  3.25k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5113|  3.25k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5113:9): [Folded, False: 3.25k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5005|  3.25k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5005:14): [Folded, False: 3.25k]
  |  |  ------------------
  ------------------
 8222|  3.25k|    OP(AND, 1): FastLogic2(&, ANDOP, R_AndSym);
  ------------------
  |  | 5638|  3.25k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  3.25k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  3.25k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  3.25k|    goto loop; \
  |  | 5642|  3.25k|    op_##name
  ------------------
                  OP(AND, 1): FastLogic2(&, ANDOP, R_AndSym);
  ------------------
  |  | 5008|      4|#define FastLogic2(op, opval, opsym) do {		\
  |  | 5009|      4|	Builtin2(do_logic, opsym, rho);		\
  |  |  ------------------
  |  |  |  | 5092|      4|#define Builtin2(do_fun,which,rho) do {					\
  |  |  |  | 5093|      4|	SEXP stack1 = GETSTACK(-1);					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      4|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      4|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 4]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5094|      4|	SEXP stack2 = GETSTACK(-2);					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      4|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      4|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 4]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5095|      4|	SEXP call = GETCONST(constants, GETOP());			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5550|      4|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  ------------------
  |  |  |  | 5096|      4|	SEXP tmp = CONS_NR(stack1, R_NilValue);				\
  |  |  |  | 5097|      4|	SETSTACK(-2, CONS_NR(stack2, tmp));				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      4|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      4|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      4|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      4|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 4]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      4|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      4|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      4|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      4|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 4]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5098|      4|	R_BCNodeStackTop--;						\
  |  |  |  | 5099|      4|	SETSTACK(-1, do_fun(call, getPrimitive(which, BUILTINSXP),	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      4|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      4|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      4|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      4|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 4]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      8|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 4]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4861|      4|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      4|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      4|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 4]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5100|      4|			    GETSTACK(-1), rho));			\
  |  |  |  | 5101|      4|	R_Visible = TRUE;						\
  |  |  |  | 5102|      4|	NEXT();								\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      4|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5103|      4|    } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5103:13): [Folded, False: 4]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5010|      4|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5010:14): [Folded, False: 4]
  |  |  ------------------
  ------------------
 8223|     40|    OP(OR, 1): FastLogic2(|, OROP, R_OrSym);
  ------------------
  |  | 5638|      6|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      6|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      6|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      6|    goto loop; \
  |  | 5642|     40|    op_##name
  ------------------
                  OP(OR, 1): FastLogic2(|, OROP, R_OrSym);
  ------------------
  |  | 5008|     40|#define FastLogic2(op, opval, opsym) do {		\
  |  | 5009|     40|	Builtin2(do_logic, opsym, rho);		\
  |  |  ------------------
  |  |  |  | 5092|     40|#define Builtin2(do_fun,which,rho) do {					\
  |  |  |  | 5093|     40|	SEXP stack1 = GETSTACK(-1);					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|     40|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|     40|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 40]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5094|     40|	SEXP stack2 = GETSTACK(-2);					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|     40|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|     40|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 40]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5095|     40|	SEXP call = GETCONST(constants, GETOP());			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5550|     40|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  ------------------
  |  |  |  | 5096|     40|	SEXP tmp = CONS_NR(stack1, R_NilValue);				\
  |  |  |  | 5097|     40|	SETSTACK(-2, CONS_NR(stack2, tmp));				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|     40|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|     40|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|     40|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|     40|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 40]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|     40|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|     40|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|     40|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|     40|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 40]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5098|     40|	R_BCNodeStackTop--;						\
  |  |  |  | 5099|     40|	SETSTACK(-1, do_fun(call, getPrimitive(which, BUILTINSXP),	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|     40|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|     40|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|     40|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|     40|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 40]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|     80|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 40]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4861|     40|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|     40|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|     40|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 40]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5100|     40|			    GETSTACK(-1), rho));			\
  |  |  |  | 5101|     40|	R_Visible = TRUE;						\
  |  |  |  | 5102|     40|	NEXT();								\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|     40|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5103|     40|    } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5103:13): [Folded, False: 40]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5010|     40|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5010:14): [Folded, False: 40]
  |  |  ------------------
  ------------------
 8224|   790k|    OP(NOT, 1):
  ------------------
  |  | 5638|     42|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|     42|    opinfo[name##_OP].argc = (n); \
  |  | 5640|     42|    opinfo[name##_OP].instname = #name; \
  |  | 5641|     42|    goto loop; \
  |  | 5642|   790k|    op_##name
  ------------------
 8225|   790k|      {
 8226|   790k|	  R_Visible = TRUE;
 8227|   790k|	  R_bcstack_t *s = R_BCNodeStackTop - 1;
 8228|   790k|	  if (s->tag == LGLSXP) {
  ------------------
  |  |  121|   790k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (8228:8): [True: 83, False: 790k]
  ------------------
 8229|     83|	      int ival = s->u.ival;
 8230|     83|	      if (ival != NA_LOGICAL)
  ------------------
  |  |   55|     83|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (8230:12): [True: 83, False: 0]
  ------------------
 8231|     83|		  s->u.ival = ival ? FALSE : TRUE;
  ------------------
  |  Branch (8231:17): [True: 29, False: 54]
  ------------------
 8232|     83|	      SKIP_OP();
  ------------------
  |  | 5657|     83|#define SKIP_OP() (pc++)
  ------------------
 8233|     83|	      NEXT();
  ------------------
  |  | 5655|     83|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8234|     83|	  }
 8235|   790k|	  Builtin1(do_logic, R_NotSym, rho);
  ------------------
  |  | 5083|   790k|#define Builtin1(do_fun,which,rho) do {					\
  |  | 5084|   790k|	SEXP call = GETCONST(constants, GETOP());			\
  |  |  ------------------
  |  |  |  | 5550|   790k|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5085|   790k|	SETSTACK(-1, CONS_NR(GETSTACK(-1), R_NilValue));		\
  |  |  ------------------
  |  |  |  | 4905|   790k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|   790k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|   790k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|   790k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 790k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  1.58M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 790k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4861|   790k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|   790k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|   790k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 790k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5086|   790k|	SETSTACK(-1, do_fun(call, getPrimitive(which, BUILTINSXP),	\
  |  |  ------------------
  |  |  |  | 4905|   790k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|   790k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|   790k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|   790k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 790k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  1.58M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 790k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4861|   790k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|   790k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|   790k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 790k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5087|   790k|			    GETSTACK(-1), rho));			\
  |  | 5088|   790k|	R_Visible = TRUE;						\
  |  | 5089|   790k|	NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|   790k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5090|   790k|    } while(0)
  |  |  ------------------
  |  |  |  Branch (5090:13): [Folded, False: 790k]
  |  |  ------------------
  ------------------
 8236|   790k|      }
 8237|   790k|    OP(DOTSERR, 0): error(_("'...' used in an incorrect context"));
  ------------------
  |  | 5638|   790k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   790k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   790k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   790k|    goto loop; \
  |  | 5642|   790k|    op_##name
  ------------------
                  OP(DOTSERR, 0): error(_("'...' used in an incorrect context"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  OP(DOTSERR, 0): error(_("'...' used in an incorrect context"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 8238|  1.92M|    OP(STARTASSIGN, 1):
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|  1.92M|    op_##name
  ------------------
 8239|  1.92M|      {
 8240|  1.92M|	INCLNK_stack_commit();
 8241|  1.92M|	if (IS_STACKVAL_BOXED(-1)) {
  ------------------
  |  | 4886|  1.92M|#define IS_STACKVAL_BOXED(idx)	(R_BCNodeStackTop[idx].tag == 0)
  |  |  ------------------
  |  |  |  Branch (4886:32): [True: 1.92M, False: 89]
  |  |  ------------------
  ------------------
 8242|  1.92M|	    SEXP saverhs = GETSTACK(-1);
  ------------------
  |  | 4903|  1.92M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|  1.92M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.92M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8243|  1.92M|	    FIXUP_RHS_NAMED(saverhs);
  ------------------
  |  | 3308|  1.92M|#define FIXUP_RHS_NAMED(r) do { \
  |  | 3309|  1.92M|	SEXP __rhs__ = (r); \
  |  | 3310|  1.92M|	if (NAMED(__rhs__)) \
  |  |  ------------------
  |  |  |  Branch (3310:6): [True: 387k, False: 1.54M]
  |  |  ------------------
  |  | 3311|  1.92M|	    ENSURE_NAMEDMAX(__rhs__); \
  |  | 3312|  1.92M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (3312:14): [Folded, False: 1.92M]
  |  |  ------------------
  ------------------
 8244|  1.92M|	    int refrhs = MAYBE_REFERENCED(saverhs);
  ------------------
  |  |  251|  1.92M|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  ------------------
 8245|  1.92M|	    SETSTACK_FLAGS(-1, refrhs);
  ------------------
  |  | 4806|  1.92M|#define SETSTACK_FLAGS(n, v) (R_BCNodeStackTop[n].flags = (v))
  ------------------
 8246|  1.92M|	    if (refrhs) INCREMENT_REFCNT(saverhs);
  ------------------
  |  Branch (8246:10): [True: 387k, False: 1.54M]
  ------------------
 8247|  1.92M|	}
 8248|  1.92M|	int sidx = GETOP();
  ------------------
  |  | 5656|  1.92M|#define GETOP() (*pc++).i
  ------------------
 8249|  1.92M|	SEXP symbol = GETCONST(constants, sidx);
  ------------------
  |  | 5550|  1.92M|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8250|  1.92M|	SEXP cell = GET_BINDING_CELL_CACHE(symbol, rho, vcache, sidx);
 8251|  1.92M|	SEXP value = BINDING_VALUE(cell);
 8252|  1.92M|	R_varloc_t loc;
 8253|  1.92M|	if (value == R_UnboundValue ||
  ------------------
  |  Branch (8253:6): [True: 1.24k, False: 1.92M]
  ------------------
 8254|  1.92M|	    TYPEOF(value) == PROMSXP) {
  ------------------
  |  |  116|  1.92M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (8254:6): [True: 1.15M, False: 771k]
  ------------------
 8255|  1.15M|	    value = EnsureLocal(symbol, rho, &loc);
 8256|  1.15M|	    if (loc.cell == NULL)
  ------------------
  |  Branch (8256:10): [True: 0, False: 1.15M]
  ------------------
 8257|      0|		loc.cell = R_NilValue;
 8258|  1.15M|	}
 8259|   771k|	else loc.cell = cell;
 8260|       |
 8261|  1.92M|	int maybe_in_assign = ASSIGNMENT_PENDING(loc.cell);
 8262|  1.92M|	SET_ASSIGNMENT_PENDING(loc.cell, TRUE);
 8263|  1.92M|	BCNPUSH(loc.cell);
  ------------------
  |  | 5449|  1.92M|#define BCNPUSH(v) do { \
  |  | 5450|  1.92M|  SEXP __value__ = (v); \
  |  | 5451|  1.92M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5452|  1.92M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5452:7): [True: 0, False: 1.92M]
  |  |  ------------------
  |  | 5453|  1.92M|  SETSTACK(0, __value__); \
  |  |  ------------------
  |  |  |  | 4905|  1.92M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  1.92M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  1.92M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  1.92M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.92M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  1.92M|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|  1.92M|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  1.92M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  1.92M|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.92M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5454|  1.92M|  R_BCNodeStackTop = __ntop__; \
  |  | 5455|  1.92M|} while (0)
  |  |  ------------------
  |  |  |  Branch (5455:10): [Folded, False: 1.92M]
  |  |  ------------------
  ------------------
 8264|       |
 8265|  1.92M|	if (maybe_in_assign || MAYBE_SHARED(value))
  ------------------
  |  Branch (8265:6): [True: 0, False: 1.92M]
  |  Branch (8265:25): [True: 2.01k, False: 1.92M]
  ------------------
 8266|  2.01k|	    value = shallow_duplicate(value);
  ------------------
  |  | 1030|  2.01k|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 8267|  1.92M|	BCNPUSH(value);
  ------------------
  |  | 5449|  1.92M|#define BCNPUSH(v) do { \
  |  | 5450|  1.92M|  SEXP __value__ = (v); \
  |  | 5451|  1.92M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5452|  1.92M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5452:7): [True: 0, False: 1.92M]
  |  |  ------------------
  |  | 5453|  1.92M|  SETSTACK(0, __value__); \
  |  |  ------------------
  |  |  |  | 4905|  1.92M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  1.92M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  1.92M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  1.92M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.92M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  1.92M|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|  1.92M|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  1.92M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  1.92M|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.92M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5454|  1.92M|  R_BCNodeStackTop = __ntop__; \
  |  | 5455|  1.92M|} while (0)
  |  |  ------------------
  |  |  |  Branch (5455:10): [Folded, False: 1.92M]
  |  |  ------------------
  ------------------
 8268|       |
 8269|  1.92M|	BCNDUP3RD();
  ------------------
  |  | 5511|  1.92M|#define BCNDUP3RD() do {					\
  |  | 5512|  1.92M|	R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1;		\
  |  | 5513|  1.92M|	if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow();	\
  |  |  ------------------
  |  |  |  Branch (5513:6): [True: 0, False: 1.92M]
  |  |  ------------------
  |  | 5514|  1.92M|	__ntop__[-1] = __ntop__[-4];				\
  |  | 5515|  1.92M|	R_BCNodeStackTop = __ntop__;				\
  |  | 5516|  1.92M|    } while(0)
  |  |  ------------------
  |  |  |  Branch (5516:13): [Folded, False: 1.92M]
  |  |  ------------------
  ------------------
 8270|       |	/* top four stack entries are now
 8271|       |	   RHS value, LHS cell, LHS value, RHS value */
 8272|  1.92M|	NEXT();
  ------------------
  |  | 5655|  1.92M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8273|  1.92M|      }
 8274|  1.92M|    OP(ENDASSIGN, 1):
  ------------------
  |  | 5638|  1.92M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.92M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.92M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.92M|    goto loop; \
  |  | 5642|  1.92M|    op_##name
  ------------------
 8275|  1.92M|      {
 8276|  1.92M|	SEXP lhscell = GETSTACK(-2);
  ------------------
  |  | 4903|  1.92M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|  1.92M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.92M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8277|  1.92M|	SET_ASSIGNMENT_PENDING(lhscell, FALSE);
 8278|       |
 8279|  1.92M|	int sidx = GETOP();
  ------------------
  |  | 5656|  1.92M|#define GETOP() (*pc++).i
  ------------------
 8280|  1.92M|	SEXP symbol = GETCONST(constants, sidx);
  ------------------
  |  | 5550|  1.92M|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8281|  1.92M|	SEXP cell = GET_BINDING_CELL_CACHE(symbol, rho, vcache, sidx);
 8282|  1.92M|	SEXP value = GETSTACK(-1); /* leave on stack for GC protection */
  ------------------
  |  | 4903|  1.92M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|  1.92M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.92M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8283|  1.92M|	if (ALTREP(value)) {
  ------------------
  |  Branch (8283:6): [True: 8, False: 1.92M]
  ------------------
 8284|      8|	    SEXP v = try_assign_unwrap(value, symbol, rho, cell);
 8285|      8|	    if (v != value) {
  ------------------
  |  Branch (8285:10): [True: 8, False: 0]
  ------------------
 8286|      8|		SETSTACK(-1, v);
  ------------------
  |  | 4905|      8|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4858|      8|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      8|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      8|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 8]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      8|    SEXP __v__ = (v); \
  |  |  |  | 4861|      8|    (s)->tag = 0; \
  |  |  |  | 4862|      8|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      8|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 8]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8287|      8|		value = v;
 8288|      8|	    }
 8289|      8|	}
 8290|  1.92M|	INCREMENT_NAMED(value);
  ------------------
  |  |  222|  1.92M|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 1.92M]
  |  |  ------------------
  ------------------
 8291|  1.92M|	if (! SET_BINDING_VALUE(cell, value))
  ------------------
  |  Branch (8291:6): [True: 0, False: 1.92M]
  ------------------
 8292|      0|	    defineVar(symbol, value, rho);
  ------------------
  |  |  905|      0|#define defineVar		Rf_defineVar
  ------------------
 8293|  1.92M|	R_BCNodeStackTop -= 2; /* now pop cell and LHS value off the stack */
 8294|       |	/* original right-hand side value is now on top of stack again */
 8295|       |#ifdef OLD_RHS_NAMED
 8296|       |	/* we do not duplicate the right-hand side value, so to be
 8297|       |	   conservative mark the value as NAMED = NAMEDMAX */
 8298|       |	ENSURE_NAMEDMAX(GETSTACK(-1));
 8299|       |#else
 8300|  1.92M|	if (IS_STACKVAL_BOXED(-1)) {
  ------------------
  |  | 4886|  1.92M|#define IS_STACKVAL_BOXED(idx)	(R_BCNodeStackTop[idx].tag == 0)
  |  |  ------------------
  |  |  |  Branch (4886:32): [True: 1.92M, False: 89]
  |  |  ------------------
  ------------------
 8301|  1.92M|	    SEXP saverhs = GETSTACK(-1);
  ------------------
  |  | 4903|  1.92M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|  1.92M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.92M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8302|  1.92M|	    INCREMENT_NAMED(saverhs);
  ------------------
  |  |  222|  1.92M|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 1.92M]
  |  |  ------------------
  ------------------
 8303|  1.92M|	    int refrhs = GETSTACK_FLAGS(-1);
  ------------------
  |  | 4805|  1.92M|#define GETSTACK_FLAGS(n) (R_BCNodeStackTop[n].flags)
  ------------------
 8304|  1.92M|	    if (refrhs) DECREMENT_REFCNT(saverhs);
  ------------------
  |  Branch (8304:10): [True: 387k, False: 1.54M]
  ------------------
 8305|  1.92M|	}
 8306|  1.92M|#endif
 8307|  1.92M|	NEXT();
  ------------------
  |  | 5655|  1.92M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8308|  1.92M|      }
 8309|  1.92M|    OP(STARTSUBSET, 2): DO_STARTDISPATCH("[");
  ------------------
  |  | 5638|  1.92M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.92M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.92M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.92M|    goto loop; \
  |  | 5642|  1.92M|    op_##name
  ------------------
                  OP(STARTSUBSET, 2): DO_STARTDISPATCH("[");
  ------------------
  |  | 6143|    116|#define DO_STARTDISPATCH(generic) do { \
  |  | 6144|    116|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  ------------------
  |  |  |  | 5550|    116|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6145|    116|  int label = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|    116|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6146|    116|  SEXP value = GETSTACK(-1); \
  |  |  ------------------
  |  |  |  | 4903|    116|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|    116|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 116]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6147|    116|  if (isObject(value) && tryDispatch(generic, call, value, rho, &value)) {\
  |  |  ------------------
  |  |  |  |  959|    116|#define isObject		Rf_isObject
  |  |  ------------------
  |  |  |  Branch (6147:7): [True: 4, False: 112]
  |  |  |  Branch (6147:26): [True: 4, False: 0]
  |  |  ------------------
  |  | 6148|      4|    SETSTACK(-1, value);						\
  |  |  ------------------
  |  |  |  | 4905|      4|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      4|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      4|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      4|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 4]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      4|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      4|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      4|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      4|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 4]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6149|      4|    BC_CHECK_SIGINT(); \
  |  |  ------------------
  |  |  |  | 6281|      4|#define BC_CHECK_SIGINT() do {			\
  |  |  |  | 6282|      4|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   45|      4|#define BC_COUNT_DELTA 127
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6282:6): [True: 0, False: 4]
  |  |  |  |  ------------------
  |  |  |  | 6283|      0|	    bc_check_sigint();			\
  |  |  |  | 6284|      0|	    evalcount = 0;			\
  |  |  |  | 6285|      0|	}					\
  |  |  |  | 6286|      4|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6286:14): [Folded, False: 4]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6150|      4|    pc = codebase + label; \
  |  | 6151|      4|  } \
  |  | 6152|    116|  else { \
  |  | 6153|    112|    SEXP tag = TAG(CDR(call)); \
  |  | 6154|    112|    BCNPUSH(call); \
  |  |  ------------------
  |  |  |  | 5449|    112|#define BCNPUSH(v) do { \
  |  |  |  | 5450|    112|  SEXP __value__ = (v); \
  |  |  |  | 5451|    112|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|    112|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 112]
  |  |  |  |  ------------------
  |  |  |  | 5453|    112|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|    112|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|    112|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|    112|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|    112|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 112]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|    112|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|    112|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|    112|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|    112|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 112]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|    112|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|    112|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 112]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6155|    112|    INIT_CALL_FRAME(R_NilValue); \
  |  |  ------------------
  |  |  |  | 6039|    112|#define INIT_CALL_FRAME(fun) do { \
  |  |  |  | 6040|    112|	BCNPUSH(fun);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5449|    112|#define BCNPUSH(v) do { \
  |  |  |  |  |  | 5450|    112|  SEXP __value__ = (v); \
  |  |  |  |  |  | 5451|    112|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  |  |  | 5452|    112|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5452:7): [True: 0, False: 112]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5453|    112|  SETSTACK(0, __value__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|    112|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|    112|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|    112|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|    112|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 112]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|    112|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|    112|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|    112|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|    112|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 112]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5454|    112|  R_BCNodeStackTop = __ntop__; \
  |  |  |  |  |  | 5455|    112|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5455:10): [Folded, False: 112]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6041|    112|	INIT_CALL_FRAME_ARGS();	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 6031|    112|#define INIT_CALL_FRAME_ARGS() do { \
  |  |  |  |  |  | 6032|    112|	BCNSTACKCHECK(2);	  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5521|    112|#define BCNSTACKCHECK(n)  do {						\
  |  |  |  |  |  |  |  | 5522|    112|	if (R_BCNodeStackTop + (n) > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (5522:6): [True: 0, False: 112]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5523|    112|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (5523:14): [Folded, False: 112]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6033|    112|	SETSTACK(0, R_NilValue);  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|    112|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|    112|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|    112|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|    112|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 112]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|    112|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|    112|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|    112|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|    112|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 112]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6034|    112|	SETSTACK(1, R_NilValue);  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|    112|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|    112|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|    112|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|    112|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 112]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|    112|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|    112|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|    112|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|    112|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 112]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6035|    112|	R_BCNodeStackTop += 2;	  \
  |  |  |  |  |  | 6036|    112|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6036:14): [Folded, False: 112]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6042|    112|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6042:14): [Folded, False: 112]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6156|    112|    PUSHCALLARG(value); \
  |  |  ------------------
  |  |  |  | 6063|    112|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  | 6054|    112|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  |  |  | 6055|    112|	SEXP __cell__ =							\
  |  |  |  |  |  | 6056|    112|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6056:6): [Folded, False: 112]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6057|    112|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|    112|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|    112|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 112]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|    112|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|    112|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|    112|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|    112|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 112]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|    112|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|    112|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|    112|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|    112|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 112]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6057:6): [True: 112, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6058|    112|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6059|    112|	SETSTACK(-1, __cell__);						\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|    112|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|    112|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|    112|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|    112|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 112]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|    112|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|    112|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|    112|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|    112|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 112]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6060|    112|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6060:6): [Folded, False: 112]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6061|    112|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  540|    112|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  |  |  541|    112|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  |  |  542|    112|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  222|    112|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 112]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  543|    112|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  |  |  544|    112|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 112]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6062|    112|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6062:14): [Folded, False: 112]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6157|    112|    SETCALLARG_TAG(tag);   \
  |  |  ------------------
  |  |  |  | 6071|    112|#define SETCALLARG_TAG(t) do {			\
  |  |  |  | 6072|    112|	SEXP __tag__ = (t);			\
  |  |  |  | 6073|    112|	if (__tag__ != R_NilValue) {		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6073:6): [True: 0, False: 112]
  |  |  |  |  ------------------
  |  |  |  | 6074|      0|	    SEXP __cell__ = GETSTACK(-1);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6075|      0|	    if (__cell__ != R_NilValue)		   \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6075:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6076|      0|		SET_TAG(__cell__, CreateTag(__tag__));	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  904|      0|#define CreateTag		Rf_CreateTag
  |  |  |  |  ------------------
  |  |  |  | 6077|      0|	}						\
  |  |  |  | 6078|    112|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6078:14): [Folded, False: 112]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6158|    112|  } \
  |  | 6159|    116|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|    116|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6160|    116|} while (0)
  |  |  ------------------
  |  |  |  Branch (6160:10): [Folded, False: 116]
  |  |  ------------------
  ------------------
 8310|    118|    OP(DFLTSUBSET, 0): DO_DFLTDISPATCH(do_subset_dflt, R_SubsetSym);
  ------------------
  |  | 5638|    118|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    118|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    118|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    118|    goto loop; \
  |  | 5642|    118|    op_##name
  ------------------
                  OP(DFLTSUBSET, 0): DO_DFLTDISPATCH(do_subset_dflt, R_SubsetSym);
  ------------------
  |  | 6162|    112|#define DO_DFLTDISPATCH(fun, symbol) do { \
  |  | 6163|    112|  SEXP call = GETSTACK_BELOW_CALL_FRAME(-1); \
  |  |  ------------------
  |  |  |  | 6027|    112|#define GETSTACK_BELOW_CALL_FRAME(n) GETSTACK((n) - CALL_FRAME_SIZE())
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|    112|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|    112|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 112]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6164|    112|  SEXP args = BUILTIN_CALL_FRAME_ARGS(); \
  |  | 6165|    112|  SEXP value = fun(call, symbol, args, rho); \
  |  | 6166|    112|  POP_CALL_FRAME_PLUS(2, value); \
  |  |  ------------------
  |  |  |  | 6047|    112|#define POP_CALL_FRAME_PLUS(n, value) do {	\
  |  |  |  | 6048|    112|	R_BCNodeStackTop -= (2 + (n));		\
  |  |  |  | 6049|    112|	SETSTACK(-1, value);			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|    112|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|    112|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|    112|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|    112|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 112]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|    112|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|    112|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|    112|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|    112|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 112]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6050|    112|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6050:14): [Folded, False: 112]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6167|    112|  R_Visible = TRUE; \
  |  | 6168|    112|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|    112|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6169|    112|} while (0)
  |  |  ------------------
  |  |  |  Branch (6169:10): [Folded, False: 112]
  |  |  ------------------
  ------------------
 8311|    114|    OP(STARTSUBASSIGN, 2): DO_START_ASSIGN_DISPATCH("[<-");
  ------------------
  |  | 5638|    114|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    114|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    114|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    114|    goto loop; \
  |  | 5642|    114|    op_##name
  ------------------
                  OP(STARTSUBASSIGN, 2): DO_START_ASSIGN_DISPATCH("[<-");
  ------------------
  |  | 6171|      2|#define DO_START_ASSIGN_DISPATCH(generic) do { \
  |  | 6172|      2|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  ------------------
  |  |  |  | 5550|      2|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6173|      2|  int label = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|      2|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6174|      2|  SEXP lhs = GETSTACK(-2); \
  |  |  ------------------
  |  |  |  | 4903|      2|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      2|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 2]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6175|      2|  SEXP rhs = GETSTACK(-1); \
  |  |  ------------------
  |  |  |  | 4903|      2|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      2|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 2]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6176|      2|  MARK_ASSIGNMENT_CALL(call); \
  |  | 6177|      2|  if (MAYBE_SHARED(lhs)) { \
  |  |  ------------------
  |  |  |  Branch (6177:7): [True: 0, False: 2]
  |  |  ------------------
  |  | 6178|      0|    lhs = shallow_duplicate(lhs); \
  |  |  ------------------
  |  |  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  |  |  ------------------
  |  | 6179|      0|    SETSTACK(-2, lhs); \
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6180|      0|    ENSURE_NAMED(lhs); \
  |  | 6181|      0|  } \
  |  | 6182|      2|  SEXP value = NULL; \
  |  | 6183|      2|  if (isObject(lhs) && \
  |  |  ------------------
  |  |  |  |  959|      2|#define isObject		Rf_isObject
  |  |  ------------------
  |  |  |  Branch (6183:7): [True: 2, False: 0]
  |  |  ------------------
  |  | 6184|      2|      tryAssignDispatch(generic, call, lhs, rhs, rho, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6184:7): [True: 2, False: 0]
  |  |  ------------------
  |  | 6185|      2|    R_BCNodeStackTop--;	\
  |  | 6186|      2|    SETSTACK(-1, value); \
  |  |  ------------------
  |  |  |  | 4905|      2|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      2|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      2|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      2|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      2|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      2|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      2|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      2|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 2]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6187|      2|    BC_CHECK_SIGINT(); \
  |  |  ------------------
  |  |  |  | 6281|      2|#define BC_CHECK_SIGINT() do {			\
  |  |  |  | 6282|      2|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   45|      2|#define BC_COUNT_DELTA 127
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6282:6): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  | 6283|      0|	    bc_check_sigint();			\
  |  |  |  | 6284|      0|	    evalcount = 0;			\
  |  |  |  | 6285|      0|	}					\
  |  |  |  | 6286|      2|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6286:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6188|      2|    pc = codebase + label; \
  |  | 6189|      2|  } \
  |  | 6190|      2|  else { \
  |  | 6191|      0|    SEXP tag = TAG(CDR(call)); \
  |  | 6192|      0|    BCNPUSH(call); \
  |  |  ------------------
  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6193|      0|    INIT_CALL_FRAME(R_NilValue); \
  |  |  ------------------
  |  |  |  | 6039|      0|#define INIT_CALL_FRAME(fun) do { \
  |  |  |  | 6040|      0|	BCNPUSH(fun);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6041|      0|	INIT_CALL_FRAME_ARGS();	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 6031|      0|#define INIT_CALL_FRAME_ARGS() do { \
  |  |  |  |  |  | 6032|      0|	BCNSTACKCHECK(2);	  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5521|      0|#define BCNSTACKCHECK(n)  do {						\
  |  |  |  |  |  |  |  | 5522|      0|	if (R_BCNodeStackTop + (n) > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (5522:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5523|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (5523:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6033|      0|	SETSTACK(0, R_NilValue);  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6034|      0|	SETSTACK(1, R_NilValue);  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6035|      0|	R_BCNodeStackTop += 2;	  \
  |  |  |  |  |  | 6036|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6036:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6042|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6042:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6194|      0|    PUSHCALLARG(lhs); \
  |  |  ------------------
  |  |  |  | 6063|      0|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  | 6054|      0|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  |  |  | 6055|      0|	SEXP __cell__ =							\
  |  |  |  |  |  | 6056|      0|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6056:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6057|      0|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6057:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6058|      0|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6059|      0|	SETSTACK(-1, __cell__);						\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6060|      0|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6060:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6061|      0|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  540|      0|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  |  |  541|      0|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  |  |  542|      0|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  543|      0|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  |  |  544|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6062|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6062:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6195|      0|    SETCALLARG_TAG(tag);   \
  |  |  ------------------
  |  |  |  | 6071|      0|#define SETCALLARG_TAG(t) do {			\
  |  |  |  | 6072|      0|	SEXP __tag__ = (t);			\
  |  |  |  | 6073|      0|	if (__tag__ != R_NilValue) {		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6073:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6074|      0|	    SEXP __cell__ = GETSTACK(-1);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6075|      0|	    if (__cell__ != R_NilValue)		   \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6075:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6076|      0|		SET_TAG(__cell__, CreateTag(__tag__));	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  904|      0|#define CreateTag		Rf_CreateTag
  |  |  |  |  ------------------
  |  |  |  | 6077|      0|	}						\
  |  |  |  | 6078|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6078:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6196|      0|  } \
  |  | 6197|      2|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      2|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6198|      2|} while (0)
  |  |  ------------------
  |  |  |  Branch (6198:10): [Folded, False: 2]
  |  |  ------------------
  ------------------
 8312|      4|    OP(DFLTSUBASSIGN, 0):
  ------------------
  |  | 5638|      4|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      4|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      4|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      4|    goto loop; \
  |  | 5642|      4|    op_##name
  ------------------
 8313|      0|      DO_DFLT_ASSIGN_DISPATCH(do_subassign_dflt, R_SubassignSym);
  ------------------
  |  | 6200|      0|#define DO_DFLT_ASSIGN_DISPATCH(fun, symbol) do { \
  |  | 6201|      0|  SEXP rhs = GETSTACK_BELOW_CALL_FRAME(-2); \
  |  |  ------------------
  |  |  |  | 6027|      0|#define GETSTACK_BELOW_CALL_FRAME(n) GETSTACK((n) - CALL_FRAME_SIZE())
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6202|      0|  SEXP call = GETSTACK_BELOW_CALL_FRAME(-1); \
  |  |  ------------------
  |  |  |  | 6027|      0|#define GETSTACK_BELOW_CALL_FRAME(n) GETSTACK((n) - CALL_FRAME_SIZE())
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6203|      0|  SEXP args = BUILTIN_CALL_FRAME_ARGS(); \
  |  | 6204|      0|  MARK_ASSIGNMENT_CALL(call); \
  |  | 6205|      0|  PUSHCALLARG(rhs); \
  |  |  ------------------
  |  |  |  | 6063|      0|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  | 6054|      0|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  |  |  | 6055|      0|	SEXP __cell__ =							\
  |  |  |  |  |  | 6056|      0|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6056:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6057|      0|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6057:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6058|      0|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6059|      0|	SETSTACK(-1, __cell__);						\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6060|      0|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6060:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6061|      0|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  540|      0|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  |  |  541|      0|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  |  |  542|      0|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  543|      0|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  |  |  544|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6062|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6062:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6206|      0|  SEXP value = fun(call, symbol, args, rho); \
  |  | 6207|      0|  POP_CALL_FRAME_PLUS(3, value); \
  |  |  ------------------
  |  |  |  | 6047|      0|#define POP_CALL_FRAME_PLUS(n, value) do {	\
  |  |  |  | 6048|      0|	R_BCNodeStackTop -= (2 + (n));		\
  |  |  |  | 6049|      0|	SETSTACK(-1, value);			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6050|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6050:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6208|      0|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6209|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (6209:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8314|      2|    OP(STARTC, 2): DO_STARTDISPATCH("c");             /* no longe used */
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
                  OP(STARTC, 2): DO_STARTDISPATCH("c");             /* no longe used */
  ------------------
  |  | 6143|      0|#define DO_STARTDISPATCH(generic) do { \
  |  | 6144|      0|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6145|      0|  int label = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6146|      0|  SEXP value = GETSTACK(-1); \
  |  |  ------------------
  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6147|      0|  if (isObject(value) && tryDispatch(generic, call, value, rho, &value)) {\
  |  |  ------------------
  |  |  |  |  959|      0|#define isObject		Rf_isObject
  |  |  ------------------
  |  |  |  Branch (6147:7): [True: 0, False: 0]
  |  |  |  Branch (6147:26): [True: 0, False: 0]
  |  |  ------------------
  |  | 6148|      0|    SETSTACK(-1, value);						\
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6149|      0|    BC_CHECK_SIGINT(); \
  |  |  ------------------
  |  |  |  | 6281|      0|#define BC_CHECK_SIGINT() do {			\
  |  |  |  | 6282|      0|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   45|      0|#define BC_COUNT_DELTA 127
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6282:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6283|      0|	    bc_check_sigint();			\
  |  |  |  | 6284|      0|	    evalcount = 0;			\
  |  |  |  | 6285|      0|	}					\
  |  |  |  | 6286|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6286:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6150|      0|    pc = codebase + label; \
  |  | 6151|      0|  } \
  |  | 6152|      0|  else { \
  |  | 6153|      0|    SEXP tag = TAG(CDR(call)); \
  |  | 6154|      0|    BCNPUSH(call); \
  |  |  ------------------
  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6155|      0|    INIT_CALL_FRAME(R_NilValue); \
  |  |  ------------------
  |  |  |  | 6039|      0|#define INIT_CALL_FRAME(fun) do { \
  |  |  |  | 6040|      0|	BCNPUSH(fun);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6041|      0|	INIT_CALL_FRAME_ARGS();	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 6031|      0|#define INIT_CALL_FRAME_ARGS() do { \
  |  |  |  |  |  | 6032|      0|	BCNSTACKCHECK(2);	  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5521|      0|#define BCNSTACKCHECK(n)  do {						\
  |  |  |  |  |  |  |  | 5522|      0|	if (R_BCNodeStackTop + (n) > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (5522:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5523|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (5523:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6033|      0|	SETSTACK(0, R_NilValue);  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6034|      0|	SETSTACK(1, R_NilValue);  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6035|      0|	R_BCNodeStackTop += 2;	  \
  |  |  |  |  |  | 6036|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6036:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6042|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6042:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6156|      0|    PUSHCALLARG(value); \
  |  |  ------------------
  |  |  |  | 6063|      0|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  | 6054|      0|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  |  |  | 6055|      0|	SEXP __cell__ =							\
  |  |  |  |  |  | 6056|      0|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6056:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6057|      0|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6057:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6058|      0|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6059|      0|	SETSTACK(-1, __cell__);						\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6060|      0|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6060:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6061|      0|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  540|      0|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  |  |  541|      0|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  |  |  542|      0|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  543|      0|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  |  |  544|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6062|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6062:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6157|      0|    SETCALLARG_TAG(tag);   \
  |  |  ------------------
  |  |  |  | 6071|      0|#define SETCALLARG_TAG(t) do {			\
  |  |  |  | 6072|      0|	SEXP __tag__ = (t);			\
  |  |  |  | 6073|      0|	if (__tag__ != R_NilValue) {		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6073:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6074|      0|	    SEXP __cell__ = GETSTACK(-1);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6075|      0|	    if (__cell__ != R_NilValue)		   \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6075:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6076|      0|		SET_TAG(__cell__, CreateTag(__tag__));	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  904|      0|#define CreateTag		Rf_CreateTag
  |  |  |  |  ------------------
  |  |  |  | 6077|      0|	}						\
  |  |  |  | 6078|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6078:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6158|      0|  } \
  |  | 6159|      0|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6160|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (6160:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8315|      2|    OP(DFLTC, 0): DO_DFLTDISPATCH(do_c_dflt, R_CSym); /* no longe used */
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
                  OP(DFLTC, 0): DO_DFLTDISPATCH(do_c_dflt, R_CSym); /* no longe used */
  ------------------
  |  | 6162|      0|#define DO_DFLTDISPATCH(fun, symbol) do { \
  |  | 6163|      0|  SEXP call = GETSTACK_BELOW_CALL_FRAME(-1); \
  |  |  ------------------
  |  |  |  | 6027|      0|#define GETSTACK_BELOW_CALL_FRAME(n) GETSTACK((n) - CALL_FRAME_SIZE())
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6164|      0|  SEXP args = BUILTIN_CALL_FRAME_ARGS(); \
  |  | 6165|      0|  SEXP value = fun(call, symbol, args, rho); \
  |  | 6166|      0|  POP_CALL_FRAME_PLUS(2, value); \
  |  |  ------------------
  |  |  |  | 6047|      0|#define POP_CALL_FRAME_PLUS(n, value) do {	\
  |  |  |  | 6048|      0|	R_BCNodeStackTop -= (2 + (n));		\
  |  |  |  | 6049|      0|	SETSTACK(-1, value);			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6050|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6050:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6167|      0|  R_Visible = TRUE; \
  |  | 6168|      0|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6169|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (6169:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8316|   770k|    OP(STARTSUBSET2, 2): DO_STARTDISPATCH("[[");
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|   770k|    op_##name
  ------------------
                  OP(STARTSUBSET2, 2): DO_STARTDISPATCH("[[");
  ------------------
  |  | 6143|   770k|#define DO_STARTDISPATCH(generic) do { \
  |  | 6144|   770k|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  ------------------
  |  |  |  | 5550|   770k|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6145|   770k|  int label = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|   770k|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6146|   770k|  SEXP value = GETSTACK(-1); \
  |  |  ------------------
  |  |  |  | 4903|   770k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|   770k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 770k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6147|   770k|  if (isObject(value) && tryDispatch(generic, call, value, rho, &value)) {\
  |  |  ------------------
  |  |  |  |  959|   770k|#define isObject		Rf_isObject
  |  |  ------------------
  |  |  |  Branch (6147:7): [True: 0, False: 770k]
  |  |  |  Branch (6147:26): [True: 0, False: 0]
  |  |  ------------------
  |  | 6148|      0|    SETSTACK(-1, value);						\
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6149|      0|    BC_CHECK_SIGINT(); \
  |  |  ------------------
  |  |  |  | 6281|      0|#define BC_CHECK_SIGINT() do {			\
  |  |  |  | 6282|      0|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   45|      0|#define BC_COUNT_DELTA 127
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6282:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6283|      0|	    bc_check_sigint();			\
  |  |  |  | 6284|      0|	    evalcount = 0;			\
  |  |  |  | 6285|      0|	}					\
  |  |  |  | 6286|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6286:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6150|      0|    pc = codebase + label; \
  |  | 6151|      0|  } \
  |  | 6152|   770k|  else { \
  |  | 6153|   770k|    SEXP tag = TAG(CDR(call)); \
  |  | 6154|   770k|    BCNPUSH(call); \
  |  |  ------------------
  |  |  |  | 5449|   770k|#define BCNPUSH(v) do { \
  |  |  |  | 5450|   770k|  SEXP __value__ = (v); \
  |  |  |  | 5451|   770k|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|   770k|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 770k]
  |  |  |  |  ------------------
  |  |  |  | 5453|   770k|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|   770k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|   770k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|   770k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|   770k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 770k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|   770k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|   770k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|   770k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|   770k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 770k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|   770k|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|   770k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 770k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6155|   770k|    INIT_CALL_FRAME(R_NilValue); \
  |  |  ------------------
  |  |  |  | 6039|   770k|#define INIT_CALL_FRAME(fun) do { \
  |  |  |  | 6040|   770k|	BCNPUSH(fun);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5449|   770k|#define BCNPUSH(v) do { \
  |  |  |  |  |  | 5450|   770k|  SEXP __value__ = (v); \
  |  |  |  |  |  | 5451|   770k|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  |  |  | 5452|   770k|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5452:7): [True: 0, False: 770k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5453|   770k|  SETSTACK(0, __value__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|   770k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|   770k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|   770k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|   770k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 770k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|   770k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|   770k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|   770k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|   770k|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 770k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5454|   770k|  R_BCNodeStackTop = __ntop__; \
  |  |  |  |  |  | 5455|   770k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5455:10): [Folded, False: 770k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6041|   770k|	INIT_CALL_FRAME_ARGS();	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 6031|   770k|#define INIT_CALL_FRAME_ARGS() do { \
  |  |  |  |  |  | 6032|   770k|	BCNSTACKCHECK(2);	  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5521|   770k|#define BCNSTACKCHECK(n)  do {						\
  |  |  |  |  |  |  |  | 5522|   770k|	if (R_BCNodeStackTop + (n) > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (5522:6): [True: 0, False: 770k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5523|   770k|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (5523:14): [Folded, False: 770k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6033|   770k|	SETSTACK(0, R_NilValue);  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|   770k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|   770k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|   770k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|   770k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 770k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|   770k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|   770k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|   770k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|   770k|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 770k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6034|   770k|	SETSTACK(1, R_NilValue);  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|   770k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|   770k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|   770k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|   770k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 770k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|   770k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|   770k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|   770k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|   770k|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 770k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6035|   770k|	R_BCNodeStackTop += 2;	  \
  |  |  |  |  |  | 6036|   770k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6036:14): [Folded, False: 770k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6042|   770k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6042:14): [Folded, False: 770k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6156|   770k|    PUSHCALLARG(value); \
  |  |  ------------------
  |  |  |  | 6063|   770k|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  | 6054|   770k|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  |  |  | 6055|   770k|	SEXP __cell__ =							\
  |  |  |  |  |  | 6056|   770k|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6056:6): [Folded, False: 770k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6057|   770k|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|   770k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|   770k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 770k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|   770k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|   770k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|   770k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|   770k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 770k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|   770k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|   770k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|   770k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|   770k|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 770k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6057:6): [True: 770k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6058|   770k|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6059|   770k|	SETSTACK(-1, __cell__);						\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|   770k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|   770k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|   770k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|   770k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 770k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|   770k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|   770k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|   770k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|   770k|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 770k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6060|   770k|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6060:6): [Folded, False: 770k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6061|   770k|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  540|   770k|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  |  |  541|   770k|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  |  |  542|   770k|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  222|   770k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 770k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  543|   770k|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  |  |  544|   770k|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 770k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6062|   770k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6062:14): [Folded, False: 770k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6157|   770k|    SETCALLARG_TAG(tag);   \
  |  |  ------------------
  |  |  |  | 6071|   770k|#define SETCALLARG_TAG(t) do {			\
  |  |  |  | 6072|   770k|	SEXP __tag__ = (t);			\
  |  |  |  | 6073|   770k|	if (__tag__ != R_NilValue) {		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6073:6): [True: 0, False: 770k]
  |  |  |  |  ------------------
  |  |  |  | 6074|      0|	    SEXP __cell__ = GETSTACK(-1);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6075|      0|	    if (__cell__ != R_NilValue)		   \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6075:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6076|      0|		SET_TAG(__cell__, CreateTag(__tag__));	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  904|      0|#define CreateTag		Rf_CreateTag
  |  |  |  |  ------------------
  |  |  |  | 6077|      0|	}						\
  |  |  |  | 6078|   770k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6078:14): [Folded, False: 770k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6158|   770k|  } \
  |  | 6159|   770k|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|   770k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6160|   770k|} while (0)
  |  |  ------------------
  |  |  |  Branch (6160:10): [Folded, False: 770k]
  |  |  ------------------
  ------------------
 8317|   770k|    OP(DFLTSUBSET2, 0): DO_DFLTDISPATCH(do_subset2_dflt, R_Subset2Sym);
  ------------------
  |  | 5638|   770k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   770k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   770k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   770k|    goto loop; \
  |  | 5642|   770k|    op_##name
  ------------------
                  OP(DFLTSUBSET2, 0): DO_DFLTDISPATCH(do_subset2_dflt, R_Subset2Sym);
  ------------------
  |  | 6162|   770k|#define DO_DFLTDISPATCH(fun, symbol) do { \
  |  | 6163|   770k|  SEXP call = GETSTACK_BELOW_CALL_FRAME(-1); \
  |  |  ------------------
  |  |  |  | 6027|   770k|#define GETSTACK_BELOW_CALL_FRAME(n) GETSTACK((n) - CALL_FRAME_SIZE())
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|   770k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|   770k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 770k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6164|   770k|  SEXP args = BUILTIN_CALL_FRAME_ARGS(); \
  |  | 6165|   770k|  SEXP value = fun(call, symbol, args, rho); \
  |  | 6166|   770k|  POP_CALL_FRAME_PLUS(2, value); \
  |  |  ------------------
  |  |  |  | 6047|   770k|#define POP_CALL_FRAME_PLUS(n, value) do {	\
  |  |  |  | 6048|   770k|	R_BCNodeStackTop -= (2 + (n));		\
  |  |  |  | 6049|   770k|	SETSTACK(-1, value);			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|   770k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|   770k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|   770k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|   770k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 770k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|   770k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|   770k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|   770k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|   770k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 770k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6050|   770k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6050:14): [Folded, False: 770k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6167|   770k|  R_Visible = TRUE; \
  |  | 6168|   770k|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|   770k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6169|   770k|} while (0)
  |  |  ------------------
  |  |  |  Branch (6169:10): [Folded, False: 770k]
  |  |  ------------------
  ------------------
 8318|   770k|    OP(STARTSUBASSIGN2, 2): DO_START_ASSIGN_DISPATCH("[[<-");
  ------------------
  |  | 5638|   770k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   770k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   770k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   770k|    goto loop; \
  |  | 5642|   770k|    op_##name
  ------------------
                  OP(STARTSUBASSIGN2, 2): DO_START_ASSIGN_DISPATCH("[[<-");
  ------------------
  |  | 6171|      0|#define DO_START_ASSIGN_DISPATCH(generic) do { \
  |  | 6172|      0|  SEXP call = GETCONST(constants, GETOP()); \
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6173|      0|  int label = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6174|      0|  SEXP lhs = GETSTACK(-2); \
  |  |  ------------------
  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6175|      0|  SEXP rhs = GETSTACK(-1); \
  |  |  ------------------
  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6176|      0|  MARK_ASSIGNMENT_CALL(call); \
  |  | 6177|      0|  if (MAYBE_SHARED(lhs)) { \
  |  |  ------------------
  |  |  |  Branch (6177:7): [True: 0, False: 0]
  |  |  ------------------
  |  | 6178|      0|    lhs = shallow_duplicate(lhs); \
  |  |  ------------------
  |  |  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  |  |  ------------------
  |  | 6179|      0|    SETSTACK(-2, lhs); \
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6180|      0|    ENSURE_NAMED(lhs); \
  |  | 6181|      0|  } \
  |  | 6182|      0|  SEXP value = NULL; \
  |  | 6183|      0|  if (isObject(lhs) && \
  |  |  ------------------
  |  |  |  |  959|      0|#define isObject		Rf_isObject
  |  |  ------------------
  |  |  |  Branch (6183:7): [True: 0, False: 0]
  |  |  ------------------
  |  | 6184|      0|      tryAssignDispatch(generic, call, lhs, rhs, rho, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6184:7): [True: 0, False: 0]
  |  |  ------------------
  |  | 6185|      0|    R_BCNodeStackTop--;	\
  |  | 6186|      0|    SETSTACK(-1, value); \
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6187|      0|    BC_CHECK_SIGINT(); \
  |  |  ------------------
  |  |  |  | 6281|      0|#define BC_CHECK_SIGINT() do {			\
  |  |  |  | 6282|      0|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   45|      0|#define BC_COUNT_DELTA 127
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6282:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6283|      0|	    bc_check_sigint();			\
  |  |  |  | 6284|      0|	    evalcount = 0;			\
  |  |  |  | 6285|      0|	}					\
  |  |  |  | 6286|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6286:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6188|      0|    pc = codebase + label; \
  |  | 6189|      0|  } \
  |  | 6190|      0|  else { \
  |  | 6191|      0|    SEXP tag = TAG(CDR(call)); \
  |  | 6192|      0|    BCNPUSH(call); \
  |  |  ------------------
  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6193|      0|    INIT_CALL_FRAME(R_NilValue); \
  |  |  ------------------
  |  |  |  | 6039|      0|#define INIT_CALL_FRAME(fun) do { \
  |  |  |  | 6040|      0|	BCNPUSH(fun);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6041|      0|	INIT_CALL_FRAME_ARGS();	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 6031|      0|#define INIT_CALL_FRAME_ARGS() do { \
  |  |  |  |  |  | 6032|      0|	BCNSTACKCHECK(2);	  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5521|      0|#define BCNSTACKCHECK(n)  do {						\
  |  |  |  |  |  |  |  | 5522|      0|	if (R_BCNodeStackTop + (n) > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (5522:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5523|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (5523:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6033|      0|	SETSTACK(0, R_NilValue);  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6034|      0|	SETSTACK(1, R_NilValue);  \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6035|      0|	R_BCNodeStackTop += 2;	  \
  |  |  |  |  |  | 6036|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6036:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6042|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6042:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6194|      0|    PUSHCALLARG(lhs); \
  |  |  ------------------
  |  |  |  | 6063|      0|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  | 6054|      0|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  |  |  | 6055|      0|	SEXP __cell__ =							\
  |  |  |  |  |  | 6056|      0|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6056:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6057|      0|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6057:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6058|      0|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6059|      0|	SETSTACK(-1, __cell__);						\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6060|      0|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6060:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6061|      0|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  540|      0|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  |  |  541|      0|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  |  |  542|      0|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  543|      0|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  |  |  544|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6062|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6062:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6195|      0|    SETCALLARG_TAG(tag);   \
  |  |  ------------------
  |  |  |  | 6071|      0|#define SETCALLARG_TAG(t) do {			\
  |  |  |  | 6072|      0|	SEXP __tag__ = (t);			\
  |  |  |  | 6073|      0|	if (__tag__ != R_NilValue) {		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6073:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6074|      0|	    SEXP __cell__ = GETSTACK(-1);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6075|      0|	    if (__cell__ != R_NilValue)		   \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6075:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6076|      0|		SET_TAG(__cell__, CreateTag(__tag__));	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  904|      0|#define CreateTag		Rf_CreateTag
  |  |  |  |  ------------------
  |  |  |  | 6077|      0|	}						\
  |  |  |  | 6078|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6078:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6196|      0|  } \
  |  | 6197|      0|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6198|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (6198:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8319|      2|    OP(DFLTSUBASSIGN2, 0):
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
 8320|      0|      DO_DFLT_ASSIGN_DISPATCH(do_subassign2_dflt, R_Subassign2Sym);
  ------------------
  |  | 6200|      0|#define DO_DFLT_ASSIGN_DISPATCH(fun, symbol) do { \
  |  | 6201|      0|  SEXP rhs = GETSTACK_BELOW_CALL_FRAME(-2); \
  |  |  ------------------
  |  |  |  | 6027|      0|#define GETSTACK_BELOW_CALL_FRAME(n) GETSTACK((n) - CALL_FRAME_SIZE())
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6202|      0|  SEXP call = GETSTACK_BELOW_CALL_FRAME(-1); \
  |  |  ------------------
  |  |  |  | 6027|      0|#define GETSTACK_BELOW_CALL_FRAME(n) GETSTACK((n) - CALL_FRAME_SIZE())
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6203|      0|  SEXP args = BUILTIN_CALL_FRAME_ARGS(); \
  |  | 6204|      0|  MARK_ASSIGNMENT_CALL(call); \
  |  | 6205|      0|  PUSHCALLARG(rhs); \
  |  |  ------------------
  |  |  |  | 6063|      0|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  |  |  ------------------
  |  |  |  |  |  | 6054|      0|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  |  |  | 6055|      0|	SEXP __cell__ =							\
  |  |  |  |  |  | 6056|      0|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6056:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6057|      0|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6057:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6058|      0|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6059|      0|	SETSTACK(-1, __cell__);						\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6060|      0|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6060:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6061|      0|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  540|      0|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  |  |  541|      0|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  |  |  542|      0|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  543|      0|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  |  |  544|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 6062|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (6062:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6206|      0|  SEXP value = fun(call, symbol, args, rho); \
  |  | 6207|      0|  POP_CALL_FRAME_PLUS(3, value); \
  |  |  ------------------
  |  |  |  | 6047|      0|#define POP_CALL_FRAME_PLUS(n, value) do {	\
  |  |  |  | 6048|      0|	R_BCNodeStackTop -= (2 + (n));		\
  |  |  |  | 6049|      0|	SETSTACK(-1, value);			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6050|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6050:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6208|      0|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6209|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (6209:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8321|  8.24k|    OP(DOLLAR, 2):
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|  8.24k|    op_##name
  ------------------
 8322|  8.24k|      {
 8323|  8.24k|	int dispatched = FALSE;
 8324|  8.24k|	SEXP call = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|  8.24k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8325|  8.24k|	SEXP symbol = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|  8.24k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8326|  8.24k|	SEXP x = GETSTACK(-1);
  ------------------
  |  | 4903|  8.24k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|  8.24k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 8.24k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8327|  8.24k|	SEXP value = NULL;
 8328|  8.24k|	if (isObject(x)) {
  ------------------
  |  |  959|  8.24k|#define isObject		Rf_isObject
  ------------------
  |  Branch (8328:6): [True: 3.15k, False: 5.08k]
  ------------------
 8329|  3.15k|	    SEXP ncall;
 8330|  3.15k|	    PROTECT(ncall = duplicate(call));
  ------------------
  |  |  357|  3.15k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 8331|       |	    /**** hack to avoid evaluating the symbol */
 8332|  3.15k|	    SETCAR(CDDR(ncall), ScalarString(PRINTNAME(symbol)));
  ------------------
  |  | 1025|  3.15k|#define ScalarString		Rf_ScalarString
  ------------------
 8333|  3.15k|	    dispatched = tryDispatch("$", ncall, x, rho, &value);
 8334|  3.15k|	    UNPROTECT(1);
  ------------------
  |  |  358|  3.15k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 8335|  3.15k|	}
 8336|  8.24k|	if (dispatched)
  ------------------
  |  Branch (8336:6): [True: 0, False: 8.24k]
  ------------------
 8337|  8.24k|	    SETSTACK(-1, value);
  ------------------
  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8338|  8.24k|	else
 8339|  8.24k|	    SETSTACK(-1, R_subset3_dflt(x, PRINTNAME(symbol), call));
  ------------------
  |  | 4905|  8.24k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4858|  8.24k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|  8.24k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|  8.24k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 8.24k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|  8.24k|    SEXP __v__ = (v); \
  |  |  |  | 4861|  8.24k|    (s)->tag = 0; \
  |  |  |  | 4862|  8.24k|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|  8.24k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 8.24k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8340|  8.24k|	R_Visible = TRUE;
 8341|  8.24k|	NEXT();
  ------------------
  |  | 5655|  8.24k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8342|  8.24k|      }
 8343|   770k|    OP(DOLLARGETS, 2):
  ------------------
  |  | 5638|  8.24k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  8.24k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  8.24k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  8.24k|    goto loop; \
  |  | 5642|   770k|    op_##name
  ------------------
 8344|   770k|      {
 8345|   770k|	int dispatched = FALSE;
 8346|   770k|	SEXP call = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|   770k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8347|   770k|	SEXP symbol = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|   770k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8348|   770k|	SEXP x = GETSTACK(-2);
  ------------------
  |  | 4903|   770k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|   770k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 770k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8349|   770k|	SEXP rhs = GETSTACK(-1);
  ------------------
  |  | 4903|   770k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|   770k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 87, False: 770k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8350|   770k|	MARK_ASSIGNMENT_CALL(call);
 8351|   770k|	if (MAYBE_SHARED(x)) {
  ------------------
  |  Branch (8351:6): [True: 28, False: 770k]
  ------------------
 8352|     28|	    x = shallow_duplicate(x);
  ------------------
  |  | 1030|     28|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 8353|     28|	    SETSTACK(-2, x);
  ------------------
  |  | 4905|     28|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4858|     28|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|     28|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|     28|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 28]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|     28|    SEXP __v__ = (v); \
  |  |  |  | 4861|     28|    (s)->tag = 0; \
  |  |  |  | 4862|     28|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|     28|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 28]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8354|     28|	    ENSURE_NAMED(x);
 8355|     28|	}
 8356|   770k|	SEXP value = NULL;
 8357|   770k|	if (isObject(x)) {
  ------------------
  |  |  959|   770k|#define isObject		Rf_isObject
  ------------------
  |  Branch (8357:6): [True: 770k, False: 116]
  ------------------
 8358|   770k|	    SEXP ncall, prom;
 8359|   770k|	    PROTECT(ncall = duplicate(call));
  ------------------
  |  |  357|   770k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 8360|       |	    /**** hack to avoid evaluating the symbol */
 8361|   770k|	    SETCAR(CDDR(ncall), ScalarString(PRINTNAME(symbol)));
  ------------------
  |  | 1025|   770k|#define ScalarString		Rf_ScalarString
  ------------------
 8362|   770k|	    prom = mkRHSPROMISE(CADDDR(ncall), rhs);
 8363|   770k|	    SETCAR(CDDDR(ncall), prom);
 8364|   770k|	    dispatched = tryDispatch("$<-", ncall, x, rho, &value);
 8365|   770k|	    UNPROTECT(1);
  ------------------
  |  |  358|   770k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 8366|   770k|	}
 8367|   770k|	if (! dispatched)
  ------------------
  |  Branch (8367:6): [True: 770k, False: 0]
  ------------------
 8368|   770k|	  value = R_subassign3_dflt(call, x, symbol, rhs);
 8369|   770k|	R_BCNodeStackTop--;
 8370|   770k|	SETSTACK(-1, value);
  ------------------
  |  | 4905|   770k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4858|   770k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|   770k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|   770k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 770k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|   770k|    SEXP __v__ = (v); \
  |  |  |  | 4861|   770k|    (s)->tag = 0; \
  |  |  |  | 4862|   770k|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|   770k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 770k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8371|   770k|	NEXT();
  ------------------
  |  | 5655|   770k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8372|   770k|      }
 8373|   786k|    OP(ISNULL, 0): DO_ISTEST(isNull);
  ------------------
  |  | 5638|   770k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   770k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   770k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   770k|    goto loop; \
  |  | 5642|   786k|    op_##name
  ------------------
                  OP(ISNULL, 0): DO_ISTEST(isNull);
  ------------------
  |  | 6253|   786k|#define DO_ISTEST(fun) do { \
  |  | 6254|   786k|  SETSTACK(-1, fun(GETSTACK(-1)) ? R_TrueValue : R_FalseValue);	\
  |  |  ------------------
  |  |  |  | 4905|   786k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|   786k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|   786k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|   786k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 786k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  3.14M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 786k]
  |  |  |  |  |  |  |  Branch (4860:19): [True: 5.88k, False: 780k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4861|   786k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|   786k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|   786k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 786k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6255|   786k|  R_Visible = TRUE; \
  |  | 6256|   786k|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|   786k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6257|   786k|} while(0)
  |  |  ------------------
  |  |  |  Branch (6257:9): [Folded, False: 786k]
  |  |  ------------------
  ------------------
 8374|   786k|    OP(ISLOGICAL, 0): DO_ISTYPE(LGLSXP);
  ------------------
  |  | 5638|   786k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   786k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   786k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   786k|    goto loop; \
  |  | 5642|   786k|    op_##name
  ------------------
                  OP(ISLOGICAL, 0): DO_ISTYPE(LGLSXP);
  ------------------
  |  | 6258|  1.15k|#define DO_ISTYPE(type) do { \
  |  | 6259|  1.15k|  SETSTACK(-1, TYPEOF(GETSTACK(-1)) == type ? R_TrueValue : R_FalseValue); \
  |  |  ------------------
  |  |  |  | 4905|  1.15k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  1.15k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  1.15k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  1.15k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.15k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  4.62k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 1.15k]
  |  |  |  |  |  |  |  Branch (4860:19): [True: 1.12k, False: 36]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4861|  1.15k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  1.15k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  1.15k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.15k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6260|  1.15k|  R_Visible = TRUE; \
  |  | 6261|  1.15k|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|  1.15k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6262|  1.15k|} while (0)
  |  |  ------------------
  |  |  |  Branch (6262:10): [Folded, False: 1.15k]
  |  |  ------------------
  ------------------
 8375|  1.15k|    OP(ISINTEGER, 0): {
  ------------------
  |  | 5638|  1.15k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.15k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.15k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.15k|    goto loop; \
  |  | 5642|  1.15k|    op_##name
  ------------------
 8376|      5|	SEXP arg = GETSTACK(-1);
  ------------------
  |  | 4903|      5|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|      5|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 5]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8377|      5|	Rboolean test = (TYPEOF(arg) == INTSXP) && ! inherits(arg, "factor");
  ------------------
  |  |  123|      5|#define INTSXP	    13	  /* integer vectors */
  ------------------
              	Rboolean test = (TYPEOF(arg) == INTSXP) && ! inherits(arg, "factor");
  ------------------
  |  |  933|      2|#define inherits		Rf_inherits
  ------------------
  |  Branch (8377:18): [True: 2, False: 3]
  |  Branch (8377:45): [True: 2, False: 0]
  ------------------
 8378|      5|	SETSTACK(-1, test ? R_TrueValue : R_FalseValue);
  ------------------
  |  | 4905|      5|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4858|      5|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      5|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      5|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 5]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|     10|    SEXP __v__ = (v); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4860:19): [True: 2, False: 3]
  |  |  |  |  ------------------
  |  |  |  | 4861|      5|    (s)->tag = 0; \
  |  |  |  | 4862|      5|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      5|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 5]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8379|      5|	R_Visible = TRUE;
 8380|      5|	NEXT();
  ------------------
  |  | 5655|      5|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8381|      5|      }
 8382|      7|    OP(ISDOUBLE, 0): DO_ISTYPE(REALSXP);
  ------------------
  |  | 5638|      7|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      7|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      7|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      7|    goto loop; \
  |  | 5642|      7|    op_##name
  ------------------
                  OP(ISDOUBLE, 0): DO_ISTYPE(REALSXP);
  ------------------
  |  | 6258|      0|#define DO_ISTYPE(type) do { \
  |  | 6259|      0|  SETSTACK(-1, TYPEOF(GETSTACK(-1)) == type ? R_TrueValue : R_FalseValue); \
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6260|      0|  R_Visible = TRUE; \
  |  | 6261|      0|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6262|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (6262:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8383|      2|    OP(ISCOMPLEX, 0): DO_ISTYPE(CPLXSXP);
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
                  OP(ISCOMPLEX, 0): DO_ISTYPE(CPLXSXP);
  ------------------
  |  | 6258|      0|#define DO_ISTYPE(type) do { \
  |  | 6259|      0|  SETSTACK(-1, TYPEOF(GETSTACK(-1)) == type ? R_TrueValue : R_FalseValue); \
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6260|      0|  R_Visible = TRUE; \
  |  | 6261|      0|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6262|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (6262:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8384|  3.51k|    OP(ISCHARACTER, 0): DO_ISTYPE(STRSXP);
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|  3.51k|    op_##name
  ------------------
                  OP(ISCHARACTER, 0): DO_ISTYPE(STRSXP);
  ------------------
  |  | 6258|  3.51k|#define DO_ISTYPE(type) do { \
  |  | 6259|  3.51k|  SETSTACK(-1, TYPEOF(GETSTACK(-1)) == type ? R_TrueValue : R_FalseValue); \
  |  |  ------------------
  |  |  |  | 4905|  3.51k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  3.51k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  3.51k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  3.51k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 3.51k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  14.0k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 3.51k]
  |  |  |  |  |  |  |  Branch (4860:19): [True: 1.69k, False: 1.82k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4861|  3.51k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  3.51k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  3.51k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 3.51k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6260|  3.51k|  R_Visible = TRUE; \
  |  | 6261|  3.51k|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|  3.51k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6262|  3.51k|} while (0)
  |  |  ------------------
  |  |  |  Branch (6262:10): [Folded, False: 3.51k]
  |  |  ------------------
  ------------------
 8385|  3.51k|    OP(ISSYMBOL, 0): DO_ISTYPE(SYMSXP); /**** S4 thingy allowed now???*/
  ------------------
  |  | 5638|  3.51k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  3.51k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  3.51k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  3.51k|    goto loop; \
  |  | 5642|  3.51k|    op_##name
  ------------------
                  OP(ISSYMBOL, 0): DO_ISTYPE(SYMSXP); /**** S4 thingy allowed now???*/
  ------------------
  |  | 6258|  1.52k|#define DO_ISTYPE(type) do { \
  |  | 6259|  1.52k|  SETSTACK(-1, TYPEOF(GETSTACK(-1)) == type ? R_TrueValue : R_FalseValue); \
  |  |  ------------------
  |  |  |  | 4905|  1.52k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  1.52k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  1.52k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  1.52k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.52k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  6.11k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 1.52k]
  |  |  |  |  |  |  |  Branch (4860:19): [True: 25, False: 1.50k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4861|  1.52k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  1.52k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  1.52k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.52k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6260|  1.52k|  R_Visible = TRUE; \
  |  | 6261|  1.52k|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|  1.52k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6262|  1.52k|} while (0)
  |  |  ------------------
  |  |  |  Branch (6262:10): [Folded, False: 1.52k]
  |  |  ------------------
  ------------------
 8386|  3.32k|    OP(ISOBJECT, 0): DO_ISTEST(OBJECT);
  ------------------
  |  | 5638|  1.53k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.53k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.53k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.53k|    goto loop; \
  |  | 5642|  3.32k|    op_##name
  ------------------
                  OP(ISOBJECT, 0): DO_ISTEST(OBJECT);
  ------------------
  |  | 6253|  3.32k|#define DO_ISTEST(fun) do { \
  |  | 6254|  3.32k|  SETSTACK(-1, fun(GETSTACK(-1)) ? R_TrueValue : R_FalseValue);	\
  |  |  ------------------
  |  |  |  | 4905|  3.32k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  3.32k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  3.32k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  3.32k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 3.32k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  13.2k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 3.32k]
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 3.32k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4861|  3.32k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  3.32k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  3.32k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 3.32k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6255|  3.32k|  R_Visible = TRUE; \
  |  | 6256|  3.32k|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|  3.32k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6257|  3.32k|} while(0)
  |  |  ------------------
  |  |  |  Branch (6257:9): [Folded, False: 3.32k]
  |  |  ------------------
  ------------------
 8387|  3.32k|    OP(ISNUMERIC, 0): DO_ISTEST(isNumericOnly);
  ------------------
  |  | 5638|  3.32k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  3.32k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  3.32k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  3.32k|    goto loop; \
  |  | 5642|  3.32k|    op_##name
  ------------------
                  OP(ISNUMERIC, 0): DO_ISTEST(isNumericOnly);
  ------------------
  |  | 6253|      0|#define DO_ISTEST(fun) do { \
  |  | 6254|      0|  SETSTACK(-1, fun(GETSTACK(-1)) ? R_TrueValue : R_FalseValue);	\
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6255|      0|  R_Visible = TRUE; \
  |  | 6256|      0|  NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6257|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (6257:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8388|   389k|    OP(VECSUBSET, 1): DO_VECSUBSET(rho, FALSE);
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|   389k|    op_##name
  ------------------
                  OP(VECSUBSET, 1): DO_VECSUBSET(rho, FALSE);
  ------------------
  |  | 6407|   389k|#define DO_VECSUBSET(rho, sub2) do {					\
  |  | 6408|   389k|	int callidx = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|   389k|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6409|   389k|	R_bcstack_t *sx = R_BCNodeStackTop - 2;				\
  |  | 6410|   389k|	R_bcstack_t *si = R_BCNodeStackTop - 1;				\
  |  | 6411|   389k|	SEXP vec = GETSTACK_PTR(sx);					\
  |  |  ------------------
  |  |  |  | 4837|   389k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 389k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6412|   389k|	if (si->tag == INTSXP && (sub2 || FAST_VECELT_OK(vec))) {	\
  |  |  ------------------
  |  |  |  |  123|   778k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	if (si->tag == INTSXP && (sub2 || FAST_VECELT_OK(vec))) {	\
  |  |  ------------------
  |  |  |  | 6373|   386k|    (ATTRIB(vec) == R_NilValue ||		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6373:6): [True: 386k, False: 6]
  |  |  |  |  ------------------
  |  |  |  | 6374|   386k|     (TAG(ATTRIB(vec)) == R_DimSymbol &&	\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6374:7): [True: 0, False: 6]
  |  |  |  |  ------------------
  |  |  |  | 6375|      6|      CDR(ATTRIB(vec)) == R_NilValue))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6375:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (6412:6): [True: 386k, False: 2.29k]
  |  |  |  Branch (6412:28): [Folded, False: 386k]
  |  |  ------------------
  |  | 6413|   386k|	    R_xlen_t i = si->u.ival;					\
  |  | 6414|   386k|	    switch (TYPEOF(vec)) {					\
  |  |  ------------------
  |  |  |  Branch (6414:14): [True: 66, False: 386k]
  |  |  ------------------
  |  | 6415|      0|		case REALSXP:						\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (6415:3): [True: 0, False: 386k]
  |  |  ------------------
  |  | 6416|      0|		    if (i <= 0 || XLENGTH(vec) < i) break;		\
  |  |  ------------------
  |  |  |  Branch (6416:11): [True: 0, False: 0]
  |  |  |  Branch (6416:21): [True: 0, False: 0]
  |  |  ------------------
  |  | 6417|      0|		    SETSTACK_REAL_PTR(sx, REAL_ELT(vec, i - 1));	\
  |  |  ------------------
  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6418|      0|		    DFVE_NEXT();					\
  |  |  ------------------
  |  |  |  | 6401|      0|#define	DFVE_NEXT() do {	\
  |  |  |  | 6402|      0|	R_Visible = TRUE;	\
  |  |  |  | 6403|      0|	R_BCNodeStackTop--;	\
  |  |  |  | 6404|      0|	NEXT();			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6405|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6405:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6419|     66|		case INTSXP:						\
  |  |  ------------------
  |  |  |  |  123|     66|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (6419:3): [True: 66, False: 386k]
  |  |  ------------------
  |  | 6420|     66|		    if (i <= 0 || XLENGTH(vec) < i) break;		\
  |  |  ------------------
  |  |  |  Branch (6420:11): [True: 0, False: 66]
  |  |  |  Branch (6420:21): [True: 0, False: 66]
  |  |  ------------------
  |  | 6421|     66|		    SETSTACK_INTEGER_PTR(sx, INTEGER_ELT(vec, i - 1));	\
  |  |  ------------------
  |  |  |  | 4871|     66|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  | 4872|     66|    int __v__ = (v); \
  |  |  |  | 4873|     66|    (s)->tag = INTSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|     66|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 4874|     66|    (s)->u.ival = __v__; \
  |  |  |  | 4875|     66|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4875:10): [Folded, False: 66]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6422|     66|		    DFVE_NEXT();					\
  |  |  ------------------
  |  |  |  | 6401|     66|#define	DFVE_NEXT() do {	\
  |  |  |  | 6402|     66|	R_Visible = TRUE;	\
  |  |  |  | 6403|     66|	R_BCNodeStackTop--;	\
  |  |  |  | 6404|     66|	NEXT();			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|     66|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6405|     66|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6405:14): [Folded, False: 66]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6423|     66|		case LGLSXP:						\
  |  |  ------------------
  |  |  |  |  121|     66|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (6423:3): [True: 0, False: 386k]
  |  |  ------------------
  |  | 6424|     66|		    if (i <= 0 || XLENGTH(vec) < i) break;		\
  |  |  ------------------
  |  |  |  Branch (6424:11): [True: 66, False: 0]
  |  |  |  Branch (6424:21): [True: 0, False: 0]
  |  |  ------------------
  |  | 6425|     66|		    SETSTACK_LOGICAL_PTR(sx, LOGICAL_ELT(vec, i - 1));	\
  |  |  ------------------
  |  |  |  | 4877|     66|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  | 4878|     66|	int __v__ = (v);			\
  |  |  |  | 4879|     66|	(s)->tag = LGLSXP;			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|     66|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 4880|     66|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|     66|#define NA_LOGICAL	R_NaInt
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4880:6): [True: 0, False: 66]
  |  |  |  |  ------------------
  |  |  |  | 4881|     66|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  ------------------
  |  |  |  | 4882|     66|	else					\
  |  |  |  | 4883|     66|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4883:20): [True: 0, False: 66]
  |  |  |  |  ------------------
  |  |  |  | 4884|     66|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4884:14): [Folded, False: 66]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6426|     66|		    DFVE_NEXT();					\
  |  |  ------------------
  |  |  |  | 6401|     66|#define	DFVE_NEXT() do {	\
  |  |  |  | 6402|     66|	R_Visible = TRUE;	\
  |  |  |  | 6403|     66|	R_BCNodeStackTop--;	\
  |  |  |  | 6404|     66|	NEXT();			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|     66|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6405|     66|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6405:14): [Folded, False: 66]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6427|   386k|	    }								\
  |  | 6428|   386k|	}								\
  |  | 6429|   389k|	VECSUBSET_PTR(vec, si, sx, rho, constants, callidx, sub2);	\
  |  | 6430|   389k|	DFVE_NEXT();							\
  |  |  ------------------
  |  |  |  | 6401|   389k|#define	DFVE_NEXT() do {	\
  |  |  |  | 6402|   389k|	R_Visible = TRUE;	\
  |  |  |  | 6403|   389k|	R_BCNodeStackTop--;	\
  |  |  |  | 6404|   389k|	NEXT();			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|   389k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6405|   389k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6405:14): [Folded, False: 389k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6431|   389k|    } while(0)
  |  |  ------------------
  |  |  |  Branch (6431:13): [Folded, False: 389k]
  |  |  ------------------
  ------------------
 8389|   389k|    OP(MATSUBSET, 1): DO_MATSUBSET(rho, FALSE); NEXT();
  ------------------
  |  | 5638|   389k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   389k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   389k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   389k|    goto loop; \
  |  | 5642|   389k|    op_##name
  ------------------
                  OP(MATSUBSET, 1): DO_MATSUBSET(rho, FALSE); NEXT();
  ------------------
  |  | 6518|  2.29k|#define DO_MATSUBSET(rho, sub2) do {					\
  |  | 6519|  2.29k|	int callidx = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|  2.29k|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6520|  2.29k|	R_bcstack_t *sx = R_BCNodeStackTop - 3;				\
  |  | 6521|  2.29k|	MATSUBSET_PTR(sx, R_BCNodeStackTop - 2, R_BCNodeStackTop - 1,	\
  |  | 6522|  2.29k|		      sx, rho, constants, callidx, sub2);		\
  |  | 6523|  2.29k|	R_BCNodeStackTop -= 2;						\
  |  | 6524|  2.29k|	R_Visible = TRUE;						\
  |  | 6525|  2.29k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6525:14): [Folded, False: 2.29k]
  |  |  ------------------
  ------------------
                  OP(MATSUBSET, 1): DO_MATSUBSET(rho, FALSE); NEXT();
  ------------------
  |  | 5655|  2.29k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8390|  2.29k|    OP(VECSUBASSIGN, 1): DO_VECSUBASSIGN(rho, FALSE);
  ------------------
  |  | 5638|  2.29k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  2.29k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  2.29k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  2.29k|    goto loop; \
  |  | 5642|  2.29k|    op_##name
  ------------------
                  OP(VECSUBASSIGN, 1): DO_VECSUBASSIGN(rho, FALSE);
  ------------------
  |  | 6669|    301|#define DO_VECSUBASSIGN(rho, sub2) do {					\
  |  | 6670|    301|	int callidx = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|    301|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6671|    301|	R_bcstack_t *sx = R_BCNodeStackTop - 3;				\
  |  | 6672|    301|	R_bcstack_t *srhs = R_BCNodeStackTop - 2;			\
  |  | 6673|    301|	R_bcstack_t *si = R_BCNodeStackTop - 1;				\
  |  | 6674|    301|	SEXP vec = GETSTACK_PTR(sx);					\
  |  |  ------------------
  |  |  |  | 4837|    301|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 301]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6675|    301|	if (MAYBE_SHARED(vec)) {					\
  |  |  ------------------
  |  |  |  Branch (6675:6): [True: 0, False: 301]
  |  |  ------------------
  |  | 6676|      0|	    vec = shallow_duplicate(vec);				\
  |  |  ------------------
  |  |  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  |  |  ------------------
  |  | 6677|      0|	    SETSTACK_PTR(sx, vec);					\
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6678|      0|	}								\
  |  | 6679|    301|	if (srhs->tag && si->tag == INTSXP &&				\
  |  |  ------------------
  |  |  |  |  123|    303|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (6679:6): [True: 2, False: 299]
  |  |  |  Branch (6679:19): [True: 2, False: 0]
  |  |  ------------------
  |  | 6680|    301|	    srhs->tag == TYPEOF(vec)) {					\
  |  |  ------------------
  |  |  |  Branch (6680:6): [True: 2, False: 0]
  |  |  ------------------
  |  | 6681|      2|	    R_xlen_t i = si->u.ival;					\
  |  | 6682|      2|	    /* i >= 0 rules out NA_INTEGER */				\
  |  | 6683|      2|	    if (i > 0 && i <= XLENGTH(vec)) {				\
  |  |  ------------------
  |  |  |  Branch (6683:10): [True: 2, False: 0]
  |  |  |  Branch (6683:19): [True: 2, False: 0]
  |  |  ------------------
  |  | 6684|      2|		switch (TYPEOF(vec)) {					\
  |  |  ------------------
  |  |  |  Branch (6684:11): [True: 2, False: 0]
  |  |  ------------------
  |  | 6685|      0|		case REALSXP:						\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (6685:3): [True: 0, False: 2]
  |  |  ------------------
  |  | 6686|      0|		    REAL(vec)[i - 1] = srhs->u.dval;			\
  |  | 6687|      0|		    DFVA_NEXT(sx, vec);					\
  |  |  ------------------
  |  |  |  | 6662|      0|#define DFVA_NEXT(sx, vec) do {		\
  |  |  |  | 6663|      0|	SETSTACK_PTR(sx, vec);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6664|      0|	SETTER_CLEAR_NAMED(vec);	\
  |  |  |  | 6665|      0|	R_BCNodeStackTop -= 2;		\
  |  |  |  | 6666|      0|	NEXT();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6667|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6667:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6688|      0|		case INTSXP:						\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (6688:3): [True: 0, False: 2]
  |  |  ------------------
  |  | 6689|      0|		    INTEGER(vec)[i - 1] = srhs->u.ival;			\
  |  | 6690|      0|		    DFVA_NEXT(sx, vec);					\
  |  |  ------------------
  |  |  |  | 6662|      0|#define DFVA_NEXT(sx, vec) do {		\
  |  |  |  | 6663|      0|	SETSTACK_PTR(sx, vec);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6664|      0|	SETTER_CLEAR_NAMED(vec);	\
  |  |  |  | 6665|      0|	R_BCNodeStackTop -= 2;		\
  |  |  |  | 6666|      0|	NEXT();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6667|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6667:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6691|      2|		case LGLSXP:						\
  |  |  ------------------
  |  |  |  |  121|      2|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (6691:3): [True: 2, False: 0]
  |  |  ------------------
  |  | 6692|      2|		    LOGICAL(vec)[i - 1] = srhs->u.ival;			\
  |  | 6693|      2|		    DFVA_NEXT(sx, vec);					\
  |  |  ------------------
  |  |  |  | 6662|      2|#define DFVA_NEXT(sx, vec) do {		\
  |  |  |  | 6663|      2|	SETSTACK_PTR(sx, vec);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      2|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      2|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      2|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      2|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      2|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      2|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      2|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 2]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6664|      2|	SETTER_CLEAR_NAMED(vec);	\
  |  |  |  | 6665|      2|	R_BCNodeStackTop -= 2;		\
  |  |  |  | 6666|      2|	NEXT();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      2|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6667|      2|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6667:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6694|      2|		}							\
  |  | 6695|      2|	    }								\
  |  | 6696|      2|	}								\
  |  | 6697|    301|	VECSUBASSIGN_PTR(vec, srhs, si, sx, rho, constants, callidx, sub2); \
  |  | 6698|    299|	R_BCNodeStackTop -= 2;						\
  |  | 6699|    299|	NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|    299|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6700|    299|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6700:14): [Folded, False: 299]
  |  |  ------------------
  ------------------
 8391|    301|    OP(MATSUBASSIGN, 1): DO_MATSUBASSIGN(rho, FALSE); NEXT();
  ------------------
  |  | 5638|    301|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    301|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    301|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    301|    goto loop; \
  |  | 5642|    301|    op_##name
  ------------------
                  OP(MATSUBASSIGN, 1): DO_MATSUBASSIGN(rho, FALSE); NEXT();
  ------------------
  |  | 6749|      8|#define DO_MATSUBASSIGN(rho, sub2) do {					\
  |  | 6750|      8|	int callidx = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|      8|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6751|      8|	R_bcstack_t *sx = R_BCNodeStackTop - 4;				\
  |  | 6752|      8|	MATSUBASSIGN_PTR(sx, R_BCNodeStackTop - 3,			\
  |  | 6753|      8|			 R_BCNodeStackTop - 2, R_BCNodeStackTop - 1,	\
  |  | 6754|      8|			 sx, rho, constants, callidx, sub2);		\
  |  | 6755|      8|	R_BCNodeStackTop -= 3;						\
  |  | 6756|      8|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6756:14): [Folded, False: 8]
  |  |  ------------------
  ------------------
                  OP(MATSUBASSIGN, 1): DO_MATSUBASSIGN(rho, FALSE); NEXT();
  ------------------
  |  | 5655|      8|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8392|   783k|    OP(AND1ST, 2): {
  ------------------
  |  | 5638|     10|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|     10|    opinfo[name##_OP].argc = (n); \
  |  | 5640|     10|    opinfo[name##_OP].instname = #name; \
  |  | 5641|     10|    goto loop; \
  |  | 5642|   783k|    op_##name
  ------------------
 8393|   783k|	int callidx = GETOP();
  ------------------
  |  | 5656|   783k|#define GETOP() (*pc++).i
  ------------------
 8394|   783k|	int label = GETOP();
  ------------------
  |  | 5656|   783k|#define GETOP() (*pc++).i
  ------------------
 8395|   783k|	FIXUP_SCALAR_LOGICAL(rho, callidx, "'x'", "&&", warn_lev);
  ------------------
  |  | 6806|   783k|#define FIXUP_SCALAR_LOGICAL(rho, callidx, arg, op, warn_level) do {	\
  |  | 6807|   783k|	if (R_BCNodeStackTop[-1].tag == LGLSXP) break;			\
  |  |  ------------------
  |  |  |  |  121|   783k|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (6807:6): [True: 481, False: 782k]
  |  |  ------------------
  |  | 6808|   783k|	SEXP val = GETSTACK(-1);					\
  |  |  ------------------
  |  |  |  | 4903|   782k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|   782k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 782k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6809|   782k|	if (IS_SIMPLE_SCALAR(val, LGLSXP))				\
  |  |  ------------------
  |  |  |  |  218|   782k|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (218:6): [True: 782k, False: 30]
  |  |  |  |  |  Branch (218:28): [True: 782k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6810|   782k|	    SETSTACK(-1, ScalarLogical(SCALAR_LVAL(val)));		\
  |  |  ------------------
  |  |  |  | 4905|   782k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|   782k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|   782k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|   782k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 782k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|   782k|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|   782k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|   782k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|   782k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 782k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6811|   782k|	else {								\
  |  | 6812|     30|	    if (!isNumber(val))						\
  |  |  ------------------
  |  |  |  |  958|     30|#define isNumber		Rf_isNumber
  |  |  ------------------
  |  |  |  Branch (6812:10): [True: 0, False: 30]
  |  |  ------------------
  |  | 6813|     30|		errorcall(GETCONST(constants, callidx),			\
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |               		errorcall(GETCONST(constants, callidx),			\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6814|      0|			  _("invalid %s type in 'x %s y'"), arg, op);	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 6815|     30|	    SETSTACK(-1, ScalarLogical(asLogical2(			\
  |  |  ------------------
  |  |  |  | 4905|     30|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|     30|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|     30|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|     30|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 30]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|     30|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|     30|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|     30|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|     30|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 30]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6816|     30|					   val, /*checking*/ 1,		\
  |  | 6817|     30|					   GETCONST(constants, callidx) \
  |  | 6818|     30|					   )));				\
  |  | 6819|     30|	}								\
  |  | 6820|   782k|    } while(0)
  |  |  ------------------
  |  |  |  Branch (6820:13): [Folded, False: 782k]
  |  |  ------------------
  ------------------
 8396|   783k|	int val = GETSTACK_LOGICAL(-1);
  ------------------
  |  | 6965|   783k|#define GETSTACK_LOGICAL(n) GETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (n))
  ------------------
 8397|   783k|	if (val == FALSE)
  ------------------
  |  Branch (8397:6): [True: 777k, False: 5.39k]
  ------------------
 8398|   777k|	    pc = codebase + label;
 8399|   783k|	R_Visible = TRUE;
 8400|   783k|	NEXT();
  ------------------
  |  | 5655|   783k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8401|   783k|    }
 8402|   783k|    OP(AND2ND, 1): {
  ------------------
  |  | 5638|   783k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   783k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   783k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   783k|    goto loop; \
  |  | 5642|   783k|    op_##name
  ------------------
 8403|  5.39k|	int callidx = GETOP();
  ------------------
  |  | 5656|  5.39k|#define GETOP() (*pc++).i
  ------------------
 8404|  5.39k|	FIXUP_SCALAR_LOGICAL(rho, callidx, "'y'", "&&", warn_lev);
  ------------------
  |  | 6806|  5.39k|#define FIXUP_SCALAR_LOGICAL(rho, callidx, arg, op, warn_level) do {	\
  |  | 6807|  5.39k|	if (R_BCNodeStackTop[-1].tag == LGLSXP) break;			\
  |  |  ------------------
  |  |  |  |  121|  5.39k|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (6807:6): [True: 408, False: 4.98k]
  |  |  ------------------
  |  | 6808|  5.39k|	SEXP val = GETSTACK(-1);					\
  |  |  ------------------
  |  |  |  | 4903|  4.98k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|  4.98k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 8, False: 4.97k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6809|  4.98k|	if (IS_SIMPLE_SCALAR(val, LGLSXP))				\
  |  |  ------------------
  |  |  |  |  218|  4.98k|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (218:6): [True: 4.97k, False: 8]
  |  |  |  |  |  Branch (218:28): [True: 4.97k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6810|  4.98k|	    SETSTACK(-1, ScalarLogical(SCALAR_LVAL(val)));		\
  |  |  ------------------
  |  |  |  | 4905|  4.97k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  4.97k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  4.97k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  4.97k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 4.97k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  4.97k|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|  4.97k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  4.97k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  4.97k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 4.97k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6811|  4.98k|	else {								\
  |  | 6812|      8|	    if (!isNumber(val))						\
  |  |  ------------------
  |  |  |  |  958|      8|#define isNumber		Rf_isNumber
  |  |  ------------------
  |  |  |  Branch (6812:10): [True: 0, False: 8]
  |  |  ------------------
  |  | 6813|      8|		errorcall(GETCONST(constants, callidx),			\
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |               		errorcall(GETCONST(constants, callidx),			\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6814|      0|			  _("invalid %s type in 'x %s y'"), arg, op);	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 6815|      8|	    SETSTACK(-1, ScalarLogical(asLogical2(			\
  |  |  ------------------
  |  |  |  | 4905|      8|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      8|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      8|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      8|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 8]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      8|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      8|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      8|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      8|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 8]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6816|      8|					   val, /*checking*/ 1,		\
  |  | 6817|      8|					   GETCONST(constants, callidx) \
  |  | 6818|      8|					   )));				\
  |  | 6819|      8|	}								\
  |  | 6820|  4.98k|    } while(0)
  |  |  ------------------
  |  |  |  Branch (6820:13): [Folded, False: 4.98k]
  |  |  ------------------
  ------------------
 8405|  5.39k|	int val = GETSTACK_LOGICAL(-1);
  ------------------
  |  | 6965|  5.39k|#define GETSTACK_LOGICAL(n) GETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (n))
  ------------------
 8406|       |	/* The first argument is TRUE or NA. If the second argument is
 8407|       |	   not TRUE then its value is the result. If the second
 8408|       |	   argument is TRUE, then the first argument's value is the
 8409|       |	   result. */
 8410|  5.39k|	if (val == FALSE || val == NA_LOGICAL)
  ------------------
  |  |   55|  3.51k|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (8410:6): [True: 1.88k, False: 3.51k]
  |  Branch (8410:22): [True: 0, False: 3.51k]
  ------------------
 8411|  5.39k|	    SETSTACK_LOGICAL(-2, val);
  ------------------
  |  | 4911|  1.88k|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4877|  1.88k|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  | 4878|  1.88k|	int __v__ = (v);			\
  |  |  |  | 4879|  1.88k|	(s)->tag = LGLSXP;			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|  1.88k|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 4880|  1.88k|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|  1.88k|#define NA_LOGICAL	R_NaInt
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4880:6): [True: 0, False: 1.88k]
  |  |  |  |  ------------------
  |  |  |  | 4881|  1.88k|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  ------------------
  |  |  |  | 4882|  1.88k|	else					\
  |  |  |  | 4883|  1.88k|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4883:20): [True: 0, False: 1.88k]
  |  |  |  |  ------------------
  |  |  |  | 4884|  1.88k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4884:14): [Folded, False: 1.88k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8412|  5.39k|	R_BCNodeStackTop -= 1;
 8413|  5.39k|	R_Visible = TRUE;
 8414|  5.39k|	NEXT();
  ------------------
  |  | 5655|  5.39k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8415|  5.39k|    }
 8416|  9.94k|    OP(OR1ST, 2):  {
  ------------------
  |  | 5638|  5.39k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  5.39k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  5.39k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  5.39k|    goto loop; \
  |  | 5642|  9.94k|    op_##name
  ------------------
 8417|  9.94k|	int callidx = GETOP();
  ------------------
  |  | 5656|  9.94k|#define GETOP() (*pc++).i
  ------------------
 8418|  9.94k|	int label = GETOP();
  ------------------
  |  | 5656|  9.94k|#define GETOP() (*pc++).i
  ------------------
 8419|  9.94k|	FIXUP_SCALAR_LOGICAL(rho, callidx, "'x'", "||", warn_lev);
  ------------------
  |  | 6806|  9.94k|#define FIXUP_SCALAR_LOGICAL(rho, callidx, arg, op, warn_level) do {	\
  |  | 6807|  9.94k|	if (R_BCNodeStackTop[-1].tag == LGLSXP) break;			\
  |  |  ------------------
  |  |  |  |  121|  9.94k|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (6807:6): [True: 247, False: 9.69k]
  |  |  ------------------
  |  | 6808|  9.94k|	SEXP val = GETSTACK(-1);					\
  |  |  ------------------
  |  |  |  | 4903|  9.69k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|  9.69k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 9.69k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6809|  9.69k|	if (IS_SIMPLE_SCALAR(val, LGLSXP))				\
  |  |  ------------------
  |  |  |  |  218|  9.69k|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (218:6): [True: 9.69k, False: 0]
  |  |  |  |  |  Branch (218:28): [True: 9.69k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6810|  9.69k|	    SETSTACK(-1, ScalarLogical(SCALAR_LVAL(val)));		\
  |  |  ------------------
  |  |  |  | 4905|  9.69k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  9.69k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  9.69k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  9.69k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 9.69k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  9.69k|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|  9.69k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  9.69k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  9.69k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 9.69k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6811|  9.69k|	else {								\
  |  | 6812|      0|	    if (!isNumber(val))						\
  |  |  ------------------
  |  |  |  |  958|      0|#define isNumber		Rf_isNumber
  |  |  ------------------
  |  |  |  Branch (6812:10): [True: 0, False: 0]
  |  |  ------------------
  |  | 6813|      0|		errorcall(GETCONST(constants, callidx),			\
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |               		errorcall(GETCONST(constants, callidx),			\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6814|      0|			  _("invalid %s type in 'x %s y'"), arg, op);	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 6815|      0|	    SETSTACK(-1, ScalarLogical(asLogical2(			\
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6816|      0|					   val, /*checking*/ 1,		\
  |  | 6817|      0|					   GETCONST(constants, callidx) \
  |  | 6818|      0|					   )));				\
  |  | 6819|      0|	}								\
  |  | 6820|  9.69k|    } while(0)
  |  |  ------------------
  |  |  |  Branch (6820:13): [Folded, False: 9.69k]
  |  |  ------------------
  ------------------
 8420|  9.94k|	int val = GETSTACK_LOGICAL(-1);
  ------------------
  |  | 6965|  9.94k|#define GETSTACK_LOGICAL(n) GETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (n))
  ------------------
 8421|  9.94k|	if (val != NA_LOGICAL &&
  ------------------
  |  |   55|  19.8k|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (8421:6): [True: 9.94k, False: 0]
  ------------------
 8422|  9.94k|	    val != FALSE) /* is true */
  ------------------
  |  Branch (8422:6): [True: 2.83k, False: 7.10k]
  ------------------
 8423|  2.83k|	    pc = codebase + label;
 8424|  9.94k|	R_Visible = TRUE;
 8425|  9.94k|	NEXT();
  ------------------
  |  | 5655|  9.94k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8426|  9.94k|    }
 8427|  9.94k|    OP(OR2ND, 1):  {
  ------------------
  |  | 5638|  9.94k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  9.94k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  9.94k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  9.94k|    goto loop; \
  |  | 5642|  9.94k|    op_##name
  ------------------
 8428|  7.10k|	int callidx = GETOP();
  ------------------
  |  | 5656|  7.10k|#define GETOP() (*pc++).i
  ------------------
 8429|  7.10k|	FIXUP_SCALAR_LOGICAL(rho, callidx, "'y'", "||", warn_lev);
  ------------------
  |  | 6806|  7.10k|#define FIXUP_SCALAR_LOGICAL(rho, callidx, arg, op, warn_level) do {	\
  |  | 6807|  7.10k|	if (R_BCNodeStackTop[-1].tag == LGLSXP) break;			\
  |  |  ------------------
  |  |  |  |  121|  7.10k|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (6807:6): [True: 241, False: 6.86k]
  |  |  ------------------
  |  | 6808|  7.10k|	SEXP val = GETSTACK(-1);					\
  |  |  ------------------
  |  |  |  | 4903|  6.86k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|  6.86k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 6.86k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6809|  6.86k|	if (IS_SIMPLE_SCALAR(val, LGLSXP))				\
  |  |  ------------------
  |  |  |  |  218|  6.86k|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (218:6): [True: 6.86k, False: 2]
  |  |  |  |  |  Branch (218:28): [True: 6.86k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6810|  6.86k|	    SETSTACK(-1, ScalarLogical(SCALAR_LVAL(val)));		\
  |  |  ------------------
  |  |  |  | 4905|  6.86k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  6.86k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  6.86k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  6.86k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 6.86k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  6.86k|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|  6.86k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  6.86k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  6.86k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 6.86k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6811|  6.86k|	else {								\
  |  | 6812|      2|	    if (!isNumber(val))						\
  |  |  ------------------
  |  |  |  |  958|      2|#define isNumber		Rf_isNumber
  |  |  ------------------
  |  |  |  Branch (6812:10): [True: 0, False: 2]
  |  |  ------------------
  |  | 6813|      2|		errorcall(GETCONST(constants, callidx),			\
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |               		errorcall(GETCONST(constants, callidx),			\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6814|      0|			  _("invalid %s type in 'x %s y'"), arg, op);	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 6815|      2|	    SETSTACK(-1, ScalarLogical(asLogical2(			\
  |  |  ------------------
  |  |  |  | 4905|      2|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      2|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      2|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      2|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      2|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      2|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      2|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      2|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 2]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6816|      2|					   val, /*checking*/ 1,		\
  |  | 6817|      2|					   GETCONST(constants, callidx) \
  |  | 6818|      2|					   )));				\
  |  | 6819|      2|	}								\
  |  | 6820|  6.86k|    } while(0)
  |  |  ------------------
  |  |  |  Branch (6820:13): [Folded, False: 6.86k]
  |  |  ------------------
  ------------------
 8430|  7.10k|	int val = GETSTACK_LOGICAL(-1);
  ------------------
  |  | 6965|  7.10k|#define GETSTACK_LOGICAL(n) GETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (n))
  ------------------
 8431|       |	/* The first argument is FALSE or NA. If the second argument is
 8432|       |	   not FALSE then its value is the result. If the second
 8433|       |	   argument is FALSE, then the first argument's value is the
 8434|       |	   result. */
 8435|  7.10k|	if (val != FALSE)
  ------------------
  |  Branch (8435:6): [True: 84, False: 7.02k]
  ------------------
 8436|  7.10k|	    SETSTACK_LOGICAL(-2, val);
  ------------------
  |  | 4911|     84|#define SETSTACK_LOGICAL(i, v) SETSTACK_LOGICAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4877|     84|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  | 4878|     84|	int __v__ = (v);			\
  |  |  |  | 4879|     84|	(s)->tag = LGLSXP;			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|     84|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 4880|     84|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|     84|#define NA_LOGICAL	R_NaInt
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4880:6): [True: 0, False: 84]
  |  |  |  |  ------------------
  |  |  |  | 4881|     84|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  ------------------
  |  |  |  | 4882|     84|	else					\
  |  |  |  | 4883|     84|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4883:20): [True: 84, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4884|     84|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4884:14): [Folded, False: 84]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8437|  7.10k|	R_BCNodeStackTop -= 1;
 8438|  7.10k|	R_Visible = TRUE;
 8439|  7.10k|	NEXT();
  ------------------
  |  | 5655|  7.10k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8440|  7.10k|    }
 8441|  1.93M|    OP(GETVAR_MISSOK, 1): DO_GETVAR(FALSE, TRUE);
  ------------------
  |  | 5638|  7.10k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  7.10k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  7.10k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  7.10k|    goto loop; \
  |  | 5642|  1.93M|    op_##name
  ------------------
                  OP(GETVAR_MISSOK, 1): DO_GETVAR(FALSE, TRUE);
  ------------------
  |  | 5921|  1.93M|#define DO_GETVAR(dd,keepmiss) do { \
  |  | 5922|  1.93M|    int sidx = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|  1.93M|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 5923|  1.93M|    R_Visible = TRUE;	     \
  |  | 5924|  1.93M|    if (!dd && smallcache) {						\
  |  |  ------------------
  |  |  |  Branch (5924:9): [True: 1.93M, Folded]
  |  |  |  Branch (5924:16): [True: 1.93M, False: 610]
  |  |  ------------------
  |  | 5925|  1.93M|	SEXP cell = GET_SMALLCACHE_BINDING_CELL(vcache, sidx);		\
  |  |  ------------------
  |  |  |  | 5771|  1.93M|#  define GET_SMALLCACHE_BINDING_CELL(vcache, sidx) VCACHE(sidx)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5768|  1.93M|#  define VCACHE(i) GETSTACK_SXPVAL_PTR(vcache + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4839|  1.93M|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5926|  1.93M|	if (cell == R_NilValue) {					\
  |  |  ------------------
  |  |  |  Branch (5926:6): [True: 391k, False: 1.54M]
  |  |  ------------------
  |  | 5927|   391k|	    /* make sure local variable cells are cached */		\
  |  | 5928|   391k|	    SEXP symbol = GETCONST(constants, sidx);			\
  |  |  ------------------
  |  |  |  | 5550|   391k|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5929|   391k|	    cell = GET_BINDING_CELL_CACHE(symbol, rho, vcache, sidx);	\
  |  | 5930|   391k|	}								\
  |  | 5931|  1.93M|	/* handle immediate binings */					\
  |  | 5932|  1.93M|	switch (BNDCELL_TAG(cell)) {					\
  |  |  ------------------
  |  |  |  Branch (5932:10): [True: 1.92M, False: 6.40k]
  |  |  ------------------
  |  | 5933|      0|	case REALSXP: BCNPUSH_REAL(BNDCELL_DVAL(cell)); NEXT();		\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	case REALSXP: BCNPUSH_REAL(BNDCELL_DVAL(cell)); NEXT();		\
  |  |  ------------------
  |  |  |  | 5462|      0|#define BCNPUSH_REAL(v) do { \
  |  |  |  | 5463|      0|  double __value__ = (v); \
  |  |  |  | 5464|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5465|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5465:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5466|      0|  __ntop__[-1].u.dval = __value__; \
  |  |  |  | 5467|      0|  __ntop__[-1].tag = REALSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  | 5468|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5469|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5469:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	case REALSXP: BCNPUSH_REAL(BNDCELL_DVAL(cell)); NEXT();		\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5933:2): [True: 0, False: 1.93M]
  |  |  ------------------
  |  | 5934|  1.92M|	case INTSXP: BCNPUSH_INTEGER(BNDCELL_IVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  |  123|  1.92M|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	case INTSXP: BCNPUSH_INTEGER(BNDCELL_IVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5471|  1.92M|#define BCNPUSH_INTEGER(v) do { \
  |  |  |  | 5472|  1.92M|  int __value__ = (v); \
  |  |  |  | 5473|  1.92M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5474|  1.92M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5474:7): [True: 0, False: 1.92M]
  |  |  |  |  ------------------
  |  |  |  | 5475|  1.92M|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5476|  1.92M|  __ntop__[-1].tag = INTSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|  1.92M|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 5477|  1.92M|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5478|  1.92M|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5478:10): [Folded, False: 1.92M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	case INTSXP: BCNPUSH_INTEGER(BNDCELL_IVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5655|  1.92M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5934:2): [True: 1.92M, False: 6.40k]
  |  |  ------------------
  |  | 5935|  1.92M|	case LGLSXP: BCNPUSH_LOGICAL(BNDCELL_LVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  |  121|  1.92M|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |               	case LGLSXP: BCNPUSH_LOGICAL(BNDCELL_LVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5480|  1.92M|#define BCNPUSH_LOGICAL(v) do { \
  |  |  |  | 5481|  1.92M|  int __value__ = (v); \
  |  |  |  | 5482|  1.92M|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5483|  1.92M|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5483:7): [True: 0, False: 1.92M]
  |  |  |  |  ------------------
  |  |  |  | 5484|  1.92M|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5485|  1.92M|  __ntop__[-1].tag = LGLSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|  1.92M|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 5486|  1.92M|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5487|  1.92M|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5487:10): [Folded, False: 1.92M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	case LGLSXP: BCNPUSH_LOGICAL(BNDCELL_LVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5655|  1.92M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5935:2): [True: 0, False: 1.93M]
  |  |  ------------------
  |  | 5936|  1.93M|	}								\
  |  | 5937|  1.93M|	SEXP value = CAR(cell);						\
  |  | 5938|  6.40k|	int type = TYPEOF(value);					\
  |  | 5939|  6.40k|	/* extract value of forced promises */				\
  |  | 5940|  6.40k|	if (type == PROMSXP) {						\
  |  |  ------------------
  |  |  |  |  116|  6.40k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (5940:6): [True: 3.06k, False: 3.33k]
  |  |  ------------------
  |  | 5941|  3.06k|	    if (PROMISE_IS_EVALUATED(value)) {				\
  |  |  ------------------
  |  |  |  Branch (5941:10): [True: 2.06k, False: 998]
  |  |  ------------------
  |  | 5942|  2.06k|		switch (PROMISE_TAG(value)) {				\
  |  |  ------------------
  |  |  |  Branch (5942:11): [True: 0, False: 2.06k]
  |  |  ------------------
  |  | 5943|      0|		case REALSXP: BCNPUSH_REAL(PROMISE_DVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               		case REALSXP: BCNPUSH_REAL(PROMISE_DVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5462|      0|#define BCNPUSH_REAL(v) do { \
  |  |  |  | 5463|      0|  double __value__ = (v); \
  |  |  |  | 5464|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5465|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5465:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5466|      0|  __ntop__[-1].u.dval = __value__; \
  |  |  |  | 5467|      0|  __ntop__[-1].tag = REALSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  | 5468|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5469|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5469:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               		case REALSXP: BCNPUSH_REAL(PROMISE_DVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5943:3): [True: 0, False: 2.06k]
  |  |  ------------------
  |  | 5944|      0|		case INTSXP: BCNPUSH_INTEGER(PROMISE_IVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               		case INTSXP: BCNPUSH_INTEGER(PROMISE_IVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5471|      0|#define BCNPUSH_INTEGER(v) do { \
  |  |  |  | 5472|      0|  int __value__ = (v); \
  |  |  |  | 5473|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5474|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5474:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5475|      0|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5476|      0|  __ntop__[-1].tag = INTSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 5477|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5478|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5478:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               		case INTSXP: BCNPUSH_INTEGER(PROMISE_IVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5944:3): [True: 0, False: 2.06k]
  |  |  ------------------
  |  | 5945|      0|		case LGLSXP: BCNPUSH_LOGICAL(PROMISE_LVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |               		case LGLSXP: BCNPUSH_LOGICAL(PROMISE_LVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5480|      0|#define BCNPUSH_LOGICAL(v) do { \
  |  |  |  | 5481|      0|  int __value__ = (v); \
  |  |  |  | 5482|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5483|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5483:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5484|      0|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5485|      0|  __ntop__[-1].tag = LGLSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 5486|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5487|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5487:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               		case LGLSXP: BCNPUSH_LOGICAL(PROMISE_LVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5945:3): [True: 0, False: 2.06k]
  |  |  ------------------
  |  | 5946|  2.06k|		}							\
  |  | 5947|  2.06k|		value = PRVALUE(value);					\
  |  | 5948|  2.06k|		type = TYPEOF(value);					\
  |  | 5949|  2.06k|	    }								\
  |  | 5950|  3.06k|	}								\
  |  | 5951|  6.40k|	/* try fast handling of some types; for these the */		\
  |  | 5952|  6.40k|	/* cell won't be R_NilValue or an active binding */		\
  |  | 5953|  6.40k|	switch(type) {							\
  |  | 5954|      0|	case REALSXP:							\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5954:2): [True: 0, False: 6.40k]
  |  |  ------------------
  |  | 5955|    393|	case INTSXP:							\
  |  |  ------------------
  |  |  |  |  123|    393|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (5955:2): [True: 393, False: 6.00k]
  |  |  ------------------
  |  | 5956|    523|	case LGLSXP:							\
  |  |  ------------------
  |  |  |  |  121|    523|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (5956:2): [True: 130, False: 6.27k]
  |  |  ------------------
  |  | 5957|    523|	case CPLXSXP:							\
  |  |  ------------------
  |  |  |  |  125|    523|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |  |  Branch (5957:2): [True: 0, False: 6.40k]
  |  |  ------------------
  |  | 5958|  5.40k|	case STRSXP:							\
  |  |  ------------------
  |  |  |  |  126|  5.40k|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (5958:2): [True: 4.87k, False: 1.52k]
  |  |  ------------------
  |  | 5959|  5.40k|	case VECSXP:							\
  |  |  ------------------
  |  |  |  |  131|  5.40k|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (5959:2): [True: 0, False: 6.40k]
  |  |  ------------------
  |  | 5960|  5.40k|	case RAWSXP:							\
  |  |  ------------------
  |  |  |  |  136|  5.40k|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (5960:2): [True: 0, False: 6.40k]
  |  |  ------------------
  |  | 5961|  5.40k|	    BCNPUSH(value);						\
  |  |  ------------------
  |  |  |  | 5449|  5.40k|#define BCNPUSH(v) do { \
  |  |  |  | 5450|  5.40k|  SEXP __value__ = (v); \
  |  |  |  | 5451|  5.40k|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|  5.40k|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 5.40k]
  |  |  |  |  ------------------
  |  |  |  | 5453|  5.40k|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  5.40k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  5.40k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  5.40k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  5.40k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 5.40k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  5.40k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  5.40k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  5.40k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  5.40k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 5.40k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|  5.40k|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|  5.40k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 5.40k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5962|  5.40k|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|  5.40k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5963|  5.40k|	case SYMSXP:							\
  |  |  ------------------
  |  |  |  |  112|  5.40k|#define SYMSXP	     1	  /* symbols */
  |  |  ------------------
  |  |  |  Branch (5963:2): [True: 0, False: 6.40k]
  |  |  ------------------
  |  | 5964|  6.40k|	case PROMSXP:							\
  |  |  ------------------
  |  |  |  |  116|  6.40k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (5964:2): [True: 998, False: 5.40k]
  |  |  ------------------
  |  | 5965|  6.40k|	    break;							\
  |  | 5966|  5.40k|	default:							\
  |  |  ------------------
  |  |  |  Branch (5966:2): [True: 0, False: 6.40k]
  |  |  ------------------
  |  | 5967|      0|	    if (cell != R_NilValue && ! IS_ACTIVE_BINDING(cell)) {	\
  |  |  ------------------
  |  |  |  Branch (5967:10): [True: 0, False: 0]
  |  |  |  Branch (5967:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 5968|      0|		BCNPUSH(value);						\
  |  |  ------------------
  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5969|      0|		NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5970|      0|	    }								\
  |  | 5971|  6.40k|	}								\
  |  | 5972|  6.40k|    }									\
  |  | 5973|  1.93M|    SEXP symbol = GETCONST(constants, sidx);				\
  |  |  ------------------
  |  |  |  | 5550|  1.60k|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5974|  1.60k|    SEXP value = findVarEX(symbol, rho, dd, vcache, sidx);		\
  |  | 5975|  1.60k|    if (! keepmiss && TYPEOF(value) == PROMSXP &&			\
  |  |  ------------------
  |  |  |  |  116|  1.60k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (5975:9): [Folded, False: 1.60k]
  |  |  |  Branch (5975:23): [True: 0, False: 0]
  |  |  ------------------
  |  | 5976|  1.60k|	! PRSEEN(value) && ! PROMISE_IS_EVALUATED(value) &&		\
  |  |  ------------------
  |  |  |  Branch (5976:2): [True: 0, False: 0]
  |  |  |  Branch (5976:21): [True: 0, False: 0]
  |  |  ------------------
  |  | 5977|  1.60k|	TYPEOF(PRCODE(value)) == BCODESXP) {				\
  |  |  ------------------
  |  |  |  |  133|      0|#define BCODESXP    21    /* byte code */
  |  |  ------------------
  |  |  |  Branch (5977:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5978|      0|	START_BCFRAME_PROM(value);					\
  |  |  ------------------
  |  |  |  | 7498|      0|#define START_BCFRAME_PROM(prom) do {				\
  |  |  |  | 7499|      0|	struct bcEval_locals locals =				\
  |  |  |  | 7500|      0|	    setup_bcframe_prom(prom);				\
  |  |  |  | 7501|      0|	SAVE_BCEVAL_LOCALS(BCFRAME_LOCALS());			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 7267|      0|#define SAVE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  |  |  | 7268|      0|	(loc)->body = body;			\
  |  |  |  |  |  | 7269|      0|	(loc)->rho = rho;			\
  |  |  |  |  |  | 7270|      0|	(loc)->vcache = vcache;			\
  |  |  |  |  |  | 7271|      0|	(loc)->smallcache = smallcache;		\
  |  |  |  |  |  | 7272|      0|	(loc)->pc = pc;				\
  |  |  |  |  |  | 7273|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (7273:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7502|      0|	RESTORE_BCEVAL_LOCALS(&locals);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 7275|      0|#define RESTORE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  |  |  | 7276|      0|	body = (loc)->body;			\
  |  |  |  |  |  | 7277|      0|	codebase = BCCODE(body);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5659|      0|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  736|      0|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 7278|      0|	constants = BCCONSTS(body);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5548|      0|    (R_bcconsts_t) {((SEXP const *) DATAPTR_RO(BCODE_CONSTS(e)))}
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  737|      0|#define BCODE_CONSTS(x) CDR(x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 7279|      0|	rho = (loc)->rho;			\
  |  |  |  |  |  | 7280|      0|	vcache = (loc)->vcache;			\
  |  |  |  |  |  | 7281|      0|	smallcache = (loc)->smallcache;		\
  |  |  |  |  |  | 7282|      0|	pc = (loc)->pc;				\
  |  |  |  |  |  | 7283|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (7283:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7503|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (7503:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5979|      0|	NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5980|      0|	/* return cleanup is in DO_GETVAR_FORCE_PROMISE_RETURN */	\
  |  | 5981|      0|    }									\
  |  | 5982|  1.60k|    BCNPUSH(getvar(symbol, rho, dd, keepmiss, vcache, sidx));		\
  |  |  ------------------
  |  |  |  | 5449|  1.60k|#define BCNPUSH(v) do { \
  |  |  |  | 5450|  1.60k|  SEXP __value__ = (v); \
  |  |  |  | 5451|  1.60k|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|  1.60k|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 1.60k]
  |  |  |  |  ------------------
  |  |  |  | 5453|  1.60k|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  1.60k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  1.60k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  1.60k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  1.60k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.60k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  1.60k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  1.60k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  1.60k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  1.60k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.60k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|  1.60k|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|  1.60k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 1.60k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5983|  1.60k|    NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|  1.60k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5984|  1.60k|} while (0)
  |  |  ------------------
  |  |  |  Branch (5984:10): [Folded, False: 1.60k]
  |  |  ------------------
  ------------------
 8442|  1.61k|    OP(DDVAL_MISSOK, 1): DO_GETVAR(TRUE, TRUE);
  ------------------
  |  | 5638|  1.61k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.61k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.61k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.61k|    goto loop; \
  |  | 5642|  1.61k|    op_##name
  ------------------
                  OP(DDVAL_MISSOK, 1): DO_GETVAR(TRUE, TRUE);
  ------------------
  |  | 5921|      0|#define DO_GETVAR(dd,keepmiss) do { \
  |  | 5922|      0|    int sidx = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 5923|      0|    R_Visible = TRUE;	     \
  |  | 5924|      0|    if (!dd && smallcache) {						\
  |  |  ------------------
  |  |  |  Branch (5924:9): [Folded, False: 0]
  |  |  |  Branch (5924:16): [True: 0, False: 0]
  |  |  ------------------
  |  | 5925|      0|	SEXP cell = GET_SMALLCACHE_BINDING_CELL(vcache, sidx);		\
  |  |  ------------------
  |  |  |  | 5771|      0|#  define GET_SMALLCACHE_BINDING_CELL(vcache, sidx) VCACHE(sidx)
  |  |  |  |  ------------------
  |  |  |  |  |  | 5768|      0|#  define VCACHE(i) GETSTACK_SXPVAL_PTR(vcache + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4839|      0|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5926|      0|	if (cell == R_NilValue) {					\
  |  |  ------------------
  |  |  |  Branch (5926:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5927|      0|	    /* make sure local variable cells are cached */		\
  |  | 5928|      0|	    SEXP symbol = GETCONST(constants, sidx);			\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5929|      0|	    cell = GET_BINDING_CELL_CACHE(symbol, rho, vcache, sidx);	\
  |  | 5930|      0|	}								\
  |  | 5931|      0|	/* handle immediate binings */					\
  |  | 5932|      0|	switch (BNDCELL_TAG(cell)) {					\
  |  |  ------------------
  |  |  |  Branch (5932:10): [True: 0, False: 0]
  |  |  ------------------
  |  | 5933|      0|	case REALSXP: BCNPUSH_REAL(BNDCELL_DVAL(cell)); NEXT();		\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	case REALSXP: BCNPUSH_REAL(BNDCELL_DVAL(cell)); NEXT();		\
  |  |  ------------------
  |  |  |  | 5462|      0|#define BCNPUSH_REAL(v) do { \
  |  |  |  | 5463|      0|  double __value__ = (v); \
  |  |  |  | 5464|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5465|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5465:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5466|      0|  __ntop__[-1].u.dval = __value__; \
  |  |  |  | 5467|      0|  __ntop__[-1].tag = REALSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  | 5468|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5469|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5469:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	case REALSXP: BCNPUSH_REAL(BNDCELL_DVAL(cell)); NEXT();		\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5933:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5934|      0|	case INTSXP: BCNPUSH_INTEGER(BNDCELL_IVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	case INTSXP: BCNPUSH_INTEGER(BNDCELL_IVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5471|      0|#define BCNPUSH_INTEGER(v) do { \
  |  |  |  | 5472|      0|  int __value__ = (v); \
  |  |  |  | 5473|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5474|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5474:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5475|      0|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5476|      0|  __ntop__[-1].tag = INTSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 5477|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5478|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5478:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	case INTSXP: BCNPUSH_INTEGER(BNDCELL_IVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5934:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5935|      0|	case LGLSXP: BCNPUSH_LOGICAL(BNDCELL_LVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |               	case LGLSXP: BCNPUSH_LOGICAL(BNDCELL_LVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5480|      0|#define BCNPUSH_LOGICAL(v) do { \
  |  |  |  | 5481|      0|  int __value__ = (v); \
  |  |  |  | 5482|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5483|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5483:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5484|      0|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5485|      0|  __ntop__[-1].tag = LGLSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 5486|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5487|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5487:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	case LGLSXP: BCNPUSH_LOGICAL(BNDCELL_LVAL(cell)); NEXT();	\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5935:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5936|      0|	}								\
  |  | 5937|      0|	SEXP value = CAR(cell);						\
  |  | 5938|      0|	int type = TYPEOF(value);					\
  |  | 5939|      0|	/* extract value of forced promises */				\
  |  | 5940|      0|	if (type == PROMSXP) {						\
  |  |  ------------------
  |  |  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (5940:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5941|      0|	    if (PROMISE_IS_EVALUATED(value)) {				\
  |  |  ------------------
  |  |  |  Branch (5941:10): [True: 0, False: 0]
  |  |  ------------------
  |  | 5942|      0|		switch (PROMISE_TAG(value)) {				\
  |  |  ------------------
  |  |  |  Branch (5942:11): [True: 0, False: 0]
  |  |  ------------------
  |  | 5943|      0|		case REALSXP: BCNPUSH_REAL(PROMISE_DVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               		case REALSXP: BCNPUSH_REAL(PROMISE_DVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5462|      0|#define BCNPUSH_REAL(v) do { \
  |  |  |  | 5463|      0|  double __value__ = (v); \
  |  |  |  | 5464|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5465|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5465:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5466|      0|  __ntop__[-1].u.dval = __value__; \
  |  |  |  | 5467|      0|  __ntop__[-1].tag = REALSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  | 5468|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5469|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5469:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               		case REALSXP: BCNPUSH_REAL(PROMISE_DVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5943:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 5944|      0|		case INTSXP: BCNPUSH_INTEGER(PROMISE_IVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               		case INTSXP: BCNPUSH_INTEGER(PROMISE_IVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5471|      0|#define BCNPUSH_INTEGER(v) do { \
  |  |  |  | 5472|      0|  int __value__ = (v); \
  |  |  |  | 5473|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5474|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5474:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5475|      0|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5476|      0|  __ntop__[-1].tag = INTSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 5477|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5478|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5478:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               		case INTSXP: BCNPUSH_INTEGER(PROMISE_IVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5944:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 5945|      0|		case LGLSXP: BCNPUSH_LOGICAL(PROMISE_LVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |               		case LGLSXP: BCNPUSH_LOGICAL(PROMISE_LVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5480|      0|#define BCNPUSH_LOGICAL(v) do { \
  |  |  |  | 5481|      0|  int __value__ = (v); \
  |  |  |  | 5482|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5483|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5483:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5484|      0|  __ntop__[-1].u.ival = __value__; \
  |  |  |  | 5485|      0|  __ntop__[-1].tag = LGLSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 5486|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5487|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5487:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               		case LGLSXP: BCNPUSH_LOGICAL(PROMISE_LVAL(value)); NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  |  |  Branch (5945:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 5946|      0|		}							\
  |  | 5947|      0|		value = PRVALUE(value);					\
  |  | 5948|      0|		type = TYPEOF(value);					\
  |  | 5949|      0|	    }								\
  |  | 5950|      0|	}								\
  |  | 5951|      0|	/* try fast handling of some types; for these the */		\
  |  | 5952|      0|	/* cell won't be R_NilValue or an active binding */		\
  |  | 5953|      0|	switch(type) {							\
  |  | 5954|      0|	case REALSXP:							\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5954:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5955|      0|	case INTSXP:							\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (5955:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5956|      0|	case LGLSXP:							\
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (5956:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5957|      0|	case CPLXSXP:							\
  |  |  ------------------
  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |  |  Branch (5957:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5958|      0|	case STRSXP:							\
  |  |  ------------------
  |  |  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (5958:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5959|      0|	case VECSXP:							\
  |  |  ------------------
  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (5959:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5960|      0|	case RAWSXP:							\
  |  |  ------------------
  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (5960:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5961|      0|	    BCNPUSH(value);						\
  |  |  ------------------
  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5962|      0|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5963|      0|	case SYMSXP:							\
  |  |  ------------------
  |  |  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  |  |  ------------------
  |  |  |  Branch (5963:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5964|      0|	case PROMSXP:							\
  |  |  ------------------
  |  |  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (5964:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5965|      0|	    break;							\
  |  | 5966|      0|	default:							\
  |  |  ------------------
  |  |  |  Branch (5966:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5967|      0|	    if (cell != R_NilValue && ! IS_ACTIVE_BINDING(cell)) {	\
  |  |  ------------------
  |  |  |  Branch (5967:10): [True: 0, False: 0]
  |  |  |  Branch (5967:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 5968|      0|		BCNPUSH(value);						\
  |  |  ------------------
  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5969|      0|		NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5970|      0|	    }								\
  |  | 5971|      0|	}								\
  |  | 5972|      0|    }									\
  |  | 5973|      0|    SEXP symbol = GETCONST(constants, sidx);				\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5974|      0|    SEXP value = findVarEX(symbol, rho, dd, vcache, sidx);		\
  |  | 5975|      0|    if (! keepmiss && TYPEOF(value) == PROMSXP &&			\
  |  |  ------------------
  |  |  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  ------------------
  |  |  |  Branch (5975:9): [Folded, False: 0]
  |  |  |  Branch (5975:23): [True: 0, False: 0]
  |  |  ------------------
  |  | 5976|      0|	! PRSEEN(value) && ! PROMISE_IS_EVALUATED(value) &&		\
  |  |  ------------------
  |  |  |  Branch (5976:2): [True: 0, False: 0]
  |  |  |  Branch (5976:21): [True: 0, False: 0]
  |  |  ------------------
  |  | 5977|      0|	TYPEOF(PRCODE(value)) == BCODESXP) {				\
  |  |  ------------------
  |  |  |  |  133|      0|#define BCODESXP    21    /* byte code */
  |  |  ------------------
  |  |  |  Branch (5977:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 5978|      0|	START_BCFRAME_PROM(value);					\
  |  |  ------------------
  |  |  |  | 7498|      0|#define START_BCFRAME_PROM(prom) do {				\
  |  |  |  | 7499|      0|	struct bcEval_locals locals =				\
  |  |  |  | 7500|      0|	    setup_bcframe_prom(prom);				\
  |  |  |  | 7501|      0|	SAVE_BCEVAL_LOCALS(BCFRAME_LOCALS());			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 7267|      0|#define SAVE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  |  |  | 7268|      0|	(loc)->body = body;			\
  |  |  |  |  |  | 7269|      0|	(loc)->rho = rho;			\
  |  |  |  |  |  | 7270|      0|	(loc)->vcache = vcache;			\
  |  |  |  |  |  | 7271|      0|	(loc)->smallcache = smallcache;		\
  |  |  |  |  |  | 7272|      0|	(loc)->pc = pc;				\
  |  |  |  |  |  | 7273|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (7273:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7502|      0|	RESTORE_BCEVAL_LOCALS(&locals);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 7275|      0|#define RESTORE_BCEVAL_LOCALS(loc) do {		\
  |  |  |  |  |  | 7276|      0|	body = (loc)->body;			\
  |  |  |  |  |  | 7277|      0|	codebase = BCCODE(body);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5659|      0|#define BCCODE(e) BCODE_PTR(BCODE_CODE(e))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  736|      0|#define BCODE_PTR(x) ((BCODE *) DATAPTR(x))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 7278|      0|	constants = BCCONSTS(body);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 5548|      0|    (R_bcconsts_t) {((SEXP const *) DATAPTR_RO(BCODE_CONSTS(e)))}
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  737|      0|#define BCODE_CONSTS(x) CDR(x)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 7279|      0|	rho = (loc)->rho;			\
  |  |  |  |  |  | 7280|      0|	vcache = (loc)->vcache;			\
  |  |  |  |  |  | 7281|      0|	smallcache = (loc)->smallcache;		\
  |  |  |  |  |  | 7282|      0|	pc = (loc)->pc;				\
  |  |  |  |  |  | 7283|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (7283:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 7503|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (7503:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5979|      0|	NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5980|      0|	/* return cleanup is in DO_GETVAR_FORCE_PROMISE_RETURN */	\
  |  | 5981|      0|    }									\
  |  | 5982|      0|    BCNPUSH(getvar(symbol, rho, dd, keepmiss, vcache, sidx));		\
  |  |  ------------------
  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5983|      0|    NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5984|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (5984:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8443|     11|    OP(VISIBLE, 0): R_Visible = TRUE; NEXT();
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|     11|    op_##name
  ------------------
                  OP(VISIBLE, 0): R_Visible = TRUE; NEXT();
  ------------------
  |  | 5655|     11|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8444|  1.99k|    OP(SETVAR2, 1):
  ------------------
  |  | 5638|     13|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|     13|    opinfo[name##_OP].argc = (n); \
  |  | 5640|     13|    opinfo[name##_OP].instname = #name; \
  |  | 5641|     13|    goto loop; \
  |  | 5642|  1.99k|    op_##name
  ------------------
 8445|  1.99k|      {
 8446|  1.99k|	SEXP symbol = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|  1.99k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8447|  1.99k|	SEXP value = GETSTACK(-1);
  ------------------
  |  | 4903|  1.99k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|  1.99k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 222, False: 1.77k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8448|  1.99k|	INCREMENT_NAMED(value);
  ------------------
  |  |  222|  1.99k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 1.99k]
  |  |  ------------------
  ------------------
 8449|  1.99k|	setVar(symbol, value, ENCLOS(rho));
  ------------------
  |  | 1029|  1.99k|#define setVar			Rf_setVar
  ------------------
 8450|  1.99k|	NEXT();
  ------------------
  |  | 5655|  1.99k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8451|  1.99k|      }
 8452|  2.00k|    OP(STARTASSIGN2, 1):
  ------------------
  |  | 5638|  2.00k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  2.00k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  2.00k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  2.00k|    goto loop; \
  |  | 5642|  2.00k|    op_##name
  ------------------
 8453|    254|      {
 8454|    254|	INCLNK_stack_commit();
 8455|    254|	SEXP symbol = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|    254|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8456|    254|	R_varloc_t loc = R_findVarLoc(symbol, rho);
 8457|       |
 8458|    254|	if (loc.cell == NULL)
  ------------------
  |  Branch (8458:6): [True: 0, False: 254]
  ------------------
 8459|      0|	    loc.cell = R_NilValue;
 8460|    254|	int maybe_in_assign = ASSIGNMENT_PENDING(loc.cell);
 8461|    254|	SET_ASSIGNMENT_PENDING(loc.cell, TRUE);
 8462|    254|	BCNPUSH(loc.cell);
  ------------------
  |  | 5449|    254|#define BCNPUSH(v) do { \
  |  | 5450|    254|  SEXP __value__ = (v); \
  |  | 5451|    254|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5452|    254|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5452:7): [True: 0, False: 254]
  |  |  ------------------
  |  | 5453|    254|  SETSTACK(0, __value__); \
  |  |  ------------------
  |  |  |  | 4905|    254|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|    254|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|    254|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|    254|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 254]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|    254|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|    254|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|    254|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|    254|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 254]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5454|    254|  R_BCNodeStackTop = __ntop__; \
  |  | 5455|    254|} while (0)
  |  |  ------------------
  |  |  |  Branch (5455:10): [Folded, False: 254]
  |  |  ------------------
  ------------------
 8463|       |
 8464|    254|	SEXP value = getvar(symbol, ENCLOS(rho), FALSE, FALSE, NULL, 0);
 8465|    254|	if (maybe_in_assign || MAYBE_SHARED(value))
  ------------------
  |  Branch (8465:6): [True: 0, False: 254]
  |  Branch (8465:25): [True: 0, False: 254]
  ------------------
 8466|      0|	    value = shallow_duplicate(value);
  ------------------
  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 8467|    254|	BCNPUSH(value);
  ------------------
  |  | 5449|    254|#define BCNPUSH(v) do { \
  |  | 5450|    254|  SEXP __value__ = (v); \
  |  | 5451|    254|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5452|    254|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5452:7): [True: 0, False: 254]
  |  |  ------------------
  |  | 5453|    254|  SETSTACK(0, __value__); \
  |  |  ------------------
  |  |  |  | 4905|    254|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|    254|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|    254|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|    254|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 254]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|    254|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|    254|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|    254|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|    254|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 254]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5454|    254|  R_BCNodeStackTop = __ntop__; \
  |  | 5455|    254|} while (0)
  |  |  ------------------
  |  |  |  Branch (5455:10): [Folded, False: 254]
  |  |  ------------------
  ------------------
 8468|       |
 8469|    254|	BCNDUP3RD();
  ------------------
  |  | 5511|    254|#define BCNDUP3RD() do {					\
  |  | 5512|    254|	R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1;		\
  |  | 5513|    254|	if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow();	\
  |  |  ------------------
  |  |  |  Branch (5513:6): [True: 0, False: 254]
  |  |  ------------------
  |  | 5514|    254|	__ntop__[-1] = __ntop__[-4];				\
  |  | 5515|    254|	R_BCNodeStackTop = __ntop__;				\
  |  | 5516|    254|    } while(0)
  |  |  ------------------
  |  |  |  Branch (5516:13): [Folded, False: 254]
  |  |  ------------------
  ------------------
 8470|       |	/* top four stack entries are now
 8471|       |	   RHS value, LHS cell, LHS value, RHS value */
 8472|    254|	if (IS_STACKVAL_BOXED(-1)) {
  ------------------
  |  | 4886|    254|#define IS_STACKVAL_BOXED(idx)	(R_BCNodeStackTop[idx].tag == 0)
  |  |  ------------------
  |  |  |  Branch (4886:32): [True: 254, False: 0]
  |  |  ------------------
  ------------------
 8473|    254|	    FIXUP_RHS_NAMED(GETSTACK(-1));
  ------------------
  |  | 3308|    254|#define FIXUP_RHS_NAMED(r) do { \
  |  | 3309|    508|	SEXP __rhs__ = (r); \
  |  |  ------------------
  |  |  |  Branch (3309:18): [True: 0, False: 254]
  |  |  ------------------
  |  | 3310|    254|	if (NAMED(__rhs__)) \
  |  |  ------------------
  |  |  |  Branch (3310:6): [True: 254, False: 0]
  |  |  ------------------
  |  | 3311|    254|	    ENSURE_NAMEDMAX(__rhs__); \
  |  | 3312|    254|    } while (0)
  |  |  ------------------
  |  |  |  Branch (3312:14): [Folded, False: 254]
  |  |  ------------------
  ------------------
 8474|    254|	    INCREMENT_REFCNT(GETSTACK(-1));
  ------------------
  |  | 4903|    254|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|    254|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 254]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8475|    254|	}
 8476|    254|	NEXT();
  ------------------
  |  | 5655|    254|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8477|    254|      }
 8478|    256|    OP(ENDASSIGN2, 1):
  ------------------
  |  | 5638|    256|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    256|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    256|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    256|    goto loop; \
  |  | 5642|    256|    op_##name
  ------------------
 8479|    254|      {
 8480|    254|	SEXP lhscell = GETSTACK(-2);
  ------------------
  |  | 4903|    254|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|    254|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 254]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8481|    254|	SET_ASSIGNMENT_PENDING(lhscell, FALSE);
 8482|       |
 8483|    254|	SEXP symbol = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|    254|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8484|    254|	SEXP value = GETSTACK(-1); /* leave on stack for GC protection */
  ------------------
  |  | 4903|    254|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|    254|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 254]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8485|    254|	INCREMENT_NAMED(value);
  ------------------
  |  |  222|    254|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 254]
  |  |  ------------------
  ------------------
 8486|    254|	setVar(symbol, value, ENCLOS(rho));
  ------------------
  |  | 1029|    254|#define setVar			Rf_setVar
  ------------------
 8487|    254|	R_BCNodeStackTop -= 2; /* now pop cell and LHS value off the stack */
 8488|       |	/* original right-hand side value is now on top of stack again */
 8489|       |#ifdef OLD_RHS_NAMED
 8490|       |	/* we do not duplicate the right-hand side value, so to be
 8491|       |	   conservative mark the value as NAMED = NAMEDMAX */
 8492|       |	ENSURE_NAMEDMAX(GETSTACK(-1));
 8493|       |#else
 8494|    254|	INCREMENT_NAMED(GETSTACK(-1));
  ------------------
  |  |  222|    254|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 254]
  |  |  ------------------
  ------------------
 8495|    254|#endif
 8496|    254|	DECREMENT_REFCNT(GETSTACK(-1));
  ------------------
  |  | 4903|    254|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|    254|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 254]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8497|    254|	NEXT();
  ------------------
  |  | 5655|    254|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8498|    254|      }
 8499|   771k|    OP(SETTER_CALL, 2):
  ------------------
  |  | 5638|    256|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    256|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    256|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    256|    goto loop; \
  |  | 5642|   771k|    op_##name
  ------------------
 8500|   771k|      {
 8501|   771k|	SEXP lhs = GETSTACK_BELOW_CALL_FRAME(-2);
  ------------------
  |  | 6027|   771k|#define GETSTACK_BELOW_CALL_FRAME(n) GETSTACK((n) - CALL_FRAME_SIZE())
  |  |  ------------------
  |  |  |  | 4903|   771k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|   771k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 771k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8502|   771k|	SEXP rhs = GETSTACK_BELOW_CALL_FRAME(-1);
  ------------------
  |  | 6027|   771k|#define GETSTACK_BELOW_CALL_FRAME(n) GETSTACK((n) - CALL_FRAME_SIZE())
  |  |  ------------------
  |  |  |  | 4903|   771k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|   771k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 771k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8503|   771k|	SEXP fun = CALL_FRAME_FUN();
  ------------------
  |  | 5996|   771k|#define CALL_FRAME_FUN() GETSTACK(-3)
  |  |  ------------------
  |  |  |  | 4903|   771k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|   771k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 771k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8504|   771k|	SEXP call = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|   771k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8505|   771k|	SEXP vexpr = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|   771k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8506|   771k|	SEXP args, prom, last;
 8507|   771k|	MARK_ASSIGNMENT_CALL(call);
 8508|   771k|	if (MAYBE_SHARED(lhs)) {
  ------------------
  |  Branch (8508:6): [True: 573, False: 771k]
  ------------------
 8509|    573|	  lhs = shallow_duplicate(lhs);
  ------------------
  |  | 1030|    573|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 8510|    573|	  SETSTACK_BELOW_CALL_FRAME(-2, lhs);
  ------------------
  |  | 6028|    573|#define SETSTACK_BELOW_CALL_FRAME(n, v) SETSTACK((n) - CALL_FRAME_SIZE(), v)
  |  |  ------------------
  |  |  |  | 4905|    573|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|    573|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|    573|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|    573|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 573]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|    573|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|    573|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|    573|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|    573|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 573]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8511|    573|	  ENSURE_NAMED(lhs);
 8512|    573|	}
 8513|   771k|	SEXP value = NULL;
 8514|   771k|	switch (TYPEOF(fun)) {
 8515|   771k|	case BUILTINSXP:
  ------------------
  |  |  119|   771k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (8515:2): [True: 771k, False: 561]
  ------------------
 8516|       |	  /* push RHS value onto arguments with 'value' tag */
 8517|   771k|	  PUSHCALLARG(rhs);
  ------------------
  |  | 6063|   771k|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  ------------------
  |  |  |  | 6054|   771k|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  | 6055|   771k|	SEXP __cell__ =							\
  |  |  |  | 6056|   771k|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6056:6): [Folded, False: 771k]
  |  |  |  |  ------------------
  |  |  |  | 6057|   771k|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|   771k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|   771k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 771k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6057:6): [True: 0, False: 771k]
  |  |  |  |  ------------------
  |  |  |  | 6058|   771k|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|   771k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|   771k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 771k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6059|   771k|	SETSTACK(-1, __cell__);						\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|   771k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|   771k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|   771k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|   771k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 771k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|   771k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|   771k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|   771k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|   771k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 771k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6060|   771k|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6060:6): [Folded, False: 771k]
  |  |  |  |  ------------------
  |  |  |  | 6061|   771k|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  540|   771k|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  541|   771k|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  542|   771k|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|   771k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 771k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  543|   771k|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  544|   771k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 771k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6062|   771k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6062:14): [Folded, False: 771k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8518|   771k|	  SETCALLARG_TAG_SYMBOL(R_valueSym);
  ------------------
  |  | 6081|   771k|#define SETCALLARG_TAG_SYMBOL(t) do {			\
  |  | 6082|   771k|	SEXP __cell__ = GETSTACK(-1);			\
  |  |  ------------------
  |  |  |  | 4903|   771k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|   771k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 771k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6083|   771k|	if (__cell__ != R_NilValue)			\
  |  |  ------------------
  |  |  |  Branch (6083:6): [True: 771k, False: 0]
  |  |  ------------------
  |  | 6084|   771k|	    SET_TAG(__cell__, t);			\
  |  | 6085|   771k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6085:14): [Folded, False: 771k]
  |  |  ------------------
  ------------------
 8519|       |	  /* replace first argument with LHS value */
 8520|   771k|	  args = BUILTIN_CALL_FRAME_ARGS();
 8521|   771k|	  SETCAR(args, lhs);
 8522|       |	  /* make the call */
 8523|   771k|	  checkForMissings(args, call);
 8524|   771k|	  value = PRIMFUN(fun) (call, fun, args, rho);
  ------------------
  |  | 1345|   771k|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 8525|   771k|	  break;
 8526|      0|	case SPECIALSXP:
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (8526:2): [True: 0, False: 771k]
  ------------------
 8527|       |	  /* duplicate arguments and protect */
 8528|      0|	  PROTECT(args = duplicate(CDR(call)));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 8529|       |	  /* insert evaluated promise for LHS as first argument */
 8530|       |	  /* promise won't be captured so don't track references */
 8531|      0|	  prom = R_mkEVPROMISE_NR(R_TmpvalSymbol, lhs);
 8532|      0|	  SETCAR(args, prom);
 8533|       |	  /* insert evaluated promise for RHS as last argument */
 8534|      0|	  last = args;
 8535|      0|	  while (CDR(last) != R_NilValue)
  ------------------
  |  Branch (8535:11): [True: 0, False: 0]
  ------------------
 8536|      0|	      last = CDR(last);
 8537|      0|	  prom = mkRHSPROMISE(vexpr, rhs);
 8538|      0|	  SETCAR(last, prom);
 8539|       |	  /* make the call */
 8540|      0|	  value = PRIMFUN(fun) (call, fun, args, rho);
  ------------------
  |  | 1345|      0|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 8541|      0|	  UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 8542|      0|	  break;
 8543|    561|	case CLOSXP:
  ------------------
  |  |  114|    561|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (8543:2): [True: 561, False: 771k]
  ------------------
 8544|       |	  /* push evaluated promise for RHS onto arguments with 'value' tag */
 8545|       |	  /* This need to use a standard EVPROMISE so the reference
 8546|       |	     from the environment to the RHS value is counted. */
 8547|    561|	  prom = R_mkEVPROMISE(vexpr, rhs);
 8548|    561|	  PUSHCALLARG(prom);
  ------------------
  |  | 6063|    561|#define PUSHCALLARG(v) PUSHCALLARG_EX(v, FALSE)
  |  |  ------------------
  |  |  |  | 6054|    561|#define PUSHCALLARG_EX(v, RC) do {					\
  |  |  |  | 6055|    561|	SEXP __cell__ =							\
  |  |  |  | 6056|    561|	    (RC) ? CONS(v, R_NilValue) : CONS_NR(v, R_NilValue);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6056:6): [Folded, False: 561]
  |  |  |  |  ------------------
  |  |  |  | 6057|    561|	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|    561|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|    561|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 561]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	if (GETSTACK(-2) == R_NilValue) SETSTACK(-2, __cell__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6057:6): [True: 0, False: 561]
  |  |  |  |  ------------------
  |  |  |  | 6058|    561|	else SETCDR(GETSTACK(-1), __cell__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|    561|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|    561|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 561]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6059|    561|	SETSTACK(-1, __cell__);						\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|    561|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|    561|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|    561|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|    561|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 561]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|    561|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|    561|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|    561|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|    561|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 561]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6060|    561|	if (RC) INCREMENT_NAMED(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6060:6): [Folded, False: 561]
  |  |  |  |  ------------------
  |  |  |  | 6061|    561|	else INCREMENT_LINKS(CAR(__cell__));				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  540|    561|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  |  |  541|    561|	SEXP il__x__ = (x);			\
  |  |  |  |  |  |  542|    561|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  222|    561|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 561]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  543|    561|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  |  |  544|    561|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (544:14): [Folded, False: 561]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6062|    561|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6062:14): [Folded, False: 561]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8549|    561|	  SETCALLARG_TAG_SYMBOL(R_valueSym);
  ------------------
  |  | 6081|    561|#define SETCALLARG_TAG_SYMBOL(t) do {			\
  |  | 6082|    561|	SEXP __cell__ = GETSTACK(-1);			\
  |  |  ------------------
  |  |  |  | 4903|    561|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|    561|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 561]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6083|    561|	if (__cell__ != R_NilValue)			\
  |  |  ------------------
  |  |  |  Branch (6083:6): [True: 561, False: 0]
  |  |  ------------------
  |  | 6084|    561|	    SET_TAG(__cell__, t);			\
  |  | 6085|    561|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6085:14): [Folded, False: 561]
  |  |  ------------------
  ------------------
 8550|       |	  /* replace first argument with evaluated promise for LHS */
 8551|       |	  /* promise might be captured, so track references */
 8552|    561|	  args = CLOSURE_CALL_FRAME_ARGS();
 8553|    561|	  prom = R_mkEVPROMISE(R_TmpvalSymbol, lhs);
 8554|    561|	  SETCAR(args, prom);
 8555|       |	  /* make the call */
 8556|    561|	  value = applyClosure(call, fun, args, rho, R_NilValue, TRUE);
  ------------------
  |  |  879|    561|#define applyClosure		Rf_applyClosure
  ------------------
 8557|    561|	  break;
 8558|      0|	default: error(_("bad function"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	default: error(_("bad function"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (8558:2): [True: 0, False: 771k]
  ------------------
 8559|   771k|	}
 8560|   771k|	POP_CALL_FRAME_PLUS(2, value);
  ------------------
  |  | 6047|   771k|#define POP_CALL_FRAME_PLUS(n, value) do {	\
  |  | 6048|   771k|	R_BCNodeStackTop -= (2 + (n));		\
  |  | 6049|   771k|	SETSTACK(-1, value);			\
  |  |  ------------------
  |  |  |  | 4905|   771k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|   771k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|   771k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|   771k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 771k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|   771k|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|   771k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|   771k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|   771k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 771k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6050|   771k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6050:14): [Folded, False: 771k]
  |  |  ------------------
  ------------------
 8561|   771k|	NEXT();
  ------------------
  |  | 5655|   771k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8562|   771k|      }
 8563|   771k|    OP(GETTER_CALL, 1):
  ------------------
  |  | 5638|   771k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   771k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   771k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   771k|    goto loop; \
  |  | 5642|   771k|    op_##name
  ------------------
 8564|      0|      {
 8565|      0|	SEXP lhs = GETSTACK_BELOW_CALL_FRAME(-2);
  ------------------
  |  | 6027|      0|#define GETSTACK_BELOW_CALL_FRAME(n) GETSTACK((n) - CALL_FRAME_SIZE())
  |  |  ------------------
  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8566|      0|	SEXP fun = CALL_FRAME_FUN();
  ------------------
  |  | 5996|      0|#define CALL_FRAME_FUN() GETSTACK(-3)
  |  |  ------------------
  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8567|      0|	SEXP call = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8568|      0|	SEXP value = NULL;
 8569|      0|	SEXP args, prom;
 8570|      0|	switch (TYPEOF(fun)) {
 8571|      0|	case BUILTINSXP:
  ------------------
  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (8571:2): [True: 0, False: 0]
  ------------------
 8572|       |	  /* replace first argument with LHS value */
 8573|      0|	  args = BUILTIN_CALL_FRAME_ARGS();
 8574|      0|	  SETCAR(args, lhs);
 8575|       |	  /* make the call */
 8576|      0|	  checkForMissings(args, call);
 8577|      0|	  value = PRIMFUN(fun) (call, fun, args, rho);
  ------------------
  |  | 1345|      0|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 8578|      0|	  break;
 8579|      0|	case SPECIALSXP:
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (8579:2): [True: 0, False: 0]
  ------------------
 8580|       |	  /* duplicate arguments and put into stack for GC protection */
 8581|      0|	  args = duplicate(CDR(call));
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 8582|      0|	  SETSTACK(-2, args);
  ------------------
  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8583|       |	  /* insert evaluated promise for LHS as first argument */
 8584|       |	  /* promise won't be captured so don't track references */
 8585|      0|	  prom = R_mkEVPROMISE_NR(R_TmpvalSymbol, lhs);
 8586|      0|	  SETCAR(args, prom);
 8587|       |	  /* make the call */
 8588|      0|	  value = PRIMFUN(fun) (call, fun, args, rho);
  ------------------
  |  | 1345|      0|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 8589|      0|	  break;
 8590|      0|	case CLOSXP:
  ------------------
  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (8590:2): [True: 0, False: 0]
  ------------------
 8591|       |	  /* replace first argument with evaluated promise for LHS */
 8592|       |	  /* promise might be captured, so track references */
 8593|      0|	  args = CLOSURE_CALL_FRAME_ARGS();
 8594|      0|	  prom = R_mkEVPROMISE(R_TmpvalSymbol, lhs);
 8595|      0|	  SETCAR(args, prom);
 8596|       |	  /* make the call */
 8597|      0|	  value = applyClosure(call, fun, args, rho, R_NilValue, TRUE);
  ------------------
  |  |  879|      0|#define applyClosure		Rf_applyClosure
  ------------------
 8598|      0|	  break;
 8599|      0|	default: error(_("bad function"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	default: error(_("bad function"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (8599:2): [True: 0, False: 0]
  ------------------
 8600|      0|	}
 8601|      0|	POP_CALL_FRAME(value);
  ------------------
  |  | 6045|      0|#define POP_CALL_FRAME(value) POP_CALL_FRAME_PLUS(0, value)
  |  |  ------------------
  |  |  |  | 6047|      0|#define POP_CALL_FRAME_PLUS(n, value) do {	\
  |  |  |  | 6048|      0|	R_BCNodeStackTop -= (2 + (n));		\
  |  |  |  | 6049|      0|	SETSTACK(-1, value);			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6050|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6050:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8602|      0|	NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8603|      0|      }
 8604|   385k|    OP(SWAP, 0): {
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|   385k|    op_##name
  ------------------
 8605|       |	/* This instruction only occurs between accessor calls in
 8606|       |	   complex assignments. [It should probably be renamed to
 8607|       |	   reflect this.] It needs to make sure intermediate LHS
 8608|       |	   values in complex assignments are not shared by duplicating
 8609|       |	   the extracted value in tmp when necessary. Duplicating is
 8610|       |	   necessary if the value might be shared _or_ if the
 8611|       |	   container, which is in R_BCNodeStackTop[-3], has become
 8612|       |	   possibly shared by going through a closure in the preceding
 8613|       |	   accessor call.  This is taken to indicate that the
 8614|       |	   corresponding replacement function might be a closure and
 8615|       |	   will need to see an unmodified LHS value. This heuristic
 8616|       |	   fails if the accessor function called here is not a closure
 8617|       |	   but the replacement function is. */
 8618|       |
 8619|       |	/* For the typed stack it might be OK just to force boxing at
 8620|       |	   this point, but for now this code tries to avoid doing
 8621|       |	   that. The macros make the code a little more readable. */
 8622|   385k|#define STACKVAL_MAYBE_REFERENCED(idx)				\
 8623|   385k|	(IS_STACKVAL_BOXED(idx) &&				\
 8624|   385k|	 MAYBE_REFERENCED(GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (idx))))
 8625|   385k|#define STACKVAL_MAYBE_SHARED(idx)				\
 8626|   385k|	(IS_STACKVAL_BOXED(idx) &&				\
 8627|   385k|	 MAYBE_SHARED(GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (idx))))
 8628|       |
 8629|   385k|	if (STACKVAL_MAYBE_REFERENCED(-1) &&
  ------------------
  |  | 8623|   770k|	(IS_STACKVAL_BOXED(idx) &&				\
  |  |  ------------------
  |  |  |  | 4886|   770k|#define IS_STACKVAL_BOXED(idx)	(R_BCNodeStackTop[idx].tag == 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4886:32): [True: 385k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 8624|   770k|	 MAYBE_REFERENCED(GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (idx))))
  |  |  ------------------
  |  |  |  |  251|   385k|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (251:29): [True: 385k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8630|   385k|	    (STACKVAL_MAYBE_SHARED(-1) ||
  ------------------
  |  | 8626|   770k|	(IS_STACKVAL_BOXED(idx) &&				\
  |  |  ------------------
  |  |  |  | 4886|   770k|#define IS_STACKVAL_BOXED(idx)	(R_BCNodeStackTop[idx].tag == 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4886:32): [True: 385k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 8627|   770k|	 MAYBE_SHARED(GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (idx))))
  |  |  ------------------
  |  |  |  | 4839|   385k|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (8627:3): [True: 2, False: 385k]
  |  |  ------------------
  ------------------
 8631|   385k|	     STACKVAL_MAYBE_SHARED(-3)))
  ------------------
  |  | 8626|   385k|	(IS_STACKVAL_BOXED(idx) &&				\
  |  |  ------------------
  |  |  |  | 4886|   770k|#define IS_STACKVAL_BOXED(idx)	(R_BCNodeStackTop[idx].tag == 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4886:32): [True: 385k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 8627|   385k|	 MAYBE_SHARED(GETSTACK_SXPVAL_PTR(R_BCNodeStackTop + (idx))))
  |  |  ------------------
  |  |  |  | 4839|   385k|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (8627:3): [True: 0, False: 385k]
  |  |  ------------------
  ------------------
 8632|   385k|	    SETSTACK(-1, shallow_duplicate(GETSTACK(-1)));
  ------------------
  |  | 4905|      2|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  ------------------
  |  |  |  | 4858|      2|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      2|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      2|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 2]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      4|    SEXP __v__ = (v); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4860:19): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  | 4861|      2|    (s)->tag = 0; \
  |  |  |  | 4862|      2|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      2|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8633|       |
 8634|   385k|	R_bcstack_t tmp = R_BCNodeStackTop[-1];
 8635|   385k|	R_BCNodeStackTop[-1] = R_BCNodeStackTop[-2];
 8636|   385k|	R_BCNodeStackTop[-2] = tmp;
 8637|   385k|	NEXT();
  ------------------
  |  | 5655|   385k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8638|   385k|    }
 8639|   385k|    OP(DUP2ND, 0): BCNDUP2ND(); NEXT();
  ------------------
  |  | 5638|   385k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   385k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   385k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   385k|    goto loop; \
  |  | 5642|   385k|    op_##name
  ------------------
                  OP(DUP2ND, 0): BCNDUP2ND(); NEXT();
  ------------------
  |  | 5504|   385k|#define BCNDUP2ND() do {					\
  |  | 5505|   385k|	R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1;		\
  |  | 5506|   385k|	if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow();	\
  |  |  ------------------
  |  |  |  Branch (5506:6): [True: 0, False: 385k]
  |  |  ------------------
  |  | 5507|   385k|	__ntop__[-1] = __ntop__[-3];				\
  |  | 5508|   385k|	R_BCNodeStackTop = __ntop__;				\
  |  | 5509|   385k|    } while(0)
  |  |  ------------------
  |  |  |  Branch (5509:13): [Folded, False: 385k]
  |  |  ------------------
  ------------------
                  OP(DUP2ND, 0): BCNDUP2ND(); NEXT();
  ------------------
  |  | 5655|   385k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8640|   385k|    OP(SWITCH, 4): {
  ------------------
  |  | 5638|   385k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   385k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   385k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   385k|    goto loop; \
  |  | 5642|   385k|    op_##name
  ------------------
 8641|    176|       SEXP call = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|    176|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8642|    176|       SEXP names = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|    176|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8643|    176|       SEXP coffsets = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|    176|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8644|    176|       SEXP ioffsets = GETCONST(constants, GETOP());
  ------------------
  |  | 5550|    176|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 8645|       |       /* Leave the value on the node stack for the whole instruction: the
 8646|       |	  node stack below R_BCNodeStackTop is the only thing rooting it, and
 8647|       |	  warningcall() below allocates and can run R-level handlers. */
 8648|    176|       SEXP value = GETSTACK(-1);
  ------------------
  |  | 4903|    176|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|    176|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 176]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8649|    176|       if (!isVector(value) || length(value) != 1)
  ------------------
  |  |  974|    176|#define isVector		Rf_isVector
  ------------------
                     if (!isVector(value) || length(value) != 1)
  ------------------
  |  |  987|    176|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (8649:12): [True: 0, False: 176]
  |  Branch (8649:32): [True: 0, False: 176]
  ------------------
 8650|      0|	   errorcall(call, _("EXPR must be a length 1 vector"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	   errorcall(call, _("EXPR must be a length 1 vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 8651|    176|       if (isFactor(value))
  ------------------
  |  |  946|    176|#define isFactor		Rf_isFactor
  ------------------
  |  Branch (8651:12): [True: 0, False: 176]
  ------------------
 8652|      0|	   warningcall(call,
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
 8653|      0|		       _("EXPR is a \"factor\", treated as integer.\n"
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 8654|      0|			 " Consider using '%s' instead."),
 8655|      0|		       "switch(as.character( * ), ...)");
 8656|    176|       if (TYPEOF(value) == STRSXP) {
  ------------------
  |  |  126|    176|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (8656:12): [True: 176, False: 0]
  ------------------
 8657|    176|	   int i, n, which;
 8658|    176|	   if (names == R_NilValue) {
  ------------------
  |  Branch (8658:9): [True: 0, False: 176]
  ------------------
 8659|      0|	       if (TYPEOF(ioffsets) != INTSXP)
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (8659:13): [True: 0, False: 0]
  ------------------
 8660|      0|		   errorcall(call, _("bad numeric 'switch' offsets"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		   errorcall(call, _("bad numeric 'switch' offsets"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 8661|      0|	       if (LENGTH(ioffsets) == 1) {
  ------------------
  |  Branch (8661:13): [True: 0, False: 0]
  ------------------
 8662|      0|		   pc = codebase + INTEGER(ioffsets)[0]; /* returns NULL */
 8663|      0|		   warningcall(call, _("'switch' with no alternatives"));
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              		   warningcall(call, _("'switch' with no alternatives"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 8664|      0|	       }
 8665|      0|	       else
 8666|      0|		   errorcall(call, _("numeric EXPR required for 'switch' "
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		   errorcall(call, _("numeric EXPR required for 'switch' "
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 8667|      0|				     "without named alternatives"));
 8668|    176|	   } else {
 8669|    176|	       if (TYPEOF(coffsets) != INTSXP)
  ------------------
  |  |  123|    176|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (8669:13): [True: 0, False: 176]
  ------------------
 8670|      0|		   errorcall(call, _("bad character 'switch' offsets"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		   errorcall(call, _("bad character 'switch' offsets"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 8671|    176|	       if (TYPEOF(names) != STRSXP || LENGTH(names) != LENGTH(coffsets))
  ------------------
  |  |  126|    352|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (8671:13): [True: 0, False: 176]
  |  Branch (8671:40): [True: 0, False: 176]
  ------------------
 8672|      0|		   errorcall(call, "bad 'switch' names");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 8673|    176|	       n = LENGTH(names);
 8674|    176|	       which = n - 1;
 8675|    767|	       for (i = 0; i < n - 1; i++)
  ------------------
  |  Branch (8675:21): [True: 685, False: 82]
  ------------------
 8676|    685|		   if (pmatch(STRING_ELT(value, 0),
  ------------------
  |  | 1011|    685|#define pmatch			Rf_pmatch
  ------------------
  |  Branch (8676:10): [True: 94, False: 591]
  ------------------
 8677|    685|			      STRING_ELT(names, i), 1 /* exact */)) {
 8678|     94|		       which = i;
 8679|     94|		       break;
 8680|     94|		   }
 8681|    176|	       pc = codebase + INTEGER(coffsets)[which];
 8682|    176|	   }
 8683|    176|       }
 8684|      0|       else {
 8685|      0|	   if (TYPEOF(ioffsets) != INTSXP)
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (8685:9): [True: 0, False: 0]
  ------------------
 8686|      0|	       errorcall(call, "bad numeric 'switch' offsets");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 8687|      0|	   int which = asInteger(value);
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
 8688|      0|	   if (which != NA_INTEGER) which--;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (8688:9): [True: 0, False: 0]
  ------------------
 8689|      0|	   if (which < 0 || which >= LENGTH(ioffsets))
  ------------------
  |  Branch (8689:9): [True: 0, False: 0]
  |  Branch (8689:22): [True: 0, False: 0]
  ------------------
 8690|      0|	       which = LENGTH(ioffsets) - 1;
 8691|      0|	   if (LENGTH(ioffsets) == 1)
  ------------------
  |  Branch (8691:9): [True: 0, False: 0]
  ------------------
 8692|      0|	       warningcall(call, _("'switch' with no alternatives"));
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              	       warningcall(call, _("'switch' with no alternatives"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 8693|      0|	   pc = codebase + INTEGER(ioffsets)[which];
 8694|      0|       }
 8695|    176|       BCNPOP_IGNORE_VALUE();
  ------------------
  |  | 5519|    176|#define BCNPOP_IGNORE_VALUE() R_BCNodeStackTop--
  ------------------
 8696|    176|       NEXT();
  ------------------
  |  | 5655|    176|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8697|    176|    }
 8698|   384k|    OP(RETURNJMP, 0): {
  ------------------
  |  | 5638|    178|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    178|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    178|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    178|    goto loop; \
  |  | 5642|   384k|    op_##name
  ------------------
 8699|   384k|      SEXP value = BCNPOP();
  ------------------
  |  | 5518|   384k|#define BCNPOP() (R_BCNodeStackTop--, GETSTACK(0))
  |  |  ------------------
  |  |  |  | 4903|   384k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|   384k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 12, False: 384k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 8700|   384k|      findcontext(CTXT_BROWSER | CTXT_FUNCTION, rho, value);
  ------------------
  |  | 1901|   384k|# define findcontext		Rf_findcontext
  ------------------
 8701|   384k|    }
 8702|   391k|    OP(STARTSUBSET_N, 2): DO_STARTDISPATCH_N("[");
  ------------------
  |  | 5638|   384k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   384k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   384k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   384k|    goto loop; \
  |  | 5642|   391k|    op_##name
  ------------------
                  OP(STARTSUBSET_N, 2): DO_STARTDISPATCH_N("[");
  ------------------
  |  | 6211|   391k|#define DO_STARTDISPATCH_N(generic) do { \
  |  | 6212|   391k|    int callidx = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|   391k|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6213|   391k|    SEXP value = GETSTACK(-1); \
  |  |  ------------------
  |  |  |  | 4903|   391k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|   391k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 26, False: 391k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6214|   391k|    if (isObject(value)) { \
  |  |  ------------------
  |  |  |  |  959|   391k|#define isObject		Rf_isObject
  |  |  ------------------
  |  |  |  Branch (6214:9): [True: 16, False: 391k]
  |  |  ------------------
  |  | 6215|     16|	SEXP call = GETCONST(constants, callidx); \
  |  |  ------------------
  |  |  |  | 5550|     16|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6216|     16|	if (tryDispatch(generic, call, value, rho, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6216:6): [True: 16, False: 0]
  |  |  ------------------
  |  | 6217|     16|	    SETSTACK(-1, value); \
  |  |  ------------------
  |  |  |  | 4905|     16|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|     16|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|     16|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|     16|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 16]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|     16|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|     16|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|     16|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|     16|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 16]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6218|     16|	    BC_CHECK_SIGINT(); \
  |  |  ------------------
  |  |  |  | 6281|     16|#define BC_CHECK_SIGINT() do {			\
  |  |  |  | 6282|     16|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   45|     16|#define BC_COUNT_DELTA 127
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6282:6): [True: 0, False: 16]
  |  |  |  |  ------------------
  |  |  |  | 6283|      0|	    bc_check_sigint();			\
  |  |  |  | 6284|      0|	    evalcount = 0;			\
  |  |  |  | 6285|      0|	}					\
  |  |  |  | 6286|     16|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6286:14): [Folded, False: 16]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6219|     16|	    int label = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|     16|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6220|     16|	    pc = codebase + label; \
  |  | 6221|     16|	    NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|     16|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6222|     16|	} \
  |  | 6223|     16|    } \
  |  | 6224|   391k|    SKIP_OP(); \
  |  |  ------------------
  |  |  |  | 5657|   391k|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 6225|   391k|    NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|   391k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6226|   391k|} while (0)
  |  |  ------------------
  |  |  |  Branch (6226:10): [Folded, False: 391k]
  |  |  ------------------
  ------------------
 8703|   391k|    OP(STARTSUBASSIGN_N, 2): DO_START_ASSIGN_DISPATCH_N("[<-");
  ------------------
  |  | 5638|   391k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   391k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   391k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   391k|    goto loop; \
  |  | 5642|   391k|    op_##name
  ------------------
                  OP(STARTSUBASSIGN_N, 2): DO_START_ASSIGN_DISPATCH_N("[<-");
  ------------------
  |  | 6228|    309|#define DO_START_ASSIGN_DISPATCH_N(generic) do { \
  |  | 6229|    309|    int callidx = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|    309|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6230|    309|    int label = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|    309|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6231|    309|    SEXP lhs = GETSTACK(-2); \
  |  |  ------------------
  |  |  |  | 4903|    309|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|    309|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 309]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6232|    309|    if (isObject(lhs)) { \
  |  |  ------------------
  |  |  |  |  959|    309|#define isObject		Rf_isObject
  |  |  ------------------
  |  |  |  Branch (6232:9): [True: 0, False: 309]
  |  |  ------------------
  |  | 6233|      0|	SEXP call = GETCONST(constants, callidx); \
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6234|      0|	MARK_ASSIGNMENT_CALL(call); \
  |  | 6235|      0|	SEXP rhs = GETSTACK(-1); \
  |  |  ------------------
  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6236|      0|	if (MAYBE_SHARED(lhs)) { \
  |  |  ------------------
  |  |  |  Branch (6236:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6237|      0|	    lhs = shallow_duplicate(lhs); \
  |  |  ------------------
  |  |  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  |  |  ------------------
  |  | 6238|      0|	    SETSTACK(-2, lhs); \
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6239|      0|	    ENSURE_NAMED(lhs); \
  |  | 6240|      0|	} \
  |  | 6241|      0|	SEXP value = NULL; \
  |  | 6242|      0|	if (tryAssignDispatch(generic, call, lhs, rhs, rho, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6242:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6243|      0|	    R_BCNodeStackTop--; \
  |  | 6244|      0|	    SETSTACK(-1, value); \
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6245|      0|	    BC_CHECK_SIGINT(); \
  |  |  ------------------
  |  |  |  | 6281|      0|#define BC_CHECK_SIGINT() do {			\
  |  |  |  | 6282|      0|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   45|      0|#define BC_COUNT_DELTA 127
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6282:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6283|      0|	    bc_check_sigint();			\
  |  |  |  | 6284|      0|	    evalcount = 0;			\
  |  |  |  | 6285|      0|	}					\
  |  |  |  | 6286|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6286:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6246|      0|	    pc = codebase + label; \
  |  | 6247|      0|	    NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6248|      0|	} \
  |  | 6249|      0|    } \
  |  | 6250|    309|    NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|    309|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6251|    309|} while (0)
  |  |  ------------------
  |  |  |  Branch (6251:10): [Folded, False: 309]
  |  |  ------------------
  ------------------
 8704|  1.16M|    OP(VECSUBSET2, 1): DO_VECSUBSET(rho, TRUE);
  ------------------
  |  | 5638|    311|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    311|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    311|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    311|    goto loop; \
  |  | 5642|  1.16M|    op_##name
  ------------------
                  OP(VECSUBSET2, 1): DO_VECSUBSET(rho, TRUE);
  ------------------
  |  | 6407|  1.16M|#define DO_VECSUBSET(rho, sub2) do {					\
  |  | 6408|  1.16M|	int callidx = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|  1.16M|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6409|  1.16M|	R_bcstack_t *sx = R_BCNodeStackTop - 2;				\
  |  | 6410|  1.16M|	R_bcstack_t *si = R_BCNodeStackTop - 1;				\
  |  | 6411|  1.16M|	SEXP vec = GETSTACK_PTR(sx);					\
  |  |  ------------------
  |  |  |  | 4837|  1.16M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.16M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6412|  1.16M|	if (si->tag == INTSXP && (sub2 || FAST_VECELT_OK(vec))) {	\
  |  |  ------------------
  |  |  |  |  123|  2.33M|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	if (si->tag == INTSXP && (sub2 || FAST_VECELT_OK(vec))) {	\
  |  |  ------------------
  |  |  |  | 6373|      0|    (ATTRIB(vec) == R_NilValue ||		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6373:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6374|      0|     (TAG(ATTRIB(vec)) == R_DimSymbol &&	\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6374:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6375|      0|      CDR(ATTRIB(vec)) == R_NilValue))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6375:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (6412:6): [True: 1.15M, False: 5.61k]
  |  |  |  Branch (6412:28): [True: 1.15M, Folded]
  |  |  ------------------
  |  | 6413|  1.15M|	    R_xlen_t i = si->u.ival;					\
  |  | 6414|  1.15M|	    switch (TYPEOF(vec)) {					\
  |  |  ------------------
  |  |  |  Branch (6414:14): [True: 0, False: 1.15M]
  |  |  ------------------
  |  | 6415|      0|		case REALSXP:						\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (6415:3): [True: 0, False: 1.15M]
  |  |  ------------------
  |  | 6416|      0|		    if (i <= 0 || XLENGTH(vec) < i) break;		\
  |  |  ------------------
  |  |  |  Branch (6416:11): [True: 0, False: 0]
  |  |  |  Branch (6416:21): [True: 0, False: 0]
  |  |  ------------------
  |  | 6417|      0|		    SETSTACK_REAL_PTR(sx, REAL_ELT(vec, i - 1));	\
  |  |  ------------------
  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6418|      0|		    DFVE_NEXT();					\
  |  |  ------------------
  |  |  |  | 6401|      0|#define	DFVE_NEXT() do {	\
  |  |  |  | 6402|      0|	R_Visible = TRUE;	\
  |  |  |  | 6403|      0|	R_BCNodeStackTop--;	\
  |  |  |  | 6404|      0|	NEXT();			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6405|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6405:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6419|      0|		case INTSXP:						\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (6419:3): [True: 0, False: 1.15M]
  |  |  ------------------
  |  | 6420|      0|		    if (i <= 0 || XLENGTH(vec) < i) break;		\
  |  |  ------------------
  |  |  |  Branch (6420:11): [True: 0, False: 0]
  |  |  |  Branch (6420:21): [True: 0, False: 0]
  |  |  ------------------
  |  | 6421|      0|		    SETSTACK_INTEGER_PTR(sx, INTEGER_ELT(vec, i - 1));	\
  |  |  ------------------
  |  |  |  | 4871|      0|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  | 4872|      0|    int __v__ = (v); \
  |  |  |  | 4873|      0|    (s)->tag = INTSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 4874|      0|    (s)->u.ival = __v__; \
  |  |  |  | 4875|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4875:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6422|      0|		    DFVE_NEXT();					\
  |  |  ------------------
  |  |  |  | 6401|      0|#define	DFVE_NEXT() do {	\
  |  |  |  | 6402|      0|	R_Visible = TRUE;	\
  |  |  |  | 6403|      0|	R_BCNodeStackTop--;	\
  |  |  |  | 6404|      0|	NEXT();			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6405|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6405:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6423|      0|		case LGLSXP:						\
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (6423:3): [True: 0, False: 1.15M]
  |  |  ------------------
  |  | 6424|      0|		    if (i <= 0 || XLENGTH(vec) < i) break;		\
  |  |  ------------------
  |  |  |  Branch (6424:11): [True: 0, False: 0]
  |  |  |  Branch (6424:21): [True: 0, False: 0]
  |  |  ------------------
  |  | 6425|      0|		    SETSTACK_LOGICAL_PTR(sx, LOGICAL_ELT(vec, i - 1));	\
  |  |  ------------------
  |  |  |  | 4877|      0|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  | 4878|      0|	int __v__ = (v);			\
  |  |  |  | 4879|      0|	(s)->tag = LGLSXP;			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 4880|      0|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4880:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4881|      0|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  ------------------
  |  |  |  | 4882|      0|	else					\
  |  |  |  | 4883|      0|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4883:20): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4884|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4884:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6426|      0|		    DFVE_NEXT();					\
  |  |  ------------------
  |  |  |  | 6401|      0|#define	DFVE_NEXT() do {	\
  |  |  |  | 6402|      0|	R_Visible = TRUE;	\
  |  |  |  | 6403|      0|	R_BCNodeStackTop--;	\
  |  |  |  | 6404|      0|	NEXT();			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6405|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6405:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6427|  1.15M|	    }								\
  |  | 6428|  1.15M|	}								\
  |  | 6429|  1.16M|	VECSUBSET_PTR(vec, si, sx, rho, constants, callidx, sub2);	\
  |  | 6430|  1.16M|	DFVE_NEXT();							\
  |  |  ------------------
  |  |  |  | 6401|  1.16M|#define	DFVE_NEXT() do {	\
  |  |  |  | 6402|  1.16M|	R_Visible = TRUE;	\
  |  |  |  | 6403|  1.16M|	R_BCNodeStackTop--;	\
  |  |  |  | 6404|  1.16M|	NEXT();			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|  1.16M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6405|  1.16M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6405:14): [Folded, False: 1.16M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6431|  1.16M|    } while(0)
  |  |  ------------------
  |  |  |  Branch (6431:13): [Folded, False: 1.16M]
  |  |  ------------------
  ------------------
 8705|  1.16M|    OP(MATSUBSET2, 1): DO_MATSUBSET(rho, TRUE); NEXT();
  ------------------
  |  | 5638|  1.16M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.16M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.16M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.16M|    goto loop; \
  |  | 5642|  1.16M|    op_##name
  ------------------
                  OP(MATSUBSET2, 1): DO_MATSUBSET(rho, TRUE); NEXT();
  ------------------
  |  | 6518|      0|#define DO_MATSUBSET(rho, sub2) do {					\
  |  | 6519|      0|	int callidx = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6520|      0|	R_bcstack_t *sx = R_BCNodeStackTop - 3;				\
  |  | 6521|      0|	MATSUBSET_PTR(sx, R_BCNodeStackTop - 2, R_BCNodeStackTop - 1,	\
  |  | 6522|      0|		      sx, rho, constants, callidx, sub2);		\
  |  | 6523|      0|	R_BCNodeStackTop -= 2;						\
  |  | 6524|      0|	R_Visible = TRUE;						\
  |  | 6525|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6525:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
                  OP(MATSUBSET2, 1): DO_MATSUBSET(rho, TRUE); NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8706|   772k|    OP(VECSUBASSIGN2, 1): DO_VECSUBASSIGN(rho, TRUE);
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|   772k|    op_##name
  ------------------
                  OP(VECSUBASSIGN2, 1): DO_VECSUBASSIGN(rho, TRUE);
  ------------------
  |  | 6669|   772k|#define DO_VECSUBASSIGN(rho, sub2) do {					\
  |  | 6670|   772k|	int callidx = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|   772k|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6671|   772k|	R_bcstack_t *sx = R_BCNodeStackTop - 3;				\
  |  | 6672|   772k|	R_bcstack_t *srhs = R_BCNodeStackTop - 2;			\
  |  | 6673|   772k|	R_bcstack_t *si = R_BCNodeStackTop - 1;				\
  |  | 6674|   772k|	SEXP vec = GETSTACK_PTR(sx);					\
  |  |  ------------------
  |  |  |  | 4837|   772k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 772k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6675|   772k|	if (MAYBE_SHARED(vec)) {					\
  |  |  ------------------
  |  |  |  Branch (6675:6): [True: 1.38k, False: 770k]
  |  |  ------------------
  |  | 6676|  1.38k|	    vec = shallow_duplicate(vec);				\
  |  |  ------------------
  |  |  |  | 1030|  1.38k|#define shallow_duplicate	Rf_shallow_duplicate
  |  |  ------------------
  |  | 6677|  1.38k|	    SETSTACK_PTR(sx, vec);					\
  |  |  ------------------
  |  |  |  | 4858|  1.38k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|  1.38k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|  1.38k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.38k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|  1.38k|    SEXP __v__ = (v); \
  |  |  |  | 4861|  1.38k|    (s)->tag = 0; \
  |  |  |  | 4862|  1.38k|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|  1.38k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.38k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6678|  1.38k|	}								\
  |  | 6679|   772k|	if (srhs->tag && si->tag == INTSXP &&				\
  |  |  ------------------
  |  |  |  |  123|   772k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (6679:6): [True: 0, False: 772k]
  |  |  |  Branch (6679:19): [True: 0, False: 0]
  |  |  ------------------
  |  | 6680|   772k|	    srhs->tag == TYPEOF(vec)) {					\
  |  |  ------------------
  |  |  |  Branch (6680:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6681|      0|	    R_xlen_t i = si->u.ival;					\
  |  | 6682|      0|	    /* i >= 0 rules out NA_INTEGER */				\
  |  | 6683|      0|	    if (i > 0 && i <= XLENGTH(vec)) {				\
  |  |  ------------------
  |  |  |  Branch (6683:10): [True: 0, False: 0]
  |  |  |  Branch (6683:19): [True: 0, False: 0]
  |  |  ------------------
  |  | 6684|      0|		switch (TYPEOF(vec)) {					\
  |  |  ------------------
  |  |  |  Branch (6684:11): [True: 0, False: 0]
  |  |  ------------------
  |  | 6685|      0|		case REALSXP:						\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (6685:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 6686|      0|		    REAL(vec)[i - 1] = srhs->u.dval;			\
  |  | 6687|      0|		    DFVA_NEXT(sx, vec);					\
  |  |  ------------------
  |  |  |  | 6662|      0|#define DFVA_NEXT(sx, vec) do {		\
  |  |  |  | 6663|      0|	SETSTACK_PTR(sx, vec);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6664|      0|	SETTER_CLEAR_NAMED(vec);	\
  |  |  |  | 6665|      0|	R_BCNodeStackTop -= 2;		\
  |  |  |  | 6666|      0|	NEXT();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6667|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6667:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6688|      0|		case INTSXP:						\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (6688:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 6689|      0|		    INTEGER(vec)[i - 1] = srhs->u.ival;			\
  |  | 6690|      0|		    DFVA_NEXT(sx, vec);					\
  |  |  ------------------
  |  |  |  | 6662|      0|#define DFVA_NEXT(sx, vec) do {		\
  |  |  |  | 6663|      0|	SETSTACK_PTR(sx, vec);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6664|      0|	SETTER_CLEAR_NAMED(vec);	\
  |  |  |  | 6665|      0|	R_BCNodeStackTop -= 2;		\
  |  |  |  | 6666|      0|	NEXT();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6667|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6667:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6691|      0|		case LGLSXP:						\
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (6691:3): [True: 0, False: 0]
  |  |  ------------------
  |  | 6692|      0|		    LOGICAL(vec)[i - 1] = srhs->u.ival;			\
  |  | 6693|      0|		    DFVA_NEXT(sx, vec);					\
  |  |  ------------------
  |  |  |  | 6662|      0|#define DFVA_NEXT(sx, vec) do {		\
  |  |  |  | 6663|      0|	SETSTACK_PTR(sx, vec);		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6664|      0|	SETTER_CLEAR_NAMED(vec);	\
  |  |  |  | 6665|      0|	R_BCNodeStackTop -= 2;		\
  |  |  |  | 6666|      0|	NEXT();				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 6667|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6667:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6694|      0|		}							\
  |  | 6695|      0|	    }								\
  |  | 6696|      0|	}								\
  |  | 6697|   772k|	VECSUBASSIGN_PTR(vec, srhs, si, sx, rho, constants, callidx, sub2); \
  |  | 6698|   772k|	R_BCNodeStackTop -= 2;						\
  |  | 6699|   772k|	NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|   772k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6700|   772k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6700:14): [Folded, False: 772k]
  |  |  ------------------
  ------------------
 8707|   772k|    OP(MATSUBASSIGN2, 1): DO_MATSUBASSIGN(rho, TRUE); NEXT();
  ------------------
  |  | 5638|   772k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   772k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   772k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   772k|    goto loop; \
  |  | 5642|   772k|    op_##name
  ------------------
                  OP(MATSUBASSIGN2, 1): DO_MATSUBASSIGN(rho, TRUE); NEXT();
  ------------------
  |  | 6749|      0|#define DO_MATSUBASSIGN(rho, sub2) do {					\
  |  | 6750|      0|	int callidx = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6751|      0|	R_bcstack_t *sx = R_BCNodeStackTop - 4;				\
  |  | 6752|      0|	MATSUBASSIGN_PTR(sx, R_BCNodeStackTop - 3,			\
  |  | 6753|      0|			 R_BCNodeStackTop - 2, R_BCNodeStackTop - 1,	\
  |  | 6754|      0|			 sx, rho, constants, callidx, sub2);		\
  |  | 6755|      0|	R_BCNodeStackTop -= 3;						\
  |  | 6756|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6756:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
                  OP(MATSUBASSIGN2, 1): DO_MATSUBASSIGN(rho, TRUE); NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8708|  1.16M|    OP(STARTSUBSET2_N, 2): DO_STARTDISPATCH_N("[[");
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|  1.16M|    op_##name
  ------------------
                  OP(STARTSUBSET2_N, 2): DO_STARTDISPATCH_N("[[");
  ------------------
  |  | 6211|  1.16M|#define DO_STARTDISPATCH_N(generic) do { \
  |  | 6212|  1.16M|    int callidx = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|  1.16M|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6213|  1.16M|    SEXP value = GETSTACK(-1); \
  |  |  ------------------
  |  |  |  | 4903|  1.16M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|  1.16M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 1.16M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6214|  1.16M|    if (isObject(value)) { \
  |  |  ------------------
  |  |  |  |  959|  1.16M|#define isObject		Rf_isObject
  |  |  ------------------
  |  |  |  Branch (6214:9): [True: 1.19k, False: 1.16M]
  |  |  ------------------
  |  | 6215|  1.19k|	SEXP call = GETCONST(constants, callidx); \
  |  |  ------------------
  |  |  |  | 5550|  1.19k|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6216|  1.19k|	if (tryDispatch(generic, call, value, rho, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6216:6): [True: 12, False: 1.18k]
  |  |  ------------------
  |  | 6217|     12|	    SETSTACK(-1, value); \
  |  |  ------------------
  |  |  |  | 4905|     12|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|     12|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|     12|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|     12|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 12]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|     12|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|     12|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|     12|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|     12|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 12]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6218|     12|	    BC_CHECK_SIGINT(); \
  |  |  ------------------
  |  |  |  | 6281|     12|#define BC_CHECK_SIGINT() do {			\
  |  |  |  | 6282|     12|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   45|     12|#define BC_COUNT_DELTA 127
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6282:6): [True: 0, False: 12]
  |  |  |  |  ------------------
  |  |  |  | 6283|      0|	    bc_check_sigint();			\
  |  |  |  | 6284|      0|	    evalcount = 0;			\
  |  |  |  | 6285|      0|	}					\
  |  |  |  | 6286|     12|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6286:14): [Folded, False: 12]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6219|     12|	    int label = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|     12|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6220|     12|	    pc = codebase + label; \
  |  | 6221|     12|	    NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|     12|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6222|     12|	} \
  |  | 6223|  1.19k|    } \
  |  | 6224|  1.16M|    SKIP_OP(); \
  |  |  ------------------
  |  |  |  | 5657|  1.16M|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 6225|  1.16M|    NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|  1.16M|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6226|  1.16M|} while (0)
  |  |  ------------------
  |  |  |  Branch (6226:10): [Folded, False: 1.16M]
  |  |  ------------------
  ------------------
 8709|  1.16M|    OP(STARTSUBASSIGN2_N, 2): DO_START_ASSIGN_DISPATCH_N("[[<-");
  ------------------
  |  | 5638|  1.16M|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  1.16M|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  1.16M|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  1.16M|    goto loop; \
  |  | 5642|  1.16M|    op_##name
  ------------------
                  OP(STARTSUBASSIGN2_N, 2): DO_START_ASSIGN_DISPATCH_N("[[<-");
  ------------------
  |  | 6228|   772k|#define DO_START_ASSIGN_DISPATCH_N(generic) do { \
  |  | 6229|   772k|    int callidx = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|   772k|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6230|   772k|    int label = GETOP(); \
  |  |  ------------------
  |  |  |  | 5656|   772k|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6231|   772k|    SEXP lhs = GETSTACK(-2); \
  |  |  ------------------
  |  |  |  | 4903|   772k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|   772k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 772k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6232|   772k|    if (isObject(lhs)) { \
  |  |  ------------------
  |  |  |  |  959|   772k|#define isObject		Rf_isObject
  |  |  ------------------
  |  |  |  Branch (6232:9): [True: 0, False: 772k]
  |  |  ------------------
  |  | 6233|      0|	SEXP call = GETCONST(constants, callidx); \
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6234|      0|	MARK_ASSIGNMENT_CALL(call); \
  |  | 6235|      0|	SEXP rhs = GETSTACK(-1); \
  |  |  ------------------
  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6236|      0|	if (MAYBE_SHARED(lhs)) { \
  |  |  ------------------
  |  |  |  Branch (6236:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6237|      0|	    lhs = shallow_duplicate(lhs); \
  |  |  ------------------
  |  |  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  |  |  ------------------
  |  | 6238|      0|	    SETSTACK(-2, lhs); \
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6239|      0|	    ENSURE_NAMED(lhs); \
  |  | 6240|      0|	} \
  |  | 6241|      0|	SEXP value = NULL; \
  |  | 6242|      0|	if (tryAssignDispatch(generic, call, lhs, rhs, rho, &value)) { \
  |  |  ------------------
  |  |  |  Branch (6242:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6243|      0|	    R_BCNodeStackTop--; \
  |  | 6244|      0|	    SETSTACK(-1, value); \
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6245|      0|	    BC_CHECK_SIGINT(); \
  |  |  ------------------
  |  |  |  | 6281|      0|#define BC_CHECK_SIGINT() do {			\
  |  |  |  | 6282|      0|	if (++evalcount > BC_COUNT_DELTA) {	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   45|      0|#define BC_COUNT_DELTA 127
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6282:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 6283|      0|	    bc_check_sigint();			\
  |  |  |  | 6284|      0|	    evalcount = 0;			\
  |  |  |  | 6285|      0|	}					\
  |  |  |  | 6286|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6286:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6246|      0|	    pc = codebase + label; \
  |  | 6247|      0|	    NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6248|      0|	} \
  |  | 6249|      0|    } \
  |  | 6250|   772k|    NEXT(); \
  |  |  ------------------
  |  |  |  | 5655|   772k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 6251|   772k|} while (0)
  |  |  ------------------
  |  |  |  Branch (6251:10): [Folded, False: 772k]
  |  |  ------------------
  ------------------
 8710|   772k|    OP(SUBSET_N, 2): DO_SUBSET_N(rho, FALSE); NEXT();
  ------------------
  |  | 5638|   772k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   772k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   772k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   772k|    goto loop; \
  |  | 5642|   772k|    op_##name
  ------------------
                  OP(SUBSET_N, 2): DO_SUBSET_N(rho, FALSE); NEXT();
  ------------------
  |  | 6572|      0|#define DO_SUBSET_N(rho, sub2) do {					\
  |  | 6573|      0|	int callidx = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6574|      0|	int rank = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6575|      0|	R_bcstack_t *sx = R_BCNodeStackTop - rank - 1;			\
  |  | 6576|      0|	SUBSET_N_PTR(sx, rank, R_BCNodeStackTop - rank, sx, rho,	\
  |  | 6577|      0|		     constants, callidx, sub2);				\
  |  | 6578|      0|	R_BCNodeStackTop -= rank;					\
  |  | 6579|      0|	R_Visible = TRUE;						\
  |  | 6580|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6580:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
                  OP(SUBSET_N, 2): DO_SUBSET_N(rho, FALSE); NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8711|      2|    OP(SUBSET2_N, 2): DO_SUBSET_N(rho, TRUE); NEXT();
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
                  OP(SUBSET2_N, 2): DO_SUBSET_N(rho, TRUE); NEXT();
  ------------------
  |  | 6572|      0|#define DO_SUBSET_N(rho, sub2) do {					\
  |  | 6573|      0|	int callidx = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6574|      0|	int rank = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6575|      0|	R_bcstack_t *sx = R_BCNodeStackTop - rank - 1;			\
  |  | 6576|      0|	SUBSET_N_PTR(sx, rank, R_BCNodeStackTop - rank, sx, rho,	\
  |  | 6577|      0|		     constants, callidx, sub2);				\
  |  | 6578|      0|	R_BCNodeStackTop -= rank;					\
  |  | 6579|      0|	R_Visible = TRUE;						\
  |  | 6580|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6580:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
                  OP(SUBSET2_N, 2): DO_SUBSET_N(rho, TRUE); NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8712|      2|    OP(SUBASSIGN_N, 2): DO_SUBASSIGN_N(rho, FALSE); NEXT();
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
                  OP(SUBASSIGN_N, 2): DO_SUBASSIGN_N(rho, FALSE); NEXT();
  ------------------
  |  | 6795|      0|#define DO_SUBASSIGN_N(rho, sub2) do {					\
  |  | 6796|      0|	int callidx = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6797|      0|	int rank = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6798|      0|	R_bcstack_t *sx = R_BCNodeStackTop - rank - 2;			\
  |  | 6799|      0|	SUBASSIGN_N_PTR(sx, rank, R_BCNodeStackTop - rank - 1,		\
  |  | 6800|      0|			R_BCNodeStackTop - rank, sx, rho,		\
  |  | 6801|      0|			constants, callidx, sub2);			\
  |  | 6802|      0|	R_BCNodeStackTop -= rank + 1;					\
  |  | 6803|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6803:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
                  OP(SUBASSIGN_N, 2): DO_SUBASSIGN_N(rho, FALSE); NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8713|      2|    OP(SUBASSIGN2_N, 2): DO_SUBASSIGN_N(rho, TRUE); NEXT();
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
                  OP(SUBASSIGN2_N, 2): DO_SUBASSIGN_N(rho, TRUE); NEXT();
  ------------------
  |  | 6795|      0|#define DO_SUBASSIGN_N(rho, sub2) do {					\
  |  | 6796|      0|	int callidx = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6797|      0|	int rank = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6798|      0|	R_bcstack_t *sx = R_BCNodeStackTop - rank - 2;			\
  |  | 6799|      0|	SUBASSIGN_N_PTR(sx, rank, R_BCNodeStackTop - rank - 1,		\
  |  | 6800|      0|			R_BCNodeStackTop - rank, sx, rho,		\
  |  | 6801|      0|			constants, callidx, sub2);			\
  |  | 6802|      0|	R_BCNodeStackTop -= rank + 1;					\
  |  | 6803|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6803:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
                  OP(SUBASSIGN2_N, 2): DO_SUBASSIGN_N(rho, TRUE); NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8714|      2|    OP(LOG, 1): DO_LOG(); NEXT();
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
                  OP(LOG, 1): DO_LOG(); NEXT();
  ------------------
  |  | 5232|      0|#define DO_LOG() do {							\
  |  | 5233|      0|	R_bcstack_t vvx;						\
  |  | 5234|      0|	R_bcstack_t *vx = bcStackScalarReal(R_BCNodeStackTop - 1, &vvx); \
  |  | 5235|      0|	if (vx->tag == REALSXP) {					\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5235:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5236|      0|	    double dval = R_log(vx->u.dval);				\
  |  | 5237|      0|	    if (ISNAN(dval)) {						\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5238|      0|		SEXP call = GETCONST(constants, GETOP());		\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5239|      0|		if (ISNAN(vx->u.dval)) dval = vx->u.dval;		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5240|      0|		else warningcall(call, R_MSG_NA);			\
  |  |  ------------------
  |  |  |  | 2013|      0|# define warningcall		Rf_warningcall
  |  |  ------------------
  |  |               		else warningcall(call, R_MSG_NA);			\
  |  |  ------------------
  |  |  |  | 5127|      0|#define R_MSG_NA	_("NaNs produced")
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5241|      0|	    }								\
  |  | 5242|      0|	    else SKIP_OP();						\
  |  |  ------------------
  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 5243|      0|	    SETSTACK_REAL(-1, dval);					\
  |  |  ------------------
  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5244|      0|	    R_Visible = TRUE;						\
  |  | 5245|      0|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5246|      0|	}								\
  |  | 5247|      0|	SEXP call = GETCONST(constants, GETOP());			\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5248|      0|	SEXP args = CONS_NR(GETSTACK(-1), R_NilValue);			\
  |  |  ------------------
  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5249|      0|	SETSTACK(-1, args); /* to protect */				\
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5250|      0|	SEXP op = getPrimitive(R_LogSym, SPECIALSXP);			\
  |  |  ------------------
  |  |  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  |  |  ------------------
  |  | 5251|      0|	SETSTACK(-1, do_log_builtin(call, op, args, rho));		\
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5252|      0|	R_Visible = TRUE;						\
  |  | 5253|      0|	NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5254|      0| } while (0)
  |  |  ------------------
  |  |  |  Branch (5254:11): [Folded, False: 0]
  |  |  ------------------
  ------------------
                  OP(LOG, 1): DO_LOG(); NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8715|      2|    OP(LOGBASE, 1): DO_LOGBASE(); NEXT();
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
                  OP(LOGBASE, 1): DO_LOGBASE(); NEXT();
  ------------------
  |  | 5256|      0|#define DO_LOGBASE() do {						\
  |  | 5257|      0|	R_bcstack_t vvx, vvy;						\
  |  | 5258|      0|	R_bcstack_t *vx = bcStackScalarReal(R_BCNodeStackTop - 2, &vvx); \
  |  | 5259|      0|	R_bcstack_t *vy = bcStackScalarReal(R_BCNodeStackTop - 1, &vvy); \
  |  | 5260|      0|	if (vx->tag == REALSXP && vy->tag == REALSXP) {			\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	if (vx->tag == REALSXP && vy->tag == REALSXP) {			\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5260:6): [True: 0, False: 0]
  |  |  |  Branch (5260:28): [True: 0, False: 0]
  |  |  ------------------
  |  | 5261|      0|	    double dval = logbase(vx->u.dval, vy->u.dval);		\
  |  | 5262|      0|	    if (ISNAN(dval)) {						\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5263|      0|		SEXP call = GETCONST(constants, GETOP());		\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5264|      0|		if (ISNAN(vx->u.dval)) dval = vx->u.dval;		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5265|      0|		else if (ISNAN(vy->u.dval)) dval = vy->u.dval;		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5266|      0|		else warningcall(call, R_MSG_NA);			\
  |  |  ------------------
  |  |  |  | 2013|      0|# define warningcall		Rf_warningcall
  |  |  ------------------
  |  |               		else warningcall(call, R_MSG_NA);			\
  |  |  ------------------
  |  |  |  | 5127|      0|#define R_MSG_NA	_("NaNs produced")
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5267|      0|	    }								\
  |  | 5268|      0|	    else SKIP_OP();						\
  |  |  ------------------
  |  |  |  | 5657|      0|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 5269|      0|	    R_BCNodeStackTop--;						\
  |  | 5270|      0|	    SETSTACK_REAL(-1, dval);					\
  |  |  ------------------
  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5271|      0|	    R_Visible = TRUE;						\
  |  | 5272|      0|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5273|      0|	}								\
  |  | 5274|      0|	SEXP call = GETCONST(constants, GETOP());			\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5275|      0|	SEXP tmp = GETSTACK(-2);					\
  |  |  ------------------
  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5276|      0|	SEXP args = CONS_NR(tmp, CONS_NR(GETSTACK(-1), R_NilValue));	\
  |  |  ------------------
  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5277|      0|	R_BCNodeStackTop--;						\
  |  | 5278|      0|	SETSTACK(-1, args); /* to protect */				\
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5279|      0|	SEXP op = getPrimitive(R_LogSym, SPECIALSXP);			\
  |  |  ------------------
  |  |  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  |  |  ------------------
  |  | 5280|      0|	SETSTACK(-1, do_log_builtin(call, op, args, rho));		\
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5281|      0|	R_Visible = TRUE;						\
  |  | 5282|      0|	NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5283|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5283:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
                  OP(LOGBASE, 1): DO_LOGBASE(); NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8716|      2|    OP(MATH1, 2): DO_MATH1(); NEXT();
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
                  OP(MATH1, 2): DO_MATH1(); NEXT();
  ------------------
  |  | 5328|      0|#define DO_MATH1() do {							\
  |  | 5329|      0|	SEXP call = GETCONST(constants, GETOP());			\
  |  |  ------------------
  |  |  |  | 5550|      0|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5330|      0|	double (*fun)(double) = getMath1Fun(GETOP(), call);		\
  |  |  ------------------
  |  |  |  | 5656|      0|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 5331|      0|	R_bcstack_t vvx;						\
  |  | 5332|      0|	R_bcstack_t *vx = bcStackScalarReal(R_BCNodeStackTop - 1, &vvx); \
  |  | 5333|      0|	if (vx->tag == REALSXP) {					\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5333:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5334|      0|	    double dval = fun(vx->u.dval);				\
  |  | 5335|      0|            if (ISNAN(dval)) {						\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5336|      0|		if (ISNAN(vx->u.dval)) dval = vx->u.dval;		\
  |  |  ------------------
  |  |  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5337|      0|		else warningcall(call, R_MSG_NA);			\
  |  |  ------------------
  |  |  |  | 2013|      0|# define warningcall		Rf_warningcall
  |  |  ------------------
  |  |               		else warningcall(call, R_MSG_NA);			\
  |  |  ------------------
  |  |  |  | 5127|      0|#define R_MSG_NA	_("NaNs produced")
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5338|      0|	    }								\
  |  | 5339|      0|	    SETSTACK_REAL(-1, dval);					\
  |  |  ------------------
  |  |  |  | 4907|      0|#define SETSTACK_REAL(i, v) SETSTACK_REAL_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5340|      0|	    R_Visible = TRUE;						\
  |  | 5341|      0|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5342|      0|	}								\
  |  | 5343|      0|	SEXP args = CONS_NR(GETSTACK(-1), R_NilValue);			\
  |  |  ------------------
  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5344|      0|	SEXP sym = CAR(call);						\
  |  | 5345|      0|	SETSTACK(-1, args); /* to protect */				\
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5346|      0|	SEXP op = getPrimitive(sym, BUILTINSXP);			\
  |  |  ------------------
  |  |  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  |  |  ------------------
  |  | 5347|      0|	SETSTACK(-1, do_math1(call, op, args, rho));			\
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5348|      0|	R_Visible = TRUE;						\
  |  | 5349|      0|	NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5350|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5350:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
                  OP(MATH1, 2): DO_MATH1(); NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8717|  4.77k|    OP(DOTCALL, 2): DO_DOTCALL(); NEXT();
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|  4.77k|    op_##name
  ------------------
                  OP(DOTCALL, 2): DO_DOTCALL(); NEXT();
  ------------------
  |  | 5355|  4.77k|#define DO_DOTCALL() do {						\
  |  | 5356|  4.77k|	SEXP call = GETCONST(constants, GETOP());			\
  |  |  ------------------
  |  |  |  | 5550|  4.77k|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 5357|  4.77k|	int nargs = GETOP();						\
  |  |  ------------------
  |  |  |  | 5656|  4.77k|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 5358|  4.77k|	DL_FUNC ofun = R_dotCallFn(GETSTACK(- nargs - 1), call, nargs);	\
  |  |  ------------------
  |  |  |  | 4903|  4.77k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|  4.77k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 4.77k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5359|  4.77k|	if (ofun && nargs <= DOTCALL_MAX) {				\
  |  |  ------------------
  |  |  |  | 5354|  4.77k|#define DOTCALL_MAX 16
  |  |  ------------------
  |  |  |  Branch (5359:6): [True: 4.77k, False: 0]
  |  |  |  Branch (5359:14): [True: 4.77k, False: 0]
  |  |  ------------------
  |  | 5360|  4.77k|	    SEXP cargs[DOTCALL_MAX];					\
  |  | 5361|  14.3k|	    for (int i = 0; i < nargs; i++)				\
  |  |  ------------------
  |  |  |  Branch (5361:22): [True: 9.53k, False: 4.77k]
  |  |  ------------------
  |  | 5362|  9.53k|		cargs[i] = GETSTACK(i - nargs);				\
  |  |  ------------------
  |  |  |  | 4903|  9.53k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|  9.53k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 6, False: 9.53k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5363|  4.77k|	    void *vmax = vmaxget();					\
  |  | 5364|  4.77k|	    SEXP val = R_doDotCall(ofun, nargs, cargs, call);		\
  |  | 5365|  4.77k|	    vmaxset(vmax);						\
  |  | 5366|  4.77k|	    R_BCNodeStackTop -= nargs;					\
  |  | 5367|  4.77k|	    SETSTACK(-1, val);						\
  |  |  ------------------
  |  |  |  | 4905|  4.77k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  4.77k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  4.77k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  4.77k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 4.77k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  4.77k|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|  4.77k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  4.77k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  4.77k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 4.77k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5368|  4.77k|	    R_Visible = TRUE;						\
  |  | 5369|  4.77k|	    NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|  4.77k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5370|  4.77k|	}								\
  |  | 5371|  4.77k|	SEXP args = R_NilValue;						\
  |  | 5372|  4.77k|	BCNPUSH(args); /* allocate space for protecting args */		\
  |  |  ------------------
  |  |  |  | 5449|  4.77k|#define BCNPUSH(v) do { \
  |  |  |  | 5450|  4.77k|  SEXP __value__ = (v); \
  |  |  |  | 5451|  4.77k|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|  4.77k|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 4.77k]
  |  |  |  |  ------------------
  |  |  |  | 5453|  4.77k|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  4.77k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  4.77k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  4.77k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  4.77k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 4.77k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  4.77k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  4.77k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  4.77k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  4.77k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 4.77k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|  4.77k|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|  4.77k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 4.77k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5373|  4.77k|	while (nargs-- >= 0) {						\
  |  |  ------------------
  |  |  |  Branch (5373:9): [True: 0, False: 4.77k]
  |  |  ------------------
  |  | 5374|      0|	    args = CONS_NR(GETSTACK(-2), args);				\
  |  |  ------------------
  |  |  |  | 4903|      0|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5375|      0|	    SETSTACK(-2, args); /* to protect */			\
  |  |  ------------------
  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5376|      0|	    BCNPOP_IGNORE_VALUE();					\
  |  |  ------------------
  |  |  |  | 5519|      0|#define BCNPOP_IGNORE_VALUE() R_BCNodeStackTop--
  |  |  ------------------
  |  | 5377|      0|	}								\
  |  | 5378|  4.77k|	SEXP sym = CAR(call);						\
  |  | 5379|  4.77k|	SEXP op = getPrimitive(sym, BUILTINSXP);			\
  |  |  ------------------
  |  |  |  |  119|  4.77k|#define BUILTINSXP   8	  /* builtin non-special forms */
  |  |  ------------------
  |  | 5380|  4.77k|	SETSTACK(-1, do_dotcall(call, op, args, rho));			\
  |  |  ------------------
  |  |  |  | 4905|  4.77k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  ------------------
  |  |  |  |  |  | 4858|  4.77k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  | 4859|  4.77k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4853|  4.77k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 4.77k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  | 4860|  4.77k|    SEXP __v__ = (v); \
  |  |  |  |  |  | 4861|  4.77k|    (s)->tag = 0; \
  |  |  |  |  |  | 4862|  4.77k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  | 4863|  4.77k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 4.77k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5381|  4.77k|	R_Visible = TRUE;						\
  |  | 5382|  4.77k|	NEXT();								\
  |  |  ------------------
  |  |  |  | 5655|  4.77k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5383|  4.77k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5383:14): [Folded, False: 4.77k]
  |  |  ------------------
  ------------------
                  OP(DOTCALL, 2): DO_DOTCALL(); NEXT();
  ------------------
  |  | 5655|  4.77k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8718|  4.77k|    OP(COLON, 1): DO_COLON(); NEXT();
  ------------------
  |  | 5638|  4.77k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  4.77k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  4.77k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  4.77k|    goto loop; \
  |  | 5642|  4.77k|    op_##name
  ------------------
                  OP(COLON, 1): DO_COLON(); NEXT();
  ------------------
  |  | 5385|    179|#define DO_COLON() do {							\
  |  | 5386|    179|	R_bcstack_t vvx, vvy;						\
  |  | 5387|    179|	R_bcstack_t *vx = bcStackScalarReal(R_BCNodeStackTop - 2, &vvx); \
  |  | 5388|    179|	R_bcstack_t *vy = bcStackScalarReal(R_BCNodeStackTop - 1, &vvy); \
  |  | 5389|    179|	if (vx->tag == REALSXP && vy->tag == REALSXP) {			\
  |  |  ------------------
  |  |  |  |  124|    358|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	if (vx->tag == REALSXP && vy->tag == REALSXP) {			\
  |  |  ------------------
  |  |  |  |  124|    179|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5389:6): [True: 179, False: 0]
  |  |  |  Branch (5389:28): [True: 179, False: 0]
  |  |  ------------------
  |  | 5390|    179|	    double rn1 = vx->u.dval;					\
  |  | 5391|    179|	    double rn2 = vy->u.dval;					\
  |  | 5392|    179|	    if (R_FINITE(rn1) && R_FINITE(rn2) &&			\
  |  |  ------------------
  |  |  |  |   82|    179|# define R_FINITE(x)    isfinite(x)
  |  |  ------------------
  |  |               	    if (R_FINITE(rn1) && R_FINITE(rn2) &&			\
  |  |  ------------------
  |  |  |  |   82|    179|# define R_FINITE(x)    isfinite(x)
  |  |  ------------------
  |  | 5393|    179|		INT_MIN <= rn1 && INT_MAX >= rn1 &&			\
  |  |  ------------------
  |  |  |  Branch (5393:3): [True: 179, False: 0]
  |  |  |  Branch (5393:21): [True: 179, False: 0]
  |  |  ------------------
  |  | 5394|    179|		INT_MIN <= rn2 && INT_MAX >= rn2 &&			\
  |  |  ------------------
  |  |  |  Branch (5394:3): [True: 179, False: 0]
  |  |  |  Branch (5394:21): [True: 179, False: 0]
  |  |  ------------------
  |  | 5395|    179|		rn1 == (int) rn1 && rn2 == (int) rn2) {			\
  |  |  ------------------
  |  |  |  Branch (5395:3): [True: 179, False: 0]
  |  |  |  Branch (5395:23): [True: 179, False: 0]
  |  |  ------------------
  |  | 5396|    179|		SKIP_OP(); /* skip 'call' index */			\
  |  |  ------------------
  |  |  |  | 5657|    179|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 5397|    179|		R_BCNodeStackTop--;					\
  |  | 5398|    179|		SETSTACK_INTSEQ(-1, rn1, rn2);				\
  |  |  ------------------
  |  |  |  | 4889|    179|#define SETSTACK_INTSEQ(idx, rn1, rn2) do {	\
  |  |  |  | 4890|    179|	SEXP info = allocVector(INTSXP, 2);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  875|    179|#define allocVector		Rf_allocVector
  |  |  |  |  ------------------
  |  |  |  |               	SEXP info = allocVector(INTSXP, 2);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|    179|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 4891|    179|	INTEGER(info)[0] = (int) rn1;		\
  |  |  |  | 4892|    179|	INTEGER(info)[1] = (int) rn2;		\
  |  |  |  | 4893|    179|	R_BCNodeStackTop[idx].u.sxpval = info;	\
  |  |  |  | 4894|    179|	R_BCNodeStackTop[idx].tag = INTSEQSXP;	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4800|    179|# define INTSEQSXP 9999
  |  |  |  |  ------------------
  |  |  |  | 4895|    179|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4895:14): [Folded, False: 179]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5399|    179|		R_Visible = TRUE;					\
  |  | 5400|    179|		NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|    179|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5401|    179|	    }								\
  |  | 5402|    179|	}								\
  |  | 5403|    179|	Builtin2(do_colon, R_ColonSymbol, rho);				\
  |  |  ------------------
  |  |  |  | 5092|    179|#define Builtin2(do_fun,which,rho) do {					\
  |  |  |  | 5093|    179|	SEXP stack1 = GETSTACK(-1);					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|    179|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|    179|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 179]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5094|    179|	SEXP stack2 = GETSTACK(-2);					\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4903|    179|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4837|    179|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 179]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5095|    179|	SEXP call = GETCONST(constants, GETOP());			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5550|    179|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  ------------------
  |  |  |  | 5096|    179|	SEXP tmp = CONS_NR(stack1, R_NilValue);				\
  |  |  |  | 5097|    179|	SETSTACK(-2, CONS_NR(stack2, tmp));				\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|    179|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|    179|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|    179|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|    179|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 179]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|    179|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|    179|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|    179|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|    179|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 179]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5098|    179|	R_BCNodeStackTop--;						\
  |  |  |  | 5099|    179|	SETSTACK(-1, do_fun(call, getPrimitive(which, BUILTINSXP),	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|    179|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|    179|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|    179|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|    179|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 179]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|    358|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 179]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4861|    179|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|    179|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|    179|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 179]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5100|    179|			    GETSTACK(-1), rho));			\
  |  |  |  | 5101|    179|	R_Visible = TRUE;						\
  |  |  |  | 5102|    179|	NEXT();								\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|    179|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5103|    179|    } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5103:13): [Folded, False: 179]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5404|    179|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5404:14): [Folded, False: 179]
  |  |  ------------------
  ------------------
                  OP(COLON, 1): DO_COLON(); NEXT();
  ------------------
  |  | 5655|    179|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
  |  Branch (8718:19): [True: 179, False: 0]
  |  Branch (8718:19): [True: 179, False: 0]
  ------------------
 8719|   385k|    OP(SEQALONG, 1): DO_SEQ_ALONG(); NEXT();
  ------------------
  |  | 5638|    181|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    181|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    181|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    181|    goto loop; \
  |  | 5642|   385k|    op_##name
  ------------------
                  OP(SEQALONG, 1): DO_SEQ_ALONG(); NEXT();
  ------------------
  |  | 5406|   385k|#define DO_SEQ_ALONG() do {					\
  |  | 5407|   385k|	SEXP x = GETSTACK(-1);					\
  |  |  ------------------
  |  |  |  | 4903|   385k|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|   385k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 385k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5408|   385k|	if (! OBJECT(x)) {					\
  |  |  ------------------
  |  |  |  Branch (5408:6): [True: 385k, False: 74]
  |  |  ------------------
  |  | 5409|   385k|	    R_xlen_t len = xlength(x);				\
  |  |  ------------------
  |  |  |  | 1049|   385k|#define xlength(x)		Rf_xlength(x)
  |  |  ------------------
  |  | 5410|   385k|	    if (len >= 1 && len <= INT_MAX) {			\
  |  |  ------------------
  |  |  |  Branch (5410:10): [True: 385k, False: 4]
  |  |  |  Branch (5410:22): [True: 385k, False: 0]
  |  |  ------------------
  |  | 5411|   385k|		SKIP_OP(); /* skip 'call' index */		\
  |  |  ------------------
  |  |  |  | 5657|   385k|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 5412|   385k|		SETSTACK_INTSEQ(-1, 1, len);			\
  |  |  ------------------
  |  |  |  | 4889|   385k|#define SETSTACK_INTSEQ(idx, rn1, rn2) do {	\
  |  |  |  | 4890|   385k|	SEXP info = allocVector(INTSXP, 2);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  875|   385k|#define allocVector		Rf_allocVector
  |  |  |  |  ------------------
  |  |  |  |               	SEXP info = allocVector(INTSXP, 2);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|   385k|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 4891|   385k|	INTEGER(info)[0] = (int) rn1;		\
  |  |  |  | 4892|   385k|	INTEGER(info)[1] = (int) rn2;		\
  |  |  |  | 4893|   385k|	R_BCNodeStackTop[idx].u.sxpval = info;	\
  |  |  |  | 4894|   385k|	R_BCNodeStackTop[idx].tag = INTSEQSXP;	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4800|   385k|# define INTSEQSXP 9999
  |  |  |  |  ------------------
  |  |  |  | 4895|   385k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4895:14): [Folded, False: 385k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5413|   385k|		R_Visible = TRUE;				\
  |  | 5414|   385k|		NEXT();						\
  |  |  ------------------
  |  |  |  | 5655|   385k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5415|   385k|	    }							\
  |  | 5416|   385k|	}							\
  |  | 5417|   385k|	Builtin1(do_seq_along, install("seq_along"), rho);	\
  |  |  ------------------
  |  |  |  | 5083|   385k|#define Builtin1(do_fun,which,rho) do {					\
  |  |  |  | 5084|   385k|	SEXP call = GETCONST(constants, GETOP());			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5550|   385k|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  ------------------
  |  |  |  | 5085|   385k|	SETSTACK(-1, CONS_NR(GETSTACK(-1), R_NilValue));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|   385k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|   385k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|   385k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|   385k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 385k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|   771k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 385k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4861|   385k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|   385k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|   385k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 385k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5086|   385k|	SETSTACK(-1, do_fun(call, getPrimitive(which, BUILTINSXP),	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|   385k|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|   385k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|   385k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|   385k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 385k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|   771k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 385k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4861|   385k|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|   385k|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|   385k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 385k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5087|   385k|			    GETSTACK(-1), rho));			\
  |  |  |  | 5088|   385k|	R_Visible = TRUE;						\
  |  |  |  | 5089|   385k|	NEXT();								\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|   385k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5090|   385k|    } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5090:13): [Folded, False: 385k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5418|   385k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5418:14): [Folded, False: 385k]
  |  |  ------------------
  ------------------
                  OP(SEQALONG, 1): DO_SEQ_ALONG(); NEXT();
  ------------------
  |  | 5655|   385k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8720|   385k|    OP(SEQLEN, 1): DO_SEQ_LEN(); NEXT();
  ------------------
  |  | 5638|   385k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|   385k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|   385k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|   385k|    goto loop; \
  |  | 5642|   385k|    op_##name
  ------------------
                  OP(SEQLEN, 1): DO_SEQ_LEN(); NEXT();
  ------------------
  |  | 5420|    962|#define DO_SEQ_LEN() do {						\
  |  | 5421|    962|	R_bcstack_t vvx;						\
  |  | 5422|    962|	R_bcstack_t *vx = bcStackScalarReal(R_BCNodeStackTop - 1, &vvx); \
  |  | 5423|    962|	if (vx->tag == REALSXP) {					\
  |  |  ------------------
  |  |  |  |  124|    962|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (5423:6): [True: 962, False: 0]
  |  |  ------------------
  |  | 5424|    962|	    double rlen = vx->u.dval;					\
  |  | 5425|    962|	    if (1 <= rlen && INT_MAX >= rlen &&				\
  |  |  ------------------
  |  |  |  Branch (5425:10): [True: 962, False: 0]
  |  |  |  Branch (5425:23): [True: 962, False: 0]
  |  |  ------------------
  |  | 5426|    962|		rlen == (int) rlen) {					\
  |  |  ------------------
  |  |  |  Branch (5426:3): [True: 962, False: 0]
  |  |  ------------------
  |  | 5427|    962|		SKIP_OP(); /* skip 'call' index */			\
  |  |  ------------------
  |  |  |  | 5657|    962|#define SKIP_OP() (pc++)
  |  |  ------------------
  |  | 5428|    962|		SETSTACK_INTSEQ(-1, 1, rlen);				\
  |  |  ------------------
  |  |  |  | 4889|    962|#define SETSTACK_INTSEQ(idx, rn1, rn2) do {	\
  |  |  |  | 4890|    962|	SEXP info = allocVector(INTSXP, 2);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  875|    962|#define allocVector		Rf_allocVector
  |  |  |  |  ------------------
  |  |  |  |               	SEXP info = allocVector(INTSXP, 2);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|    962|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 4891|    962|	INTEGER(info)[0] = (int) rn1;		\
  |  |  |  | 4892|    962|	INTEGER(info)[1] = (int) rn2;		\
  |  |  |  | 4893|    962|	R_BCNodeStackTop[idx].u.sxpval = info;	\
  |  |  |  | 4894|    962|	R_BCNodeStackTop[idx].tag = INTSEQSXP;	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4800|    962|# define INTSEQSXP 9999
  |  |  |  |  ------------------
  |  |  |  | 4895|    962|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4895:14): [Folded, False: 962]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5429|    962|		R_Visible = TRUE;					\
  |  | 5430|    962|		NEXT();							\
  |  |  ------------------
  |  |  |  | 5655|    962|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  ------------------
  |  | 5431|    962|	    }								\
  |  | 5432|    962|	}								\
  |  | 5433|    962|	Builtin1(do_seq_len, install("seq_len"), rho);			\
  |  |  ------------------
  |  |  |  | 5083|    962|#define Builtin1(do_fun,which,rho) do {					\
  |  |  |  | 5084|    962|	SEXP call = GETCONST(constants, GETOP());			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5550|    962|#define GETCONST(x, i) ((x).p)[i]
  |  |  |  |  ------------------
  |  |  |  | 5085|    962|	SETSTACK(-1, CONS_NR(GETSTACK(-1), R_NilValue));		\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|    962|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|    962|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|    962|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|    962|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 962]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  1.92k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 962]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4861|    962|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|    962|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|    962|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 962]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5086|    962|	SETSTACK(-1, do_fun(call, getPrimitive(which, BUILTINSXP),	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|    962|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|    962|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|    962|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|    962|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 962]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  1.92k|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4860:19): [True: 0, False: 962]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4861|    962|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|    962|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|    962|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 962]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5087|    962|			    GETSTACK(-1), rho));			\
  |  |  |  | 5088|    962|	R_Visible = TRUE;						\
  |  |  |  | 5089|    962|	NEXT();								\
  |  |  |  |  ------------------
  |  |  |  |  |  | 5655|    962|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  |  |  |  |  ------------------
  |  |  |  | 5090|    962|    } while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5090:13): [Folded, False: 962]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 5434|    962|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5434:14): [Folded, False: 962]
  |  |  ------------------
  ------------------
                  OP(SEQLEN, 1): DO_SEQ_LEN(); NEXT();
  ------------------
  |  | 5655|    962|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8721|  7.00k|    OP(BASEGUARD, 2): DO_BASEGUARD(); NEXT();
  ------------------
  |  | 5638|    964|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|    964|    opinfo[name##_OP].argc = (n); \
  |  | 5640|    964|    opinfo[name##_OP].instname = #name; \
  |  | 5641|    964|    goto loop; \
  |  | 5642|  7.00k|    op_##name
  ------------------
                  OP(BASEGUARD, 2): DO_BASEGUARD(); NEXT();
  ------------------
  |  | 6928|  7.00k|#define DO_BASEGUARD() do {				\
  |  | 6929|  7.00k|	SEXP expr = GETCONST(constants, GETOP());	\
  |  |  ------------------
  |  |  |  | 5550|  7.00k|#define GETCONST(x, i) ((x).p)[i]
  |  |  ------------------
  |  | 6930|  7.00k|	int label = GETOP();				\
  |  |  ------------------
  |  |  |  | 5656|  7.00k|#define GETOP() (*pc++).i
  |  |  ------------------
  |  | 6931|  7.00k|	SEXP sym = CAR(expr);				\
  |  | 6932|  7.00k|	if (findFun(sym, rho) != SymbolValue(sym)) {	\
  |  |  ------------------
  |  |  |  |  915|  7.00k|#define findFun			Rf_findFun
  |  |  ------------------
  |  |  |  Branch (6932:6): [True: 0, False: 7.00k]
  |  |  ------------------
  |  | 6933|      0|	    BCNPUSH(eval(expr, rho));			\
  |  |  ------------------
  |  |  |  | 5449|      0|#define BCNPUSH(v) do { \
  |  |  |  | 5450|      0|  SEXP __value__ = (v); \
  |  |  |  | 5451|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  |  |  | 5452|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5452:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 5453|      0|  SETSTACK(0, __value__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|      0|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 5454|      0|  R_BCNodeStackTop = __ntop__; \
  |  |  |  | 5455|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (5455:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6934|      0|	    pc = codebase + label;			\
  |  | 6935|      0|	}						\
  |  | 6936|  7.00k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6936:14): [Folded, False: 7.00k]
  |  |  ------------------
  ------------------
                  OP(BASEGUARD, 2): DO_BASEGUARD(); NEXT();
  ------------------
  |  | 5655|  7.00k|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8722|  7.00k|    OP(INCLNK, 0):
  ------------------
  |  | 5638|  7.00k|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|  7.00k|    opinfo[name##_OP].argc = (n); \
  |  | 5640|  7.00k|    opinfo[name##_OP].instname = #name; \
  |  | 5641|  7.00k|    goto loop; \
  |  | 5642|  7.00k|    op_##name
  ------------------
 8723|      0|      INCLNK_stack_commit(); /* needed for pre version 12 byte code */
 8724|      0|      INCLNK_STACK_PTR(R_BCNodeStackTop - 1);
  ------------------
  |  | 4977|      0|#define INCLNK_STACK_PTR(s) do {		\
  |  | 4978|      0|	if ((s)->tag == 0)			\
  |  |  ------------------
  |  |  |  Branch (4978:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 4979|      0|	    INCREMENT_LINKS((s)->u.sxpval);	\
  |  |  ------------------
  |  |  |  |  540|      0|#define INCREMENT_LINKS(x) do {			\
  |  |  |  |  541|      0|	SEXP il__x__ = (x);			\
  |  |  |  |  542|      0|	INCREMENT_NAMED(il__x__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  222|      0|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (222:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  543|      0|	INCREMENT_REFCNT(il__x__);		\
  |  |  |  |  544|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (544:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4980|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4980:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8725|      0|      NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8726|      2|    OP(DECLNK, 0):
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
 8727|      0|      DECLNK_STACK_PTR(R_BCNodeStackTop - 2);
  ------------------
  |  | 4982|      0|#define DECLNK_STACK_PTR(s) do {		\
  |  | 4983|      0|	if ((s)->tag == 0)			\
  |  |  ------------------
  |  |  |  Branch (4983:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 4984|      0|	    DECREMENT_LINKS((s)->u.sxpval);	\
  |  |  ------------------
  |  |  |  |  545|      0|#define DECREMENT_LINKS(x) do {			\
  |  |  |  |  546|      0|	SEXP dl__x__ = (x);			\
  |  |  |  |  547|      0|	DECREMENT_NAMED(dl__x__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  223|      0|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (223:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  548|      0|	DECREMENT_REFCNT(dl__x__);		\
  |  |  |  |  549|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (549:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4985|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4985:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8728|      0|      NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8729|      2|    OP(DECLNK_N, 1):
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
 8730|      0|      for (int n = GETOP(), i = 0; i < n; i++)
  ------------------
  |  | 5656|      0|#define GETOP() (*pc++).i
  ------------------
  |  Branch (8730:36): [True: 0, False: 0]
  ------------------
 8731|      0|	  DECLNK_STACK_PTR(R_BCNodeStackTop - 2 - i);
  ------------------
  |  | 4982|      0|#define DECLNK_STACK_PTR(s) do {		\
  |  | 4983|      0|	if ((s)->tag == 0)			\
  |  |  ------------------
  |  |  |  Branch (4983:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 4984|      0|	    DECREMENT_LINKS((s)->u.sxpval);	\
  |  |  ------------------
  |  |  |  |  545|      0|#define DECREMENT_LINKS(x) do {			\
  |  |  |  |  546|      0|	SEXP dl__x__ = (x);			\
  |  |  |  |  547|      0|	DECREMENT_NAMED(dl__x__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  223|      0|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (223:43): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  548|      0|	DECREMENT_REFCNT(dl__x__);		\
  |  |  |  |  549|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (549:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4985|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4985:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8732|      0|      NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8733|      2|    OP(INCLNKSTK, 0):
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
 8734|      0|      {
 8735|      0|	  int offset = (int)(R_BCProtTop - R_BCNodeStackBase);
 8736|      0|	  INCLNK_stack(R_BCNodeStackTop);
 8737|      0|	  BCNPUSH_INTEGER(offset);
  ------------------
  |  | 5471|      0|#define BCNPUSH_INTEGER(v) do { \
  |  | 5472|      0|  int __value__ = (v); \
  |  | 5473|      0|  R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1; \
  |  | 5474|      0|  if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5474:7): [True: 0, False: 0]
  |  |  ------------------
  |  | 5475|      0|  __ntop__[-1].u.ival = __value__; \
  |  | 5476|      0|  __ntop__[-1].tag = INTSXP; \
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  | 5477|      0|  R_BCNodeStackTop = __ntop__; \
  |  | 5478|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (5478:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 8738|      0|	  NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8739|      0|      }
 8740|      2|    OP(DECLNKSTK, 0):
  ------------------
  |  | 5638|      2|  case name##_OP: opinfo[name##_OP].addr = (__extension__ &&op_##name); \
  |  |  ------------------
  |  |  |  Branch (5638:3): [True: 2, False: 258]
  |  |  ------------------
  |  | 5639|      2|    opinfo[name##_OP].argc = (n); \
  |  | 5640|      2|    opinfo[name##_OP].instname = #name; \
  |  | 5641|      2|    goto loop; \
  |  | 5642|      2|    op_##name
  ------------------
 8741|      0|      {
 8742|      0|	  int offset = GETSTACK_IVAL_PTR(R_BCNodeStackTop - 2);
  ------------------
  |  | 4841|      0|#define GETSTACK_IVAL_PTR(s) ((s)->u.ival)
  ------------------
 8743|      0|	  R_bcstack_t *ptop = R_BCNodeStackBase + offset;
 8744|      0|	  DECLNK_stack(ptop);
 8745|      0|	  R_BCNodeStackTop[-2] = R_BCNodeStackTop[-1];
 8746|      0|	  R_BCNodeStackTop--;
 8747|      0|	  NEXT();
  ------------------
  |  | 5655|      0|#define NEXT() (__extension__ ({currentpc = pc; goto *(*pc++).v;}))
  ------------------
 8748|      0|      }
 8749|    262|    LASTOP;
  ------------------
  |  | 5645|    260|#define LASTOP } return R_NilValue
  ------------------
 8750|    262|  }
 8751|    262|}
eval.c:bc_check_sigint:
 6272|   386k|{
 6273|   386k|    R_CheckUserInterrupt();
 6274|   386k|#ifndef IMMEDIATE_FINALIZERS
 6275|       |    /* finalizers are run here since this should only be called at
 6276|       |       points where running arbitrary code should be safe */
 6277|   386k|    R_RunPendingFinalizers();
 6278|   386k|#endif
 6279|   386k|}
eval.c:GETSTACK_PTR_TAG:
 4809|   399k|{
 4810|       |    /* no error checking since only called with tag != 0 */
 4811|   399k|    SEXP value;
 4812|   399k|    switch (s->tag) {
 4813|  3.12k|    case REALSXP:
  ------------------
  |  |  124|  3.12k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (4813:5): [True: 3.12k, False: 395k]
  ------------------
 4814|  3.12k|	value = ScalarReal(s->u.dval);
  ------------------
  |  | 1024|  3.12k|#define ScalarReal		Rf_ScalarReal
  ------------------
 4815|  3.12k|	break;
 4816|   393k|    case INTSXP:
  ------------------
  |  |  123|   393k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (4816:5): [True: 393k, False: 5.65k]
  ------------------
 4817|   393k|	value = ScalarInteger(s->u.ival);
  ------------------
  |  | 1022|   393k|#define ScalarInteger		Rf_ScalarInteger
  ------------------
 4818|   393k|	break;
 4819|  2.35k|    case LGLSXP:
  ------------------
  |  |  121|  2.35k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (4819:5): [True: 2.35k, False: 396k]
  ------------------
 4820|  2.35k|	value = ScalarLogical(s->u.ival);
  ------------------
  |  | 1023|  2.35k|#define ScalarLogical		Rf_ScalarLogical
  ------------------
 4821|  2.35k|	break;
 4822|      0|#ifdef COMPACT_INTSEQ
 4823|    176|    case INTSEQSXP:
  ------------------
  |  | 4800|    176|# define INTSEQSXP 9999
  ------------------
  |  Branch (4823:5): [True: 176, False: 398k]
  ------------------
 4824|    176|	{
 4825|    176|	    int *seqinfo = INTEGER(s->u.sxpval);
 4826|    176|	    value = seq_int(seqinfo[0], seqinfo[1]);
 4827|    176|	}
 4828|    176|	break;
 4829|      0|#endif
 4830|      0|    default: /* not reached */
  ------------------
  |  Branch (4830:5): [True: 0, False: 399k]
  ------------------
 4831|      0|	value = NULL;
 4832|   399k|    }
 4833|   399k|    s->tag = 0;
 4834|   399k|    s->u.sxpval = value;
 4835|   399k|    return value;
 4836|   399k|}
eval.c:seq_int:
 4780|    176|{
 4781|    176|#define USE_ALTREP_COMPACT_INTRANGE
 4782|    176|#ifdef USE_ALTREP_COMPACT_INTRANGE
 4783|    176|    return R_compact_intrange(n1, n2);
 4784|       |#else
 4785|       |    int n = n1 <= n2 ? n2 - n1 + 1 : n1 - n2 + 1;
 4786|       |    SEXP ans = allocVector(INTSXP, n);
 4787|       |    int *data = INTEGER(ans);
 4788|       |    if (n1 <= n2)
 4789|       |	for (int i = 0; i < n; i++)
 4790|       |	    data[i] = n1 + i;
 4791|       |    else
 4792|       |	for (int i = 0; i < n; i++)
 4793|       |	    data[i] = n1 - i;
 4794|       |    return ans;
 4795|       |#endif
 4796|    176|}
eval.c:finish_force_promise:
 7506|  3.13M|{
 7507|  3.13M|    POP_PENDING_PROMISE(BCFRAME_PRSTACK());
  ------------------
  |  | 7342|  3.13M|#define BCFRAME_PRSTACK() (&(R_BCFrame->u.promvars.prstack))
  ------------------
 7508|  3.13M|    SEXP prom = BCFRAME_PROMISE();
  ------------------
  |  | 7340|  3.13M|#define BCFRAME_PROMISE() (R_BCFrame->u.promvars.promise)
  ------------------
 7509|  3.13M|    R_bcstack_t ubval = POP_BCFRAME(FALSE);
 7510|  3.13M|    BCNPUSH_STACKVAL(ubval); /* push early to protect */
  ------------------
  |  | 5489|  3.13M|#define BCNPUSH_STACKVAL(v) do {				\
  |  | 5490|  3.13M|	R_bcstack_t __value__ = (v);				\
  |  | 5491|  3.13M|	R_bcstack_t *__ntop__ = R_BCNodeStackTop + 1;		\
  |  | 5492|  3.13M|	if (__ntop__ > R_BCNodeStackEnd) nodeStackOverflow();	\
  |  |  ------------------
  |  |  |  Branch (5492:6): [True: 0, False: 3.13M]
  |  |  ------------------
  |  | 5493|  3.13M|	__ntop__[-1] = __value__;				\
  |  | 5494|  3.13M|	R_BCNodeStackTop = __ntop__;				\
  |  | 5495|  3.13M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5495:14): [Folded, False: 3.13M]
  |  |  ------------------
  ------------------
 7511|  3.13M|    SET_PROMISE_VALUE_FROM_STACKVAL(prom, ubval);
  ------------------
  |  | 5890|  3.13M|# define SET_PROMISE_VALUE_FROM_STACKVAL(prom, ubval)  do {		\
  |  | 5891|  3.13M|	SEXP value;							\
  |  | 5892|  3.13M|	SET_PROMISE_TAG(prom, ubval.tag);				\
  |  | 5893|  3.13M|	switch ((ubval).tag) {						\
  |  | 5894|     48|	case REALSXP: SET_PROMISE_DVAL(prom, (ubval).u.dval); break;	\
  |  |  ------------------
  |  |  |  |  124|     48|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |               	case REALSXP: SET_PROMISE_DVAL(prom, (ubval).u.dval); break;	\
  |  |  ------------------
  |  |  |  | 5847|     48|# define SET_PROMISE_DVAL SET_BNDCELL_DVAL
  |  |  ------------------
  |  |  |  Branch (5894:2): [True: 48, False: 3.13M]
  |  |  ------------------
  |  | 5895|    372|	case INTSXP: SET_PROMISE_IVAL(prom, (ubval).u.ival); break;	\
  |  |  ------------------
  |  |  |  |  123|    372|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |               	case INTSXP: SET_PROMISE_IVAL(prom, (ubval).u.ival); break;	\
  |  |  ------------------
  |  |  |  | 5848|    372|# define SET_PROMISE_IVAL SET_BNDCELL_IVAL
  |  |  ------------------
  |  |  |  Branch (5895:2): [True: 372, False: 3.13M]
  |  |  ------------------
  |  | 5896|     41|	case LGLSXP: SET_PROMISE_LVAL(prom, (ubval).u.ival); break;	\
  |  |  ------------------
  |  |  |  |  121|     41|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |               	case LGLSXP: SET_PROMISE_LVAL(prom, (ubval).u.ival); break;	\
  |  |  ------------------
  |  |  |  | 5849|     41|# define SET_PROMISE_LVAL SET_BNDCELL_LVAL
  |  |  ------------------
  |  |  |  Branch (5896:2): [True: 41, False: 3.13M]
  |  |  ------------------
  |  | 5897|  3.13M|	default:							\
  |  |  ------------------
  |  |  |  Branch (5897:2): [True: 3.13M, False: 461]
  |  |  ------------------
  |  | 5898|  3.13M|	    value = STACKVAL_TO_SEXP(ubval);				\
  |  | 5899|  3.13M|	    SET_PRVALUE(prom, value);					\
  |  | 5900|  3.13M|	    ENSURE_NAMEDMAX(value);					\
  |  | 5901|  3.13M|	}								\
  |  | 5902|  3.13M|    } while(0)
  |  |  ------------------
  |  |  |  Branch (5902:13): [Folded, False: 3.13M]
  |  |  ------------------
  ------------------
 7512|  3.13M|    SET_PRSEEN(prom, 0);
 7513|  3.13M|    SET_PRENV(prom, R_NilValue);
 7514|  3.13M|    UNPROTECT(1); /* prom */
  ------------------
  |  |  358|  3.13M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 7515|  3.13M|}
eval.c:POP_BCFRAME:
 7358|  6.26M|{
 7359|  6.26M|    R_bcstack_t val = has_cntxt ?
  ------------------
  |  Branch (7359:23): [True: 3.12M, False: 3.13M]
  ------------------
 7360|  3.12M|	BCFRAME_CNTXT()->returnValue :
  ------------------
  |  | 7333|  3.12M|#define BCFRAME_CNTXT() (R_BCFrame->pcntxt)
  ------------------
 7361|  6.26M|	R_BCNodeStackTop[-1];
 7362|  6.26M|    restore_bcEval_globals(BCFRAME_GLOBALS());
  ------------------
  |  | 7332|  6.26M|#define BCFRAME_GLOBALS() (&(R_BCFrame->globals))
  ------------------
 7363|  6.26M|    return val;
 7364|  6.26M|}
eval.c:finish_inline_closure_call:
 7443|  3.12M|{
 7444|  3.12M|    endcontext(BCFRAME_CNTXT());
  ------------------
  |  | 1895|  3.12M|# define endcontext		Rf_endcontext
  ------------------
                  endcontext(BCFRAME_CNTXT());
  ------------------
  |  | 7333|  3.12M|#define BCFRAME_CNTXT() (R_BCFrame->pcntxt)
  ------------------
 7445|  3.12M|    SEXP newrho = BCFRAME_NEWRHO();
  ------------------
  |  | 7334|  3.12M|#define BCFRAME_NEWRHO() (R_BCFrame->u.callvars.newrho)
  ------------------
 7446|  3.12M|    SEXP args = BCFRAME_ARGS();
  ------------------
  |  | 7336|  3.12M|#define BCFRAME_ARGS() (R_BCFrame->u.callvars.args)
  ------------------
 7447|  3.12M|    SEXP call = BCFRAME_CALL();
  ------------------
  |  | 7338|  3.12M|#define BCFRAME_CALL() (R_BCFrame->u.callvars.call)
  ------------------
 7448|  3.12M|    R_bcstack_t unboxed_val = POP_BCFRAME(TRUE);
 7449|       |
 7450|  3.12M|    if (unboxed_val.tag) {
  ------------------
  |  Branch (7450:9): [True: 948, False: 3.12M]
  ------------------
 7451|    948|#ifdef ADJUST_ENVIR_REFCNTS
 7452|    948|	R_CleanupEnvir(newrho, R_NilValue);
 7453|    948|	unpromiseArgs(args);
 7454|    948|#endif
 7455|    948|	UNPROTECT(1); /* newrho */
  ------------------
  |  |  358|    948|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 7456|    948|	POP_CALL_FRAME(R_NilValue);/**** maybe unboxed version?*/
  ------------------
  |  | 6045|    948|#define POP_CALL_FRAME(value) POP_CALL_FRAME_PLUS(0, value)
  |  |  ------------------
  |  |  |  | 6047|    948|#define POP_CALL_FRAME_PLUS(n, value) do {	\
  |  |  |  | 6048|    948|	R_BCNodeStackTop -= (2 + (n));		\
  |  |  |  | 6049|    948|	SETSTACK(-1, value);			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|    948|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|    948|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|    948|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|    948|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 948]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|    948|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|    948|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|    948|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|    948|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 948]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6050|    948|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6050:14): [Folded, False: 948]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7457|    948|	R_BCNodeStackTop[-1] = unboxed_val;
 7458|    948|    }
 7459|  3.12M|    else {
 7460|  3.12M|	SEXP value = unboxed_val.u.sxpval;
 7461|  3.12M|#ifdef ADJUST_ENVIR_REFCNTS
 7462|  3.12M|	Rboolean is_getter_call =
 7463|  3.12M|	    (CADR(call) == R_TmpvalSymbol &&
  ------------------
  |  Branch (7463:7): [True: 0, False: 3.12M]
  ------------------
 7464|      0|	     ! R_isReplaceSymbol(CAR(call)));
  ------------------
  |  Branch (7464:7): [True: 0, False: 0]
  ------------------
 7465|  3.12M|	R_CleanupEnvir(newrho, value);
 7466|  3.12M|	if (is_getter_call && MAYBE_REFERENCED(value))
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (7466:6): [True: 0, False: 3.12M]
  ------------------
 7467|      0|	    value = shallow_duplicate(value);
  ------------------
  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 7468|  3.12M|	unpromiseArgs(args);
 7469|  3.12M|#endif
 7470|  3.12M|#ifdef SUPPORT_TAILCALL
 7471|       |	/**** this could try to stay in the same bcEval, but don't
 7472|       |	      bother for now */
 7473|  3.12M|	value = handle_exec_continuation(value);
 7474|  3.12M|#endif
 7475|  3.12M|	UNPROTECT(1); /* newrho */
  ------------------
  |  |  358|  3.12M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 7476|  3.12M|	POP_CALL_FRAME(value);
  ------------------
  |  | 6045|  3.12M|#define POP_CALL_FRAME(value) POP_CALL_FRAME_PLUS(0, value)
  |  |  ------------------
  |  |  |  | 6047|  3.12M|#define POP_CALL_FRAME_PLUS(n, value) do {	\
  |  |  |  | 6048|  3.12M|	R_BCNodeStackTop -= (2 + (n));		\
  |  |  |  | 6049|  3.12M|	SETSTACK(-1, value);			\
  |  |  |  |  ------------------
  |  |  |  |  |  | 4905|  3.12M|#define SETSTACK(i, v) SETSTACK_PTR(R_BCNodeStackTop + (i), v)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4858|  3.12M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  |  |  |  |  | 4859|  3.12M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  | 4853|  3.12M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 3.12M]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 4860|  3.12M|    SEXP __v__ = (v); \
  |  |  |  |  |  |  |  | 4861|  3.12M|    (s)->tag = 0; \
  |  |  |  |  |  |  |  | 4862|  3.12M|    (s)->u.sxpval = __v__; \
  |  |  |  |  |  |  |  | 4863|  3.12M|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (4863:10): [Folded, False: 3.12M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 6050|  3.12M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (6050:14): [Folded, False: 3.12M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 7477|  3.12M|    }
 7478|  3.12M|}
eval.c:GETSTACK_LOGICAL_NO_NA_PTR:
 6948|  4.29M|{
 6949|  4.29M|    if (s->tag == LGLSXP && s->u.ival != NA_LOGICAL)
  ------------------
  |  |  121|  8.59M|#define LGLSXP	    10	  /* logical vectors */
  ------------------
                  if (s->tag == LGLSXP && s->u.ival != NA_LOGICAL)
  ------------------
  |  |   55|   778k|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (6949:9): [True: 778k, False: 3.51M]
  |  Branch (6949:29): [True: 778k, False: 0]
  ------------------
 6950|   778k|	return (Rboolean) s->u.ival;
 6951|       |
 6952|  3.51M|    SEXP value = GETSTACK_PTR(s);
  ------------------
  |  | 4837|  3.51M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (4837:26): [True: 8, False: 3.51M]
  |  |  ------------------
  ------------------
 6953|  3.51M|    if (IS_SCALAR(value, LGLSXP)) {
  ------------------
  |  |  121|  3.51M|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (6953:9): [True: 2.74M, False: 770k]
  ------------------
 6954|  2.74M|	int lval = SCALAR_LVAL(value);
 6955|  2.74M|	if (lval != NA_LOGICAL)
  ------------------
  |  |   55|  2.74M|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (6955:6): [True: 2.74M, False: 0]
  ------------------
 6956|  2.74M|	    return (Rboolean) lval;
 6957|  2.74M|    }
 6958|   770k|    SEXP call = GETCONST(constants, callidx);
  ------------------
  |  | 5550|   770k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
 6959|   770k|    PROTECT(value);
  ------------------
  |  |  357|   770k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 6960|   770k|    Rboolean ans = asLogicalNoNA(value, call);
 6961|   770k|    UNPROTECT(1);
  ------------------
  |  |  358|   770k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 6962|   770k|    return ans;
 6963|  3.51M|}
eval.c:BCNALLOC:
 5566|  10.5M|{
 5567|  10.5M|    int nelems = NELEMS_FOR_SIZE(size);
  ------------------
  |  | 5562|  10.5M|    ((int) (((size) + sizeof(R_bcstack_t) - 1) / sizeof(R_bcstack_t)))
  ------------------
 5568|  10.5M|    BCNSTACKCHECK(nelems + 1);
  ------------------
  |  | 5521|  10.5M|#define BCNSTACKCHECK(n)  do {						\
  |  | 5522|  10.5M|	if (R_BCNodeStackTop + (n) > R_BCNodeStackEnd) nodeStackOverflow(); \
  |  |  ------------------
  |  |  |  Branch (5522:6): [True: 0, False: 10.5M]
  |  |  ------------------
  |  | 5523|  10.5M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (5523:14): [Folded, False: 10.5M]
  |  |  ------------------
  ------------------
 5569|  10.5M|    R_BCNodeStackTop->tag = RAWMEM_TAG;
  ------------------
  |  | 1401|  10.5M|# define RAWMEM_TAG 254
  ------------------
 5570|  10.5M|    R_BCNodeStackTop->u.ival = nelems;
 5571|  10.5M|    R_BCNodeStackTop++;
 5572|  10.5M|    void *ans = R_BCNodeStackTop;
 5573|  10.5M|    R_BCNodeStackTop += nelems;
 5574|  10.5M|    return ans;
 5575|  10.5M|}
eval.c:BCNPOP_ALLOC:
 5578|     24|{
 5579|     24|    size_t nelems = NELEMS_FOR_SIZE(size);
  ------------------
  |  | 5562|     24|    ((int) (((size) + sizeof(R_bcstack_t) - 1) / sizeof(R_bcstack_t)))
  ------------------
 5580|     24|    R_BCNodeStackTop -= nelems + 1; /* '+ 1' is for the RAWMEM_TAG */
 5581|     24|}
eval.c:BCNPOP_AND_END_CNTXT:
 5592|     12|static R_INLINE void BCNPOP_AND_END_CNTXT(void) {
 5593|     12|    RCNTXT* cntxt = BCNALLOC_BASE(sizeof(RCNTXT));
 5594|     12|    endcontext(cntxt);
  ------------------
  |  | 1895|     12|# define endcontext		Rf_endcontext
  ------------------
 5595|     12|    BCNPOP_ALLOC(sizeof(RCNTXT));
 5596|     12|}
eval.c:BCNALLOC_BASE:
 5584|     12|{
 5585|     12|    size_t nelems = (size + sizeof(R_bcstack_t) - 1) / sizeof(R_bcstack_t);
 5586|     12|    return R_BCNodeStackTop - nelems;
 5587|     12|}
eval.c:getForLoopSeq:
 5437|   386k|{
 5438|   386k|#ifdef COMPACT_INTSEQ
 5439|   386k|    R_bcstack_t *s = R_BCNodeStackTop + offset;
 5440|   386k|    if (s->tag == INTSEQSXP) {
  ------------------
  |  | 4800|   386k|# define INTSEQSXP 9999
  ------------------
  |  Branch (5440:9): [True: 386k, False: 188]
  ------------------
 5441|   386k|	*iscompact = TRUE;
 5442|   386k|	return s->u.sxpval;
 5443|   386k|    }
 5444|    188|#endif
 5445|    188|    *iscompact = FALSE;
 5446|    188|    return GETSTACK(offset);
  ------------------
  |  | 4903|    188|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  ------------------
  |  |  |  | 4837|    188|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 188]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 5447|   386k|}
eval.c:NEW_BNDCELL_DVAL:
 5689|      1|{
 5690|      1|    INIT_BNDCELL(cell, REALSXP);
  ------------------
  |  |  124|      1|#define REALSXP	    14	  /* real variables */
  ------------------
 5691|      1|    SET_BNDCELL_DVAL(cell, dval);
 5692|      1|}
eval.c:NEW_BNDCELL_IVAL:
 5695|   386k|{
 5696|   386k|    INIT_BNDCELL(cell, INTSXP);
  ------------------
  |  |  123|   386k|#define INTSXP	    13	  /* integer vectors */
  ------------------
 5697|   386k|    SET_BNDCELL_IVAL(cell, ival);
 5698|   386k|}
eval.c:NEW_BNDCELL_LVAL:
 5701|      4|{
 5702|      4|    INIT_BNDCELL(cell, LGLSXP);
  ------------------
  |  |  121|      4|#define LGLSXP	    10	  /* logical vectors */
  ------------------
 5703|      4|    SET_BNDCELL_LVAL(cell, lval);
 5704|      4|}
eval.c:GET_BINDING_CELL_CACHE:
 5795|  27.7M|{
 5796|  27.7M|    SEXP cell = GET_CACHED_BINDING_CELL(vcache, idx);
  ------------------
  |  | 5770|  27.7M|    (vcache ? VCACHE(CACHEIDX(sidx)) : R_NilValue)
  |  |  ------------------
  |  |  |  | 5768|  27.7M|#  define VCACHE(i) GETSTACK_SXPVAL_PTR(vcache + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|  27.7M|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (5770:6): [True: 27.7M, False: 0]
  |  |  ------------------
  ------------------
 5797|       |    /* The value returned by GET_CACHED_BINDING_CELL is either a
 5798|       |       binding cell or R_NilValue.  TAG(R_NilValue) is R_NilValue, and
 5799|       |       that will not equal symbol. So a separate test for cell !=
 5800|       |       R_NilValue is not needed. */
 5801|  27.7M|    if (TAG(cell) == symbol && ! BNDCELL_UNBOUND(cell))
  ------------------
  |  | 5686|  12.0M|#define BNDCELL_UNBOUND(v) (BNDCELL_TAG(v) == 0 && CAR0(v) == R_UnboundValue)
  |  |  ------------------
  |  |  |  Branch (5686:29): [True: 12.0M, False: 12]
  |  |  |  Branch (5686:52): [True: 0, False: 12.0M]
  |  |  ------------------
  ------------------
  |  Branch (5801:9): [True: 12.0M, False: 15.6M]
  ------------------
 5802|  12.0M|	return cell;
 5803|  15.6M|    else {
 5804|  15.6M|	SEXP ncell = GET_BINDING_CELL(symbol, rho);
 5805|  15.6M|	if (ncell != R_NilValue)
  ------------------
  |  Branch (5805:6): [True: 15.5M, False: 69.3k]
  ------------------
 5806|  15.5M|	    SET_CACHED_BINDING(vcache, idx, ncell);
  ------------------
  |  | 5774|  15.5M|    do { if (vcache) VCACHE(CACHEIDX(sidx)) = (cell); } while (0)
  |  |  ------------------
  |  |  |  | 5768|  15.5M|#  define VCACHE(i) GETSTACK_SXPVAL_PTR(vcache + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|  15.5M|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (5774:14): [True: 15.5M, False: 0]
  |  |  |  Branch (5774:64): [Folded, False: 15.5M]
  |  |  ------------------
  ------------------
 5807|  69.3k|	else if (cell != R_NilValue && BNDCELL_UNBOUND(cell))
  ------------------
  |  | 5686|      2|#define BNDCELL_UNBOUND(v) (BNDCELL_TAG(v) == 0 && CAR0(v) == R_UnboundValue)
  |  |  ------------------
  |  |  |  Branch (5686:29): [True: 2, False: 0]
  |  |  |  Branch (5686:52): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  |  Branch (5807:11): [True: 2, False: 69.3k]
  ------------------
 5808|      0|	    SET_CACHED_BINDING(vcache, idx, R_NilValue);
  ------------------
  |  | 5774|      0|    do { if (vcache) VCACHE(CACHEIDX(sidx)) = (cell); } while (0)
  |  |  ------------------
  |  |  |  | 5768|      0|#  define VCACHE(i) GETSTACK_SXPVAL_PTR(vcache + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4839|      0|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (5774:14): [True: 0, False: 0]
  |  |  |  Branch (5774:64): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5809|  15.6M|	return ncell;
 5810|  15.6M|    }
 5811|  27.7M|}
eval.c:findVarEX:
 5831|  9.05M|{
 5832|  9.05M|    if (dd)
  ------------------
  |  Branch (5832:9): [True: 0, False: 9.05M]
  ------------------
 5833|      0|	return ddfindVar(symbol, rho);
  ------------------
  |  | 1880|      0|# define ddfindVar		Rf_ddfindVar
  ------------------
 5834|  9.05M|    else if (vcache != NULL) {
  ------------------
  |  Branch (5834:14): [True: 9.05M, False: 254]
  ------------------
 5835|  9.05M|	SEXP cell = GET_BINDING_CELL_CACHE(symbol, rho, vcache, sidx);
 5836|  9.05M|	SEXP value = BINDING_VALUE(cell);
 5837|  9.05M|	if (value == R_UnboundValue)
  ------------------
  |  Branch (5837:6): [True: 44.5k, False: 9.00M]
  ------------------
 5838|  44.5k|	    return FIND_VAR_NO_CACHE(symbol, rho, cell);
 5839|  9.00M|	else
 5840|  9.00M|	    return value;
 5841|  9.05M|    }
 5842|    254|    else
 5843|    254|	return R_findVar(symbol, rho);
 5844|  9.05M|}
eval.c:FIND_VAR_NO_CACHE:
 5819|  44.5k|{
 5820|  44.5k|    R_varloc_t loc =  R_findVarLoc(symbol, rho);
 5821|  44.5k|    if (loc.cell && IS_ACTIVE_BINDING(loc.cell)) {
  ------------------
  |  Branch (5821:9): [True: 44.5k, False: 0]
  |  Branch (5821:21): [True: 4, False: 44.5k]
  ------------------
 5822|      4|	SEXP value = R_GetVarLocValue(loc);
 5823|      4|	return value;
 5824|      4|    }
 5825|  44.5k|    else return R_GetVarLocValue(loc);
 5826|  44.5k|}
eval.c:setup_bcframe_prom:
 7487|  3.52M|{
 7488|  3.52M|    PROTECT(prom);
  ------------------
  |  |  357|  3.52M|#define PROTECT(s)	Rf_protect(s)
  ------------------
 7489|  3.52M|    SET_PRSEEN(prom, 1);
 7490|  3.52M|    R_BCFrame = PUSH_BCFRAME(FALSE);
 7491|  3.52M|    INCREMENT_EVAL_DEPTH();
  ------------------
  |  | 1067|  3.52M|#define INCREMENT_EVAL_DEPTH() do {		\
  |  | 1068|  3.52M|	R_EvalDepth++;				\
  |  | 1069|  3.52M|	if (R_EvalDepth > R_Expressions)	\
  |  |  ------------------
  |  |  |  Branch (1069:6): [True: 0, False: 3.52M]
  |  |  ------------------
  |  | 1070|  3.52M|	    handle_eval_depth_overflow();	\
  |  | 1071|  3.52M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (1071:14): [Folded, False: 3.52M]
  |  |  ------------------
  ------------------
 7492|  3.52M|    SET_BCFRAME_PROMISE(prom);
  ------------------
  |  | 7341|  3.52M|#define SET_BCFRAME_PROMISE(val) (R_BCFrame->u.promvars.promise = (val))
  ------------------
 7493|  3.52M|    PUSH_PENDING_PROMISE(prom, BCFRAME_PRSTACK());
  ------------------
  |  | 7342|  3.52M|#define BCFRAME_PRSTACK() (&(R_BCFrame->u.promvars.prstack))
  ------------------
 7494|  3.52M|    R_Visible = TRUE;
 7495|  3.52M|    return bcode_setup_locals(PRCODE(prom), PRENV(prom));
 7496|  3.52M|}
eval.c:PUSH_BCFRAME:
 7346|  7.03M|{
 7347|  7.03M|    R_bcstack_t *oldtop = R_BCNodeStackTop;
 7348|  7.03M|    RCNTXT *pcntxt = need_cntxt ? BCNALLOC_CNTXT() : NULL;
  ------------------
  |  | 5590|  3.51M|#define BCNALLOC_CNTXT() (RCNTXT *) BCNALLOC(sizeof(RCNTXT))
  ------------------
  |  Branch (7348:22): [True: 3.51M, False: 3.52M]
  ------------------
 7349|  7.03M|    R_bcFrame_type *rec = (R_bcFrame_type *) BCNALLOC(sizeof(R_bcFrame_type));
 7350|  7.03M|    save_bcEval_globals(&(rec->globals));
 7351|       |    /* modify saved stack top to the value before pushing the frame */
 7352|  7.03M|    rec->globals.oldntop = oldtop; // must come after save_bcEval_globals!!
 7353|  7.03M|    rec->pcntxt = pcntxt;
 7354|  7.03M|    return rec;
 7355|  7.03M|}
eval.c:getvar:
 5858|  2.76M|{
 5859|  2.76M|    SEXP value = findVarEX(symbol, rho, dd, vcache, sidx);
 5860|       |
 5861|  2.76M|    if (value == R_UnboundValue)
  ------------------
  |  Branch (5861:9): [True: 0, False: 2.76M]
  ------------------
 5862|      0|	UNBOUND_VARIABLE_ERROR(symbol, rho);
 5863|  2.76M|    else if (value == R_MissingArg) {
  ------------------
  |  Branch (5863:14): [True: 0, False: 2.76M]
  ------------------
 5864|      0|	if (!keepmiss) R_MissingArgError(symbol, getLexicalCall(rho), "getvarError");
  ------------------
  |  Branch (5864:6): [True: 0, False: 0]
  ------------------
 5865|      0|	return R_MissingArg;
 5866|      0|    }
 5867|  2.76M|    else if (TYPEOF(value) == PROMSXP) {
  ------------------
  |  |  116|  2.76M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (5867:14): [True: 2.74M, False: 19.3k]
  ------------------
 5868|  2.74M|	if (PROMISE_IS_EVALUATED(value))
  ------------------
  |  Branch (5868:6): [True: 5.03k, False: 2.73M]
  ------------------
 5869|  5.03k|	    return PRVALUE(value);
 5870|  2.73M|	else {
 5871|       |	    /**** R_isMissing is inefficient */
 5872|  2.73M|	    if (keepmiss) {
  ------------------
  |  Branch (5872:10): [True: 998, False: 2.73M]
  ------------------
 5873|    998|		PROTECT(value);
  ------------------
  |  |  357|    998|#define PROTECT(s)	Rf_protect(s)
  ------------------
 5874|    998|		Rboolean miss = R_isMissing(symbol, rho);
 5875|    998|		UNPROTECT(1);
  ------------------
  |  |  358|    998|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 5876|    998|		if (miss)
  ------------------
  |  Branch (5876:7): [True: 0, False: 998]
  ------------------
 5877|      0|		    return R_MissingArg;
 5878|    998|	    }
 5879|  2.73M|	    forcePromise(value);
 5880|  2.73M|	    return PRVALUE(value);
 5881|  2.73M|	}
 5882|  2.74M|    }
 5883|  19.3k|    else {
 5884|  19.3k|	ENSURE_NAMED(value); /* needed for .Last.value - LT */
 5885|  19.3k|	return value;
 5886|  19.3k|    }
 5887|  2.76M|}
eval.c:getPrimitive:
 5013|  9.71M|{
 5014|  9.71M|    SEXP value = SYMVALUE(symbol);
 5015|  9.71M|    if (TYPEOF(value) == PROMSXP) {
  ------------------
  |  |  116|  9.71M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (5015:9): [True: 0, False: 9.71M]
  ------------------
 5016|      0|	ENSURE_PROMISE_IS_EVALUATED(value);
  ------------------
  |  |  946|      0|#define ENSURE_PROMISE_IS_EVALUATED(x) do {	\
  |  |  947|      0|	SEXP __x__ = (x);			\
  |  |  948|      0|	if (! PROMISE_IS_EVALUATED(__x__))	\
  |  |  ------------------
  |  |  |  Branch (948:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|	    forcePromise(__x__);		\
  |  |  950|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (950:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5017|      0|	value = PRVALUE(value);
 5018|      0|    }
 5019|  9.71M|    if (TYPEOF(value) != type) {
  ------------------
  |  Branch (5019:9): [True: 0, False: 9.71M]
  ------------------
 5020|       |	/* probably means a package redefined the base function so
 5021|       |	   try to get the real thing from the internal table of
 5022|       |	   primitives */
 5023|      0|	value = R_Primitive(CHAR(PRINTNAME(symbol)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 5024|      0|	if (TYPEOF(value) != type)
  ------------------
  |  Branch (5024:6): [True: 0, False: 0]
  ------------------
 5025|       |	    /* if that doesn't work we signal an error */
 5026|      0|	    error(_("\"%s\" is not a %s function"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("\"%s\" is not a %s function"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5027|      0|		  CHAR(PRINTNAME(symbol)),
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 5028|      0|		  type == BUILTINSXP ? "BUILTIN" : "SPECIAL");
  ------------------
  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (5028:5): [True: 0, False: 0]
  ------------------
 5029|      0|    }
 5030|  9.71M|    return value;
 5031|  9.71M|}
eval.c:BUILTIN_CALL_FRAME_ARGS:
 6002|  13.9M|{
 6003|  13.9M|    SEXP args = CALL_FRAME_ARGS();
  ------------------
  |  | 5997|  13.9M|#define CALL_FRAME_ARGS() GETSTACK(-2)
  |  |  ------------------
  |  |  |  | 4903|  13.9M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|  13.9M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 13.9M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 6004|  37.2M|    for (SEXP a = args; a  != R_NilValue; a = CDR(a))
  ------------------
  |  Branch (6004:25): [True: 23.2M, False: 13.9M]
  ------------------
 6005|  23.2M|	DECREMENT_LINKS(CAR(a));
  ------------------
  |  |  545|  23.2M|#define DECREMENT_LINKS(x) do {			\
  |  |  546|  23.2M|	SEXP dl__x__ = (x);			\
  |  |  547|  23.2M|	DECREMENT_NAMED(dl__x__);		\
  |  |  ------------------
  |  |  |  |  223|  23.2M|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (223:43): [Folded, False: 23.2M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  548|  23.2M|	DECREMENT_REFCNT(dl__x__);		\
  |  |  549|  23.2M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (549:14): [Folded, False: 23.2M]
  |  |  ------------------
  ------------------
 6006|  13.9M|    return args;
 6007|  13.9M|}
eval.c:checkForMissings:
 6853|  2.31M|{
 6854|  2.31M|    Rboolean found = FALSE;
 6855|  5.40M|    for (SEXP a = args; a != R_NilValue; a = CDR(a))
  ------------------
  |  Branch (6855:25): [True: 3.08M, False: 2.31M]
  ------------------
 6856|  3.08M|	if (CAR(a) == R_MissingArg) {
  ------------------
  |  Branch (6856:6): [True: 0, False: 3.08M]
  ------------------
 6857|      0|	    found = TRUE;
 6858|      0|	    break;
 6859|      0|	}
 6860|  2.31M|    if (found)
  ------------------
  |  Branch (6860:9): [True: 0, False: 2.31M]
  ------------------
 6861|      0|	signalMissingArgError(args, call);
 6862|  2.31M|}
eval.c:markSpecialArgs:
 7190|  12.6k|{
 7191|  12.6k|    SEXP arg;
 7192|  28.1k|    for(arg = args; arg != R_NilValue; arg = CDR(arg))
  ------------------
  |  Branch (7192:21): [True: 15.4k, False: 12.6k]
  ------------------
 7193|  15.4k|	MARK_NOT_MUTABLE(CAR(arg));
 7194|  12.6k|    return args;
 7195|  12.6k|}
eval.c:CLOSURE_CALL_FRAME_ARGS:
 6010|  3.51M|{
 6011|  3.51M|    SEXP args = CALL_FRAME_ARGS();
  ------------------
  |  | 5997|  3.51M|#define CALL_FRAME_ARGS() GETSTACK(-2)
  |  |  ------------------
  |  |  |  | 4903|  3.51M|#define GETSTACK(i) GETSTACK_PTR(R_BCNodeStackTop + (i))
  |  |  |  |  ------------------
  |  |  |  |  |  | 4837|  3.51M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4837:26): [True: 0, False: 3.51M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 6012|       |    /* it would be better not to build this arglist with CONS_NR in
 6013|       |       the first place */
 6014|  3.51M|#ifndef NO_CALL_FRAME_ARGS_NR
 6015|  8.99M|    for (SEXP a = args; a  != R_NilValue; a = CDR(a)) {
  ------------------
  |  Branch (6015:25): [True: 5.47M, False: 3.51M]
  ------------------
 6016|  5.47M|	DECREMENT_LINKS(CAR(a));
  ------------------
  |  |  545|  5.47M|#define DECREMENT_LINKS(x) do {			\
  |  |  546|  5.47M|	SEXP dl__x__ = (x);			\
  |  |  547|  5.47M|	DECREMENT_NAMED(dl__x__);		\
  |  |  ------------------
  |  |  |  |  223|  5.47M|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (223:43): [Folded, False: 5.47M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  548|  5.47M|	DECREMENT_REFCNT(dl__x__);		\
  |  |  549|  5.47M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (549:14): [Folded, False: 5.47M]
  |  |  ------------------
  ------------------
 6017|  5.47M|	if (! TRACKREFS(a)) {
  ------------------
  |  Branch (6017:6): [True: 5.47M, False: 0]
  ------------------
 6018|  5.47M|	    ENABLE_REFCNT(a);
 6019|  5.47M|	    INCREMENT_REFCNT(CAR(a));
 6020|  5.47M|	    INCREMENT_REFCNT(CDR(a));
 6021|  5.47M|	}
 6022|  5.47M|    }
 6023|  3.51M|#endif
 6024|  3.51M|    return args;
 6025|  3.51M|}
eval.c:setup_bcframe_call:
 7421|  3.51M|{
 7422|  3.51M|    SEXP newrho = make_applyClosure_env(call, fun, args, rho, R_NilValue);
 7423|  3.51M|    PROTECT(newrho);
  ------------------
  |  |  357|  3.51M|#define PROTECT(s)	Rf_protect(s)
  ------------------
 7424|  3.51M|    R_BCFrame = PUSH_BCFRAME(TRUE);
 7425|  3.51M|    begincontext(BCFRAME_CNTXT(), CTXT_RETURN, call, newrho, rho, args, fun);
  ------------------
  |  | 1864|  3.51M|# define begincontext		Rf_begincontext
  ------------------
                  begincontext(BCFRAME_CNTXT(), CTXT_RETURN, call, newrho, rho, args, fun);
  ------------------
  |  | 7333|  3.51M|#define BCFRAME_CNTXT() (R_BCFrame->pcntxt)
  ------------------
 7426|  3.51M|    INCREMENT_EVAL_DEPTH();
  ------------------
  |  | 1067|  3.51M|#define INCREMENT_EVAL_DEPTH() do {		\
  |  | 1068|  3.51M|	R_EvalDepth++;				\
  |  | 1069|  3.51M|	if (R_EvalDepth > R_Expressions)	\
  |  |  ------------------
  |  |  |  Branch (1069:6): [True: 0, False: 3.51M]
  |  |  ------------------
  |  | 1070|  3.51M|	    handle_eval_depth_overflow();	\
  |  | 1071|  3.51M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (1071:14): [Folded, False: 3.51M]
  |  |  ------------------
  ------------------
 7427|  3.51M|    SET_BCFRAME_NEWRHO(newrho);
  ------------------
  |  | 7335|  3.51M|#define SET_BCFRAME_NEWRHO(val) (R_BCFrame->u.callvars.newrho = (val))
  ------------------
 7428|  3.51M|    SET_BCFRAME_CALL(call);
  ------------------
  |  | 7339|  3.51M|#define SET_BCFRAME_CALL(val) (R_BCFrame->u.callvars.call = (val))
  ------------------
 7429|  3.51M|    SET_BCFRAME_ARGS(args);
  ------------------
  |  | 7337|  3.51M|#define SET_BCFRAME_ARGS(val) (R_BCFrame->u.callvars.args = (val))
  ------------------
 7430|  3.51M|    R_Visible = TRUE;
 7431|  3.51M|    return bcode_setup_locals(BODY(fun), newrho);
 7432|  3.51M|}
eval.c:bcStackScalar:
 4924|  3.88M|{
 4925|  3.88M|    switch (s->tag) {
  ------------------
  |  Branch (4925:13): [True: 778k, False: 3.10M]
  ------------------
 4926|  1.01k|    case REALSXP:
  ------------------
  |  |  124|  1.01k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (4926:5): [True: 1.01k, False: 3.88M]
  ------------------
 4927|   778k|    case INTSXP:
  ------------------
  |  |  123|   778k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (4927:5): [True: 777k, False: 3.10M]
  ------------------
 4928|   778k|    case LGLSXP: return s;
  ------------------
  |  |  121|   778k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (4928:5): [True: 0, False: 3.88M]
  ------------------
 4929|  3.88M|    }
 4930|       |
 4931|  3.10M|    SEXP x = GETSTACK_SXPVAL_PTR(s);
  ------------------
  |  | 4839|  3.10M|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  ------------------
 4932|  3.10M|    if (IS_SIMPLE_SCALAR(x, REALSXP)) {
  ------------------
  |  |  218|  3.10M|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (218:6): [True: 1.28k, False: 3.10M]
  |  |  |  Branch (218:28): [True: 1.28k, False: 0]
  |  |  ------------------
  ------------------
 4933|  1.28k|	v->tag = REALSXP;
  ------------------
  |  |  124|  1.28k|#define REALSXP	    14	  /* real variables */
  ------------------
 4934|  1.28k|	v->u.dval = SCALAR_DVAL(x);
 4935|  1.28k|	return v;
 4936|  1.28k|    }
 4937|  3.10M|    else if (IS_SIMPLE_SCALAR(x, INTSXP)) {
  ------------------
  |  |  218|  3.10M|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (218:6): [True: 783k, False: 2.31M]
  |  |  |  Branch (218:28): [True: 783k, False: 4]
  |  |  ------------------
  ------------------
 4938|   783k|	v->tag = INTSXP;
  ------------------
  |  |  123|   783k|#define INTSXP	    13	  /* integer vectors */
  ------------------
 4939|   783k|	v->u.ival = SCALAR_IVAL(x);
 4940|   783k|	return v;
 4941|   783k|    }
 4942|  2.31M|    else if (IS_SIMPLE_SCALAR(x, LGLSXP)) {
  ------------------
  |  |  218|  2.31M|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (218:6): [True: 26, False: 2.31M]
  |  |  |  Branch (218:28): [True: 26, False: 0]
  |  |  ------------------
  ------------------
 4943|     26|	v->tag = LGLSXP;
  ------------------
  |  |  121|     26|#define LGLSXP	    10	  /* logical vectors */
  ------------------
 4944|     26|	v->u.ival = SCALAR_LVAL(x);
 4945|     26|	return v;
 4946|     26|    }
 4947|  2.31M|    else {
 4948|  2.31M|	v->tag = 0;
 4949|       |	v->u.sxpval = NULL;
 4950|  2.31M|	return v;
 4951|  2.31M|    }
 4952|  3.10M|}
eval.c:cmp_arith1:
 5051|     14|{
 5052|     14|    SEXP op = getPrimitive(opsym, BUILTINSXP);
  ------------------
  |  |  119|     14|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
 5053|     14|    if (isObject(x)) {
  ------------------
  |  |  959|     14|#define isObject		Rf_isObject
  ------------------
  |  Branch (5053:9): [True: 0, False: 14]
  ------------------
 5054|      0|	SEXP args, ans;
 5055|      0|	args = CONS_NR(x, R_NilValue);
 5056|      0|	PROTECT(args);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 5057|      0|	if (DispatchGroup("Ops", call, op, args, rho, &ans)) {
  ------------------
  |  | 1886|      0|# define DispatchGroup		Rf_DispatchGroup
  ------------------
  |  Branch (5057:6): [True: 0, False: 0]
  ------------------
 5058|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 5059|      0|	    return ans;
 5060|      0|	}
 5061|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 5062|      0|    }
 5063|     14|    return R_unary(call, op, x);
 5064|     14|}
eval.c:cmp_arith2:
 5068|    146|{
 5069|    146|    SEXP op = getPrimitive(opsym, BUILTINSXP);
  ------------------
  |  |  119|    146|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
 5070|    146|    if (isObject(x) || isObject(y)) {
  ------------------
  |  |  959|    146|#define isObject		Rf_isObject
  ------------------
                  if (isObject(x) || isObject(y)) {
  ------------------
  |  |  959|    146|#define isObject		Rf_isObject
  ------------------
  |  Branch (5070:9): [True: 0, False: 146]
  |  Branch (5070:24): [True: 0, False: 146]
  ------------------
 5071|      0|	SEXP args, ans;
 5072|      0|	args = CONS_NR(x, CONS_NR(y, R_NilValue));
 5073|      0|	PROTECT(args);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 5074|      0|	if (DispatchGroup("Ops", call, op, args, rho, &ans)) {
  ------------------
  |  | 1886|      0|# define DispatchGroup		Rf_DispatchGroup
  ------------------
  |  Branch (5074:6): [True: 0, False: 0]
  ------------------
 5075|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 5076|      0|	    return ans;
 5077|      0|	}
 5078|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 5079|      0|    }
 5080|    146|    return R_binary(call, op, x, y);
 5081|    146|}
eval.c:cmp_relop:
 5035|   773k|{
 5036|   773k|    SEXP op = getPrimitive(opsym, BUILTINSXP);
  ------------------
  |  |  119|   773k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
 5037|   773k|    if (isObject(x) || isObject(y)) {
  ------------------
  |  |  959|   773k|#define isObject		Rf_isObject
  ------------------
                  if (isObject(x) || isObject(y)) {
  ------------------
  |  |  959|   773k|#define isObject		Rf_isObject
  ------------------
  |  Branch (5037:9): [True: 38, False: 773k]
  |  Branch (5037:24): [True: 0, False: 773k]
  ------------------
 5038|     38|	SEXP args, ans;
 5039|     38|	args = CONS_NR(x, CONS_NR(y, R_NilValue));
 5040|     38|	PROTECT(args);
  ------------------
  |  |  357|     38|#define PROTECT(s)	Rf_protect(s)
  ------------------
 5041|     38|	if (DispatchGroup("Ops", call, op, args, rho, &ans)) {
  ------------------
  |  | 1886|     38|# define DispatchGroup		Rf_DispatchGroup
  ------------------
  |  Branch (5041:6): [True: 38, False: 0]
  ------------------
 5042|     38|	    UNPROTECT(1);
  ------------------
  |  |  358|     38|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 5043|     38|	    return ans;
 5044|     38|	}
 5045|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 5046|      0|    }
 5047|   773k|    return do_relop_dflt(call, op, x, y);
 5048|   773k|}
eval.c:tryDispatch:
 6088|   775k|{
 6089|   775k|  RCNTXT cntxt;
 6090|   775k|  SEXP pargs, rho1;
 6091|   775k|  int dispatched = FALSE;
 6092|   775k|  SEXP op = SYMVALUE(install(generic)); /**** avoid this */
  ------------------
  |  |  934|   775k|#define install			Rf_install
  ------------------
 6093|       |
 6094|   775k|  PROTECT(pargs = promiseArgs(CDR(call), rho));
  ------------------
  |  |  357|   775k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 6095|   775k|  IF_PROMSXP_SET_PRVALUE(CAR(pargs), x);
 6096|       |
 6097|       |  /**** Minimal hack to try to handle the S4 case.  If we do the check
 6098|       |	and do not dispatch then some arguments beyond the first might
 6099|       |	have been evaluated; these will then be evaluated again by the
 6100|       |	compiled argument code. */
 6101|   775k|  if (IS_S4_OBJECT(x) && R_has_methods(op)) {
  ------------------
  |  Branch (6101:7): [True: 0, False: 775k]
  |  Branch (6101:26): [True: 0, False: 0]
  ------------------
 6102|      0|    SEXP val = R_possible_dispatch(call, op, pargs, rho, TRUE);
 6103|      0|    if (val) {
  ------------------
  |  Branch (6103:9): [True: 0, False: 0]
  ------------------
 6104|      0|      *pv = val;
 6105|      0|      UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 6106|      0|      return TRUE;
 6107|      0|    }
 6108|      0|  }
 6109|       |
 6110|       |  /* See comment at first usemethod() call in this file. LT */
 6111|   775k|  PROTECT(rho1 = NewEnvironment(R_NilValue, R_NilValue, rho));
  ------------------
  |  |  357|   775k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 6112|   775k|  begincontext(&cntxt, CTXT_RETURN, call, rho1, rho, pargs, op);
  ------------------
  |  | 1864|   775k|# define begincontext		Rf_begincontext
  ------------------
 6113|   775k|  if (usemethod(generic, x, call, pargs, rho1, rho, R_BaseEnv, pv))
  ------------------
  |  | 2005|   775k|# define usemethod		Rf_usemethod
  ------------------
  |  Branch (6113:7): [True: 34, False: 775k]
  ------------------
 6114|     34|    dispatched = TRUE;
 6115|   775k|  endcontext(&cntxt);
  ------------------
  |  | 1895|   775k|# define endcontext		Rf_endcontext
  ------------------
 6116|   775k|  UNPROTECT(2);
  ------------------
  |  |  358|   775k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 6117|   775k|#ifdef ADJUST_ENVIR_REFCNTS
 6118|   775k|  R_CleanupEnvir(rho1, dispatched ? *pv : R_NilValue);
  ------------------
  |  Branch (6118:24): [True: 34, False: 775k]
  ------------------
 6119|   775k|  unpromiseArgs(pargs);
 6120|       |#else
 6121|       |  if (! dispatched) DECREMENT_REFCNT(x);
 6122|       |#endif
 6123|   775k|  return dispatched;
 6124|   775k|}
eval.c:tryAssignDispatch:
 6128|      2|{
 6129|      2|    int result;
 6130|      2|    SEXP ncall, last, prom;
 6131|       |
 6132|      2|    PROTECT(ncall = duplicate(call));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 6133|      2|    last = ncall;
 6134|     10|    while (CDR(last) != R_NilValue)
  ------------------
  |  Branch (6134:12): [True: 8, False: 2]
  ------------------
 6135|      8|	last = CDR(last);
 6136|      2|    prom = mkRHSPROMISE(CAR(last), rhs);
 6137|      2|    SETCAR(last, prom);
 6138|      2|    result = tryDispatch(generic, ncall, lhs, rho, pv);
 6139|      2|    UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 6140|      2|    return result;
 6141|      2|}
eval.c:VECSUBSET_PTR:
 6381|  1.55M|{
 6382|  1.55M|    R_xlen_t i = bcStackIndex(si) - 1;
 6383|  1.55M|    if ((subset2 || FAST_VECELT_OK(vec)))
  ------------------
  |  | 6373|   389k|    (ATTRIB(vec) == R_NilValue ||		\
  |  |  ------------------
  |  |  |  Branch (6373:6): [True: 388k, False: 727]
  |  |  ------------------
  |  | 6374|   389k|     (TAG(ATTRIB(vec)) == R_DimSymbol &&	\
  |  |  ------------------
  |  |  |  Branch (6374:7): [True: 0, False: 727]
  |  |  ------------------
  |  | 6375|    727|      CDR(ATTRIB(vec)) == R_NilValue))
  |  |  ------------------
  |  |  |  Branch (6375:7): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (6383:10): [True: 1.16M, False: 389k]
  ------------------
 6384|  1.55M|	DO_FAST_VECELT(sv, vec, i, subset2);
  ------------------
  |  | 6338|  1.55M|#define DO_FAST_VECELT(sv, vec,  i, subset2) do {		\
  |  | 6339|  1.55M|	switch (TYPEOF(vec)) {					\
  |  |  ------------------
  |  |  |  Branch (6339:10): [True: 1.16M, False: 391k]
  |  |  ------------------
  |  | 6340|  1.00k|	case REALSXP:						\
  |  |  ------------------
  |  |  |  |  124|  1.00k|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (6340:2): [True: 1.00k, False: 1.55M]
  |  |  ------------------
  |  | 6341|  1.00k|	    if (i < 0 || XLENGTH(vec) <= i) break;		\
  |  |  ------------------
  |  |  |  Branch (6341:10): [True: 1.00k, False: 0]
  |  |  |  Branch (6341:19): [True: 0, False: 0]
  |  |  ------------------
  |  | 6342|  1.00k|	    SETSTACK_REAL_PTR(sv, REAL_ELT(vec, i));		\
  |  |  ------------------
  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6343|      0|	    return;						\
  |  | 6344|  1.00k|	case INTSXP:						\
  |  |  ------------------
  |  |  |  |  123|     77|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (6344:2): [True: 77, False: 1.55M]
  |  |  ------------------
  |  | 6345|     77|	    if (i < 0 || XLENGTH(vec) <= i) break;		\
  |  |  ------------------
  |  |  |  Branch (6345:10): [True: 73, False: 4]
  |  |  |  Branch (6345:19): [True: 0, False: 4]
  |  |  ------------------
  |  | 6346|     77|	    SETSTACK_INTEGER_PTR(sv, INTEGER_ELT(vec, i));	\
  |  |  ------------------
  |  |  |  | 4871|      4|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  | 4872|      4|    int __v__ = (v); \
  |  |  |  | 4873|      4|    (s)->tag = INTSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 4874|      4|    (s)->u.ival = __v__; \
  |  |  |  | 4875|      4|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4875:10): [Folded, False: 4]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6347|      4|	    return;						\
  |  | 6348|     77|	case LGLSXP:						\
  |  |  ------------------
  |  |  |  |  121|      8|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (6348:2): [True: 8, False: 1.55M]
  |  |  ------------------
  |  | 6349|      8|	    if (i < 0 || XLENGTH(vec) <= i) break;		\
  |  |  ------------------
  |  |  |  Branch (6349:10): [True: 8, False: 0]
  |  |  |  Branch (6349:19): [True: 0, False: 0]
  |  |  ------------------
  |  | 6350|      8|	    SETSTACK_LOGICAL_PTR(sv, LOGICAL_ELT(vec, i));	\
  |  |  ------------------
  |  |  |  | 4877|      0|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  | 4878|      0|	int __v__ = (v);			\
  |  |  |  | 4879|      0|	(s)->tag = LGLSXP;			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 4880|      0|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4880:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4881|      0|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  ------------------
  |  |  |  | 4882|      0|	else					\
  |  |  |  | 4883|      0|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4883:20): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4884|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4884:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6351|      0|	    return;						\
  |  | 6352|      8|	case CPLXSXP:						\
  |  |  ------------------
  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |  |  Branch (6352:2): [True: 0, False: 1.55M]
  |  |  ------------------
  |  | 6353|      0|	    if (i < 0 || XLENGTH(vec) <= i) break;		\
  |  |  ------------------
  |  |  |  Branch (6353:10): [True: 0, False: 0]
  |  |  |  Branch (6353:19): [True: 0, False: 0]
  |  |  ------------------
  |  | 6354|      0|	    SETSTACK_PTR(sv, ScalarComplex(COMPLEX_ELT(vec, i)));	\
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6355|      0|	    return;						\
  |  | 6356|      0|	case RAWSXP:						\
  |  |  ------------------
  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (6356:2): [True: 0, False: 1.55M]
  |  |  ------------------
  |  | 6357|      0|	    if (i < 0 || XLENGTH(vec) <= i) break;		\
  |  |  ------------------
  |  |  |  Branch (6357:10): [True: 0, False: 0]
  |  |  |  Branch (6357:19): [True: 0, False: 0]
  |  |  ------------------
  |  | 6358|      0|	    SETSTACK_PTR(sv, ScalarRaw(RAW(vec)[i]));		\
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6359|      0|	    return;						\
  |  | 6360|  1.16M|	case VECSXP:						\
  |  |  ------------------
  |  |  |  |  131|  1.16M|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (6360:2): [True: 1.16M, False: 392k]
  |  |  ------------------
  |  | 6361|  1.16M|	    if (i < 0 || XLENGTH(vec) <= i) break;		\
  |  |  ------------------
  |  |  |  Branch (6361:10): [True: 2.08k, False: 1.15M]
  |  |  |  Branch (6361:19): [True: 0, False: 1.15M]
  |  |  ------------------
  |  | 6362|  1.16M|	    SEXP elt = VECTOR_ELT(vec, i);			\
  |  | 6363|  1.15M|	    RAISE_NAMED(elt, NAMED(vec));			\
  |  |  ------------------
  |  |  |  |  911|  1.15M|#define elt			Rf_elt
  |  |  ------------------
  |  | 6364|  1.15M|	    if (subset2)					\
  |  |  ------------------
  |  |  |  Branch (6364:10): [True: 1.15M, False: 0]
  |  |  ------------------
  |  | 6365|  1.15M|		SETSTACK_PTR(sv, elt);				\
  |  |  ------------------
  |  |  |  | 4858|  1.15M|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|  1.15M|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|  1.15M|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.15M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|  1.15M|    SEXP __v__ = (v); \
  |  |  |  | 4861|  1.15M|    (s)->tag = 0; \
  |  |  |  | 4862|  1.15M|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|  1.15M|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 1.15M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6366|  1.15M|	    else						\
  |  | 6367|  1.15M|		SETSTACK_PTR(sv, mkVector1(elt));		\
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6368|  1.15M|	    return;						\
  |  | 6369|  1.55M|	}							\
  |  | 6370|  1.55M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6370:14): [Folded, False: 394k]
  |  |  ------------------
  ------------------
 6385|       |
 6386|       |    /* fall through to the standard default handler */
 6387|   394k|    SEXP idx, args, value;
 6388|   394k|    idx = GETSTACK_PTR(si);
  ------------------
  |  | 4837|   394k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (4837:26): [True: 387k, False: 7.45k]
  |  |  ------------------
  ------------------
 6389|   394k|    args = CONS_NR(idx, R_NilValue);
 6390|   394k|    args = CONS_NR(vec, args);
 6391|   394k|    PROTECT(args);
  ------------------
  |  |  357|   394k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 6392|   394k|    SEXP call = callidx < 0 ? R_NilValue : GETCONST(consts, callidx);
  ------------------
  |  | 5550|   394k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
  |  Branch (6392:17): [True: 0, False: 394k]
  ------------------
 6393|   394k|    if (subset2)
  ------------------
  |  Branch (6393:9): [True: 5.78k, False: 389k]
  ------------------
 6394|  5.78k|	value = do_subset2_dflt(call, R_Subset2Sym, args, rho);
 6395|   389k|    else
 6396|   389k|	value = do_subset_dflt(call, R_SubsetSym, args, rho);
 6397|   394k|    UNPROTECT(1);
  ------------------
  |  |  358|   394k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 6398|   394k|    SETSTACK_PTR(sv, value);
  ------------------
  |  | 4858|   394k|#define SETSTACK_PTR(s, v) do { \
  |  | 4859|   394k|    CHECK_SET_BELOW_PROT(s); \
  |  |  ------------------
  |  |  |  | 4853|   394k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4853:9): [True: 0, False: 394k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4860|   394k|    SEXP __v__ = (v); \
  |  | 4861|   394k|    (s)->tag = 0; \
  |  | 4862|   394k|    (s)->u.sxpval = __v__; \
  |  | 4863|   394k|} while (0)
  |  |  ------------------
  |  |  |  Branch (4863:10): [Folded, False: 394k]
  |  |  ------------------
  ------------------
 6399|   394k|}
eval.c:bcStackIndex:
 6298|  2.32M|{
 6299|  2.32M|    switch(s->tag) {
 6300|  2.31M|    case INTSXP:
  ------------------
  |  |  123|  2.31M|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (6300:5): [True: 2.31M, False: 9.64k]
  ------------------
 6301|  2.31M|	if (s->u.ival != NA_INTEGER)
  ------------------
  |  |   56|  2.31M|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (6301:6): [True: 2.31M, False: 0]
  ------------------
 6302|  2.31M|	    return s->u.ival;
 6303|      0|	else return -1;
 6304|    399|    case REALSXP:
  ------------------
  |  |  124|    399|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (6304:5): [True: 399, False: 2.32M]
  ------------------
 6305|    399|	{
 6306|    399|	    double val = s->u.dval;
 6307|    399|	    if (! ISNAN(val) && val <= R_XLEN_T_MAX && val > 0)
  ------------------
  |  |   76|    798|#  define ISNAN(x)     (isnan(x)!=0)
  ------------------
              	    if (! ISNAN(val) && val <= R_XLEN_T_MAX && val > 0)
  ------------------
  |  |   76|    798|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (6307:10): [True: 399, False: 0]
  |  Branch (6307:26): [True: 399, False: 0]
  |  Branch (6307:49): [True: 278, False: 121]
  ------------------
 6308|    278|		return (R_xlen_t) s->u.dval;
 6309|    121|	    else return -1;
 6310|    399|	}
 6311|     29|    case LGLSXP: return -1;
  ------------------
  |  |  121|     29|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (6311:5): [True: 29, False: 2.32M]
  ------------------
 6312|  9.22k|    default: break;
  ------------------
  |  Branch (6312:5): [True: 9.22k, False: 2.31M]
  ------------------
 6313|  2.32M|    }
 6314|       |
 6315|  9.22k|    SEXP idx = GETSTACK_SXPVAL_PTR(s);
  ------------------
  |  | 4839|  9.22k|#define GETSTACK_SXPVAL_PTR(s) ((s)->u.sxpval)
  ------------------
 6316|  9.22k|    if (IS_SCALAR(idx, INTSXP)) {
  ------------------
  |  |  123|  9.22k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (6316:9): [True: 291, False: 8.93k]
  ------------------
 6317|    291|	int ival = SCALAR_IVAL(idx);
 6318|    291|	if (ival != NA_INTEGER)
  ------------------
  |  |   56|    291|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (6318:6): [True: 291, False: 0]
  ------------------
 6319|    291|	    return ival;
 6320|      0|	else return -1;
 6321|    291|    }
 6322|  8.93k|    else if (IS_SCALAR(idx, REALSXP)) {
  ------------------
  |  |  124|  8.93k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (6322:14): [True: 0, False: 8.93k]
  ------------------
 6323|      0|	double val = SCALAR_DVAL(idx);
 6324|      0|	if (! ISNAN(val) && val <= R_XLEN_T_MAX && val > 0)
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  ------------------
              	if (! ISNAN(val) && val <= R_XLEN_T_MAX && val > 0)
  ------------------
  |  |   76|      0|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (6324:6): [True: 0, False: 0]
  |  Branch (6324:22): [True: 0, False: 0]
  |  Branch (6324:45): [True: 0, False: 0]
  ------------------
 6325|      0|	    return (R_xlen_t) val;
 6326|      0|	else return -1;
 6327|      0|    }
 6328|  8.93k|    else return -1;
 6329|  9.22k|}
eval.c:MATSUBSET_PTR:
 6484|  2.29k|{
 6485|  2.29k|    SEXP idx, jdx, args, value;
 6486|  2.29k|    SEXP mat = GETSTACK_PTR(sx);
  ------------------
  |  | 4837|  2.29k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (4837:26): [True: 0, False: 2.29k]
  |  |  ------------------
  ------------------
 6487|       |
 6488|  2.29k|    if (subset2 || FAST_VECELT_OK(mat)) {
  ------------------
  |  | 6373|  2.29k|    (ATTRIB(vec) == R_NilValue ||		\
  |  |  ------------------
  |  |  |  Branch (6373:6): [True: 0, False: 2.29k]
  |  |  ------------------
  |  | 6374|  2.29k|     (TAG(ATTRIB(vec)) == R_DimSymbol &&	\
  |  |  ------------------
  |  |  |  Branch (6374:7): [True: 2.29k, False: 0]
  |  |  ------------------
  |  | 6375|  2.29k|      CDR(ATTRIB(vec)) == R_NilValue))
  |  |  ------------------
  |  |  |  Branch (6375:7): [True: 0, False: 2.29k]
  |  |  ------------------
  ------------------
  |  Branch (6488:9): [True: 0, False: 2.29k]
  ------------------
 6489|      0|	SEXP dim = getMatrixDim(mat);
 6490|      0|	if (dim != R_NilValue) {
  ------------------
  |  Branch (6490:6): [True: 0, False: 0]
  ------------------
 6491|      0|	    R_xlen_t i = bcStackIndex(si);
 6492|      0|	    R_xlen_t j = bcStackIndex(sj);
 6493|      0|	    R_xlen_t nrow = INTEGER(dim)[0];
 6494|      0|	    R_xlen_t ncol = INTEGER(dim)[1];
 6495|      0|	    if (i > 0 && j > 0 && i <= nrow && j <= ncol) {
  ------------------
  |  Branch (6495:10): [True: 0, False: 0]
  |  Branch (6495:19): [True: 0, False: 0]
  |  Branch (6495:28): [True: 0, False: 0]
  |  Branch (6495:41): [True: 0, False: 0]
  ------------------
 6496|      0|		R_xlen_t k = i - 1 + nrow * (j - 1);
 6497|      0|		DO_FAST_VECELT(sv, mat, k, subset2);
  ------------------
  |  | 6338|      0|#define DO_FAST_VECELT(sv, vec,  i, subset2) do {		\
  |  | 6339|      0|	switch (TYPEOF(vec)) {					\
  |  |  ------------------
  |  |  |  Branch (6339:10): [True: 0, False: 0]
  |  |  ------------------
  |  | 6340|      0|	case REALSXP:						\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (6340:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 6341|      0|	    if (i < 0 || XLENGTH(vec) <= i) break;		\
  |  |  ------------------
  |  |  |  Branch (6341:10): [True: 0, False: 0]
  |  |  |  Branch (6341:19): [True: 0, False: 0]
  |  |  ------------------
  |  | 6342|      0|	    SETSTACK_REAL_PTR(sv, REAL_ELT(vec, i));		\
  |  |  ------------------
  |  |  |  | 4865|      0|#define SETSTACK_REAL_PTR(s, v) do { \
  |  |  |  | 4866|      0|    double __v__ = (v); \
  |  |  |  | 4867|      0|    (s)->tag = REALSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  | 4868|      0|    (s)->u.dval = __v__; \
  |  |  |  | 4869|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4869:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6343|      0|	    return;						\
  |  | 6344|      0|	case INTSXP:						\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (6344:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 6345|      0|	    if (i < 0 || XLENGTH(vec) <= i) break;		\
  |  |  ------------------
  |  |  |  Branch (6345:10): [True: 0, False: 0]
  |  |  |  Branch (6345:19): [True: 0, False: 0]
  |  |  ------------------
  |  | 6346|      0|	    SETSTACK_INTEGER_PTR(sv, INTEGER_ELT(vec, i));	\
  |  |  ------------------
  |  |  |  | 4871|      0|#define SETSTACK_INTEGER_PTR(s, v) do { \
  |  |  |  | 4872|      0|    int __v__ = (v); \
  |  |  |  | 4873|      0|    (s)->tag = INTSXP; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  | 4874|      0|    (s)->u.ival = __v__; \
  |  |  |  | 4875|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4875:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6347|      0|	    return;						\
  |  | 6348|      0|	case LGLSXP:						\
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (6348:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 6349|      0|	    if (i < 0 || XLENGTH(vec) <= i) break;		\
  |  |  ------------------
  |  |  |  Branch (6349:10): [True: 0, False: 0]
  |  |  |  Branch (6349:19): [True: 0, False: 0]
  |  |  ------------------
  |  | 6350|      0|	    SETSTACK_LOGICAL_PTR(sv, LOGICAL_ELT(vec, i));	\
  |  |  ------------------
  |  |  |  | 4877|      0|#define SETSTACK_LOGICAL_PTR(s, v) do {		\
  |  |  |  | 4878|      0|	int __v__ = (v);			\
  |  |  |  | 4879|      0|	(s)->tag = LGLSXP;			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  | 4880|      0|	if (__v__ == NA_LOGICAL)		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4880:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4881|      0|	    (s)->u.ival = NA_LOGICAL;		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  |  |  ------------------
  |  |  |  | 4882|      0|	else					\
  |  |  |  | 4883|      0|	    (s)->u.ival = __v__ ? TRUE : FALSE;	\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4883:20): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 4884|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4884:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6351|      0|	    return;						\
  |  | 6352|      0|	case CPLXSXP:						\
  |  |  ------------------
  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |  |  Branch (6352:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 6353|      0|	    if (i < 0 || XLENGTH(vec) <= i) break;		\
  |  |  ------------------
  |  |  |  Branch (6353:10): [True: 0, False: 0]
  |  |  |  Branch (6353:19): [True: 0, False: 0]
  |  |  ------------------
  |  | 6354|      0|	    SETSTACK_PTR(sv, ScalarComplex(COMPLEX_ELT(vec, i)));	\
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6355|      0|	    return;						\
  |  | 6356|      0|	case RAWSXP:						\
  |  |  ------------------
  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (6356:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 6357|      0|	    if (i < 0 || XLENGTH(vec) <= i) break;		\
  |  |  ------------------
  |  |  |  Branch (6357:10): [True: 0, False: 0]
  |  |  |  Branch (6357:19): [True: 0, False: 0]
  |  |  ------------------
  |  | 6358|      0|	    SETSTACK_PTR(sv, ScalarRaw(RAW(vec)[i]));		\
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6359|      0|	    return;						\
  |  | 6360|      0|	case VECSXP:						\
  |  |  ------------------
  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (6360:2): [True: 0, False: 0]
  |  |  ------------------
  |  | 6361|      0|	    if (i < 0 || XLENGTH(vec) <= i) break;		\
  |  |  ------------------
  |  |  |  Branch (6361:10): [True: 0, False: 0]
  |  |  |  Branch (6361:19): [True: 0, False: 0]
  |  |  ------------------
  |  | 6362|      0|	    SEXP elt = VECTOR_ELT(vec, i);			\
  |  | 6363|      0|	    RAISE_NAMED(elt, NAMED(vec));			\
  |  |  ------------------
  |  |  |  |  911|      0|#define elt			Rf_elt
  |  |  ------------------
  |  | 6364|      0|	    if (subset2)					\
  |  |  ------------------
  |  |  |  Branch (6364:10): [True: 0, False: 0]
  |  |  ------------------
  |  | 6365|      0|		SETSTACK_PTR(sv, elt);				\
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6366|      0|	    else						\
  |  | 6367|      0|		SETSTACK_PTR(sv, mkVector1(elt));		\
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6368|      0|	    return;						\
  |  | 6369|      0|	}							\
  |  | 6370|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6370:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 6498|      0|	    }
 6499|      0|	}
 6500|      0|    }
 6501|       |
 6502|       |    /* fall through to the standard default handler */
 6503|  2.29k|    idx = GETSTACK_PTR(si);
  ------------------
  |  | 4837|  2.29k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (4837:26): [True: 2.29k, False: 0]
  |  |  ------------------
  ------------------
 6504|  2.29k|    jdx = GETSTACK_PTR(sj);
  ------------------
  |  | 4837|  2.29k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (4837:26): [True: 2.29k, False: 0]
  |  |  ------------------
  ------------------
 6505|  2.29k|    args = CONS_NR(jdx, R_NilValue);
 6506|  2.29k|    args = CONS_NR(idx, args);
 6507|  2.29k|    args = CONS_NR(mat, args);
 6508|  2.29k|    PROTECT(args);
  ------------------
  |  |  357|  2.29k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 6509|  2.29k|    SEXP call = callidx < 0 ? R_NilValue : GETCONST(consts, callidx);
  ------------------
  |  | 5550|  2.29k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
  |  Branch (6509:17): [True: 0, False: 2.29k]
  ------------------
 6510|  2.29k|    if (subset2)
  ------------------
  |  Branch (6510:9): [True: 0, False: 2.29k]
  ------------------
 6511|      0|	value = do_subset2_dflt(call, R_Subset2Sym, args, rho);
 6512|  2.29k|    else
 6513|  2.29k|	value = do_subset_dflt(call, R_SubsetSym, args, rho);
 6514|  2.29k|    UNPROTECT(1);
  ------------------
  |  |  358|  2.29k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 6515|  2.29k|    SETSTACK_PTR(sv, value);
  ------------------
  |  | 4858|  2.29k|#define SETSTACK_PTR(s, v) do { \
  |  | 4859|  2.29k|    CHECK_SET_BELOW_PROT(s); \
  |  |  ------------------
  |  |  |  | 4853|  2.29k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4853:9): [True: 0, False: 2.29k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4860|  2.29k|    SEXP __v__ = (v); \
  |  | 4861|  2.29k|    (s)->tag = 0; \
  |  | 4862|  2.29k|    (s)->u.sxpval = __v__; \
  |  | 4863|  2.29k|} while (0)
  |  |  ------------------
  |  |  |  Branch (4863:10): [Folded, False: 2.29k]
  |  |  ------------------
  ------------------
 6516|  2.29k|}
eval.c:getMatrixDim:
 6434|      8|{
 6435|      8|    SEXP attr = ATTRIB(mat);
 6436|       |    /* look for the common case of 'dim' as the only attribute first */
 6437|      8|    SEXP dim = TAG(attr) == R_DimSymbol ? CAR(attr) :
  ------------------
  |  Branch (6437:16): [True: 8, False: 0]
  ------------------
 6438|      8|	getAttrib(mat, R_DimSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 6439|      8|    if (TYPEOF(dim) == INTSXP && LENGTH(dim) == 2)
  ------------------
  |  |  123|     16|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (6439:9): [True: 8, False: 0]
  |  Branch (6439:34): [True: 8, False: 0]
  ------------------
 6440|      8|	return dim;
 6441|      0|    else return R_NilValue;
 6442|      8|}
eval.c:VECSUBASSIGN_PTR:
 6637|   772k|{
 6638|   772k|    SEXP idx, args, value;
 6639|       |
 6640|   772k|    R_xlen_t i = bcStackIndex(si) - 1;
 6641|   772k|    if (i >= 0)
  ------------------
  |  Branch (6641:9): [True: 770k, False: 1.64k]
  ------------------
 6642|   770k|	DO_FAST_SETVECELT(sv, srhs, vec,  i, subset2);
  ------------------
  |  | 6613|   770k|#define DO_FAST_SETVECELT(sv, srhs, vec,  i, subset2) do {		\
  |  | 6614|   770k|	if (setElementFromScalar(vec, i, srhs)) {			\
  |  |  ------------------
  |  |  |  Branch (6614:6): [True: 36, False: 770k]
  |  |  ------------------
  |  | 6615|     36|	    SETSTACK_PTR(sv, vec);					\
  |  |  ------------------
  |  |  |  | 4858|     36|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|     36|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|     36|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 36]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|     36|    SEXP __v__ = (v); \
  |  |  |  | 4861|     36|    (s)->tag = 0; \
  |  |  |  | 4862|     36|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|     36|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 36]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6616|     36|	    SETTER_CLEAR_NAMED(vec);					\
  |  | 6617|     36|	    return;							\
  |  | 6618|     36|	}								\
  |  | 6619|   770k|	else if (subassign2 && TYPEOF(vec) == VECSXP &&			\
  |  |  ------------------
  |  |  |  |  131|  1.54M|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (6619:11): [True: 770k, False: 31]
  |  |  |  Branch (6619:25): [True: 770k, False: 0]
  |  |  ------------------
  |  | 6620|   770k|		 i < XLENGTH(vec)) {					\
  |  |  ------------------
  |  |  |  Branch (6620:4): [True: 770k, False: 0]
  |  |  ------------------
  |  | 6621|   770k|	    SEXP rhs = GETSTACK_PTR(srhs);				\
  |  |  ------------------
  |  |  |  | 4837|   770k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 770k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6622|   770k|	    if (rhs != R_NilValue) {					\
  |  |  ------------------
  |  |  |  Branch (6622:10): [True: 770k, False: 0]
  |  |  ------------------
  |  | 6623|   770k|		if (MAYBE_REFERENCED(rhs) && VECTOR_ELT(vec, i) != rhs)	\
  |  |  ------------------
  |  |  |  |  251|  1.54M|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (251:29): [True: 385k, False: 385k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (6623:32): [True: 11, False: 385k]
  |  |  ------------------
  |  | 6624|   770k|		    rhs = R_FixupRHS(vec, rhs);				\
  |  | 6625|   770k|		SET_VECTOR_ELT(vec, i, rhs);				\
  |  | 6626|   770k|		SETTER_CLEAR_NAMED(vec);				\
  |  | 6627|   770k|		SETSTACK_PTR(sv, vec);					\
  |  |  ------------------
  |  |  |  | 4858|   770k|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|   770k|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|   770k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 770k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|   770k|    SEXP __v__ = (v); \
  |  |  |  | 4861|   770k|    (s)->tag = 0; \
  |  |  |  | 4862|   770k|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|   770k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 770k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6628|   770k|		return;							\
  |  | 6629|   770k|	    }								\
  |  | 6630|   770k|	}								\
  |  | 6631|   770k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6631:14): [Folded, False: 31]
  |  |  ------------------
  ------------------
 6643|       |
 6644|       |    /* fall through to the standard default handler */
 6645|  1.67k|    value = GETSTACK_PTR(srhs);
  ------------------
  |  | 4837|  1.67k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (4837:26): [True: 0, False: 1.67k]
  |  |  ------------------
  ------------------
 6646|  1.67k|    idx = GETSTACK_PTR(si);
  ------------------
  |  | 4837|  1.67k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (4837:26): [True: 3, False: 1.67k]
  |  |  ------------------
  ------------------
 6647|  1.67k|    args = CONS_NR(value, R_NilValue);
 6648|  1.67k|    SET_TAG(args, R_valueSym);
 6649|  1.67k|    args = CONS_NR(idx, args);
 6650|  1.67k|    args = CONS_NR(vec, args);
 6651|  1.67k|    PROTECT(args);
  ------------------
  |  |  357|  1.67k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 6652|  1.67k|    SEXP call = callidx < 0 ? R_NilValue : GETCONST(consts, callidx);
  ------------------
  |  | 5550|  1.67k|#define GETCONST(x, i) ((x).p)[i]
  ------------------
  |  Branch (6652:17): [True: 0, False: 1.67k]
  ------------------
 6653|  1.67k|    MARK_ASSIGNMENT_CALL(call);
 6654|  1.67k|    if (subassign2)
  ------------------
  |  Branch (6654:9): [True: 1.41k, False: 263]
  ------------------
 6655|  1.41k|	vec = do_subassign2_dflt(call, R_Subassign2Sym, args, rho);
 6656|    263|    else
 6657|    263|	vec = do_subassign_dflt(call, R_SubassignSym, args, rho);
 6658|  1.67k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.67k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 6659|  1.67k|    SETSTACK_PTR(sv, vec);
  ------------------
  |  | 4858|  1.67k|#define SETSTACK_PTR(s, v) do { \
  |  | 4859|  1.67k|    CHECK_SET_BELOW_PROT(s); \
  |  |  ------------------
  |  |  |  | 4853|  1.67k|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4853:9): [True: 0, False: 1.67k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4860|  1.67k|    SEXP __v__ = (v); \
  |  | 4861|  1.67k|    (s)->tag = 0; \
  |  | 4862|  1.67k|    (s)->u.sxpval = __v__; \
  |  | 4863|  1.67k|} while (0)
  |  |  ------------------
  |  |  |  Branch (4863:10): [Folded, False: 1.67k]
  |  |  ------------------
  ------------------
 6660|  1.67k|}
eval.c:setElementFromScalar:
 6584|   770k|{
 6585|   770k|    if (i < 0) return FALSE;
  ------------------
  |  Branch (6585:9): [True: 0, False: 770k]
  ------------------
 6586|       |
 6587|   770k|    R_bcstack_t vv;
 6588|   770k|    R_bcstack_t *v = bcStackScalar(srhs, &vv);
 6589|       |
 6590|   770k|    if (TYPEOF(vec) == REALSXP) {
  ------------------
  |  |  124|   770k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (6590:9): [True: 8, False: 770k]
  ------------------
 6591|      8|	if (XLENGTH(vec) <= i) return FALSE;
  ------------------
  |  Branch (6591:6): [True: 0, False: 8]
  ------------------
 6592|      8|	switch(v->tag) {
  ------------------
  |  Branch (6592:9): [True: 8, False: 0]
  ------------------
 6593|      0|	case REALSXP: REAL(vec)[i] = v->u.dval; return TRUE;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (6593:2): [True: 0, False: 8]
  ------------------
 6594|      8|	case INTSXP: REAL(vec)[i] = INTEGER_TO_REAL(v->u.ival); return TRUE;
  ------------------
  |  |  123|      8|#define INTSXP	    13	  /* integer vectors */
  ------------------
              	case INTSXP: REAL(vec)[i] = INTEGER_TO_REAL(v->u.ival); return TRUE;
  ------------------
  |  | 4956|      8|#define INTEGER_TO_REAL(x) ((x) == NA_INTEGER ? NA_REAL : (x))
  |  |  ------------------
  |  |  |  |   56|      8|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               #define INTEGER_TO_REAL(x) ((x) == NA_INTEGER ? NA_REAL : (x))
  |  |  ------------------
  |  |  |  |   58|      0|#define NA_REAL		R_NaReal
  |  |  ------------------
  |  |  |  Branch (4956:29): [True: 0, False: 8]
  |  |  ------------------
  ------------------
  |  Branch (6594:2): [True: 8, False: 0]
  ------------------
 6595|      0|	case LGLSXP: REAL(vec)[i] = LOGICAL_TO_REAL(v->u.ival); return TRUE;
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
              	case LGLSXP: REAL(vec)[i] = LOGICAL_TO_REAL(v->u.ival); return TRUE;
  ------------------
  |  | 4957|      0|#define LOGICAL_TO_REAL(x) ((x) == NA_LOGICAL ? NA_REAL : (x))
  |  |  ------------------
  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  ------------------
  |  |               #define LOGICAL_TO_REAL(x) ((x) == NA_LOGICAL ? NA_REAL : (x))
  |  |  ------------------
  |  |  |  |   58|      0|#define NA_REAL		R_NaReal
  |  |  ------------------
  |  |  |  Branch (4957:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (6595:2): [True: 0, False: 8]
  ------------------
 6596|      8|	}
 6597|      8|    }
 6598|   770k|    else if (v->tag == TYPEOF(vec)) {
  ------------------
  |  Branch (6598:14): [True: 28, False: 770k]
  ------------------
 6599|     28|	switch(v->tag) {
  ------------------
  |  Branch (6599:9): [True: 28, False: 0]
  ------------------
 6600|     28|	case INTSXP:
  ------------------
  |  |  123|     28|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (6600:2): [True: 28, False: 0]
  ------------------
 6601|     28|	    if (XLENGTH(vec) <= i) return FALSE;
  ------------------
  |  Branch (6601:10): [True: 0, False: 28]
  ------------------
 6602|     28|	    INTEGER(vec)[i] = v->u.ival;
 6603|     28|	    return TRUE;
 6604|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (6604:2): [True: 0, False: 28]
  ------------------
 6605|      0|	    if (XLENGTH(vec) <= i) return FALSE;
  ------------------
  |  Branch (6605:10): [True: 0, False: 0]
  ------------------
 6606|      0|	    LOGICAL(vec)[i] = INTEGER_TO_LOGICAL(v->u.ival);
  ------------------
  |  | 4955|      0|    ((x) == NA_INTEGER ? NA_LOGICAL : (x) ? TRUE : FALSE)
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |                   ((x) == NA_INTEGER ? NA_LOGICAL : (x) ? TRUE : FALSE)
  |  |  ------------------
  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  ------------------
  |  |  |  Branch (4955:6): [True: 0, False: 0]
  |  |  |  Branch (4955:39): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 6607|      0|	    return TRUE;
 6608|     28|	}
 6609|     28|    }
 6610|   770k|    return FALSE;
 6611|   770k|}
eval.c:MATSUBASSIGN_PTR:
 6707|      8|{
 6708|      8|    SEXP dim, idx, jdx, args, value;
 6709|      8|    SEXP mat = GETSTACK_PTR(sx);
  ------------------
  |  | 4837|      8|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (4837:26): [True: 0, False: 8]
  |  |  ------------------
  ------------------
 6710|       |
 6711|      8|    if (MAYBE_SHARED(mat)) {
  ------------------
  |  Branch (6711:9): [True: 0, False: 8]
  ------------------
 6712|      0|	mat = shallow_duplicate(mat);
  ------------------
  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 6713|      0|	SETSTACK_PTR(sx, mat);
  ------------------
  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  ------------------
  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4860|      0|    SEXP __v__ = (v); \
  |  | 4861|      0|    (s)->tag = 0; \
  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  | 4863|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 6714|      0|    }
 6715|       |
 6716|      8|    dim = getMatrixDim(mat);
 6717|       |
 6718|      8|    if (dim != R_NilValue) {
  ------------------
  |  Branch (6718:9): [True: 8, False: 0]
  ------------------
 6719|      8|	R_xlen_t i = bcStackIndex(si);
 6720|      8|	R_xlen_t j = bcStackIndex(sj);
 6721|      8|	R_xlen_t nrow = INTEGER(dim)[0];
 6722|      8|	R_xlen_t ncol = INTEGER(dim)[1];
 6723|      8|	if (i > 0 && j > 0 && i <= nrow && j <= ncol) {
  ------------------
  |  Branch (6723:6): [True: 0, False: 8]
  |  Branch (6723:15): [True: 0, False: 0]
  |  Branch (6723:24): [True: 0, False: 0]
  |  Branch (6723:37): [True: 0, False: 0]
  ------------------
 6724|      0|	    R_xlen_t k = i - 1 + nrow * (j - 1);
 6725|      0|	    DO_FAST_SETVECELT(sv, srhs, mat,  k, subset2);
  ------------------
  |  | 6613|      0|#define DO_FAST_SETVECELT(sv, srhs, vec,  i, subset2) do {		\
  |  | 6614|      0|	if (setElementFromScalar(vec, i, srhs)) {			\
  |  |  ------------------
  |  |  |  Branch (6614:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 6615|      0|	    SETSTACK_PTR(sv, vec);					\
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6616|      0|	    SETTER_CLEAR_NAMED(vec);					\
  |  | 6617|      0|	    return;							\
  |  | 6618|      0|	}								\
  |  | 6619|      0|	else if (subassign2 && TYPEOF(vec) == VECSXP &&			\
  |  |  ------------------
  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (6619:11): [True: 0, False: 0]
  |  |  |  Branch (6619:25): [True: 0, False: 0]
  |  |  ------------------
  |  | 6620|      0|		 i < XLENGTH(vec)) {					\
  |  |  ------------------
  |  |  |  Branch (6620:4): [True: 0, False: 0]
  |  |  ------------------
  |  | 6621|      0|	    SEXP rhs = GETSTACK_PTR(srhs);				\
  |  |  ------------------
  |  |  |  | 4837|      0|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4837:26): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6622|      0|	    if (rhs != R_NilValue) {					\
  |  |  ------------------
  |  |  |  Branch (6622:10): [True: 0, False: 0]
  |  |  ------------------
  |  | 6623|      0|		if (MAYBE_REFERENCED(rhs) && VECTOR_ELT(vec, i) != rhs)	\
  |  |  ------------------
  |  |  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (6623:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 6624|      0|		    rhs = R_FixupRHS(vec, rhs);				\
  |  | 6625|      0|		SET_VECTOR_ELT(vec, i, rhs);				\
  |  | 6626|      0|		SETTER_CLEAR_NAMED(vec);				\
  |  | 6627|      0|		SETSTACK_PTR(sv, vec);					\
  |  |  ------------------
  |  |  |  | 4858|      0|#define SETSTACK_PTR(s, v) do { \
  |  |  |  | 4859|      0|    CHECK_SET_BELOW_PROT(s); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 4853|      0|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (4853:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 4860|      0|    SEXP __v__ = (v); \
  |  |  |  | 4861|      0|    (s)->tag = 0; \
  |  |  |  | 4862|      0|    (s)->u.sxpval = __v__; \
  |  |  |  | 4863|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4863:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 6628|      0|		return;							\
  |  | 6629|      0|	    }								\
  |  | 6630|      0|	}								\
  |  | 6631|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (6631:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 6726|      0|	}
 6727|      8|    }
 6728|       |
 6729|       |    /* fall through to the standard default handler */
 6730|      8|    value = GETSTACK_PTR(srhs);
  ------------------
  |  | 4837|      8|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (4837:26): [True: 0, False: 8]
  |  |  ------------------
  ------------------
 6731|      8|    idx = GETSTACK_PTR(si);
  ------------------
  |  | 4837|      8|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (4837:26): [True: 0, False: 8]
  |  |  ------------------
  ------------------
 6732|      8|    jdx = GETSTACK_PTR(sj);
  ------------------
  |  | 4837|      8|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (4837:26): [True: 8, False: 0]
  |  |  ------------------
  ------------------
 6733|      8|    args = CONS_NR(value, R_NilValue);
 6734|      8|    SET_TAG(args, R_valueSym);
 6735|      8|    args = CONS_NR(jdx, args);
 6736|      8|    args = CONS_NR(idx, args);
 6737|      8|    args = CONS_NR(mat, args);
 6738|      8|    PROTECT(args);
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 6739|      8|    SEXP call = callidx < 0 ? R_NilValue : GETCONST(consts, callidx);
  ------------------
  |  | 5550|      8|#define GETCONST(x, i) ((x).p)[i]
  ------------------
  |  Branch (6739:17): [True: 0, False: 8]
  ------------------
 6740|      8|    MARK_ASSIGNMENT_CALL(call);
 6741|      8|    if (subassign2)
  ------------------
  |  Branch (6741:9): [True: 0, False: 8]
  ------------------
 6742|      0|	mat = do_subassign2_dflt(call, R_Subassign2Sym, args, rho);
 6743|      8|    else
 6744|      8|	mat = do_subassign_dflt(call, R_SubassignSym, args, rho);
 6745|      8|    UNPROTECT(1);
  ------------------
  |  |  358|      8|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 6746|      8|    SETSTACK_PTR(sv, mat);
  ------------------
  |  | 4858|      8|#define SETSTACK_PTR(s, v) do { \
  |  | 4859|      8|    CHECK_SET_BELOW_PROT(s); \
  |  |  ------------------
  |  |  |  | 4853|      8|    if ((s) < R_BCProtTop) error("changing stack value below R_BCProt pointer")
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (4853:9): [True: 0, False: 8]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4860|      8|    SEXP __v__ = (v); \
  |  | 4861|      8|    (s)->tag = 0; \
  |  | 4862|      8|    (s)->u.sxpval = __v__; \
  |  | 4863|      8|} while (0)
  |  |  ------------------
  |  |  |  Branch (4863:10): [Folded, False: 8]
  |  |  ------------------
  ------------------
 6747|      8|}
eval.c:GETSTACK_LOGICAL_PTR:
 6967|   805k|{
 6968|   805k|    if (s->tag == LGLSXP) return s->u.ival;
  ------------------
  |  |  121|   805k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (6968:9): [True: 1.37k, False: 804k]
  ------------------
 6969|   804k|    SEXP value = GETSTACK_PTR(s);
  ------------------
  |  | 4837|   804k|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (4837:26): [True: 0, False: 804k]
  |  |  ------------------
  ------------------
 6970|   804k|    return SCALAR_LVAL(value);
 6971|   805k|}
eval.c:bcStackScalarReal:
 4960|  1.32k|{
 4961|  1.32k|    v = bcStackScalar(s, v);
 4962|  1.32k|    if (v->tag == INTSXP) {
  ------------------
  |  |  123|  1.32k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (4962:9): [True: 991, False: 329]
  ------------------
 4963|    991|	v->tag = REALSXP;
  ------------------
  |  |  124|    991|#define REALSXP	    14	  /* real variables */
  ------------------
 4964|    991|	v->u.dval = INTEGER_TO_REAL(v->u.ival);
  ------------------
  |  | 4956|    991|#define INTEGER_TO_REAL(x) ((x) == NA_INTEGER ? NA_REAL : (x))
  |  |  ------------------
  |  |  |  |   56|    991|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               #define INTEGER_TO_REAL(x) ((x) == NA_INTEGER ? NA_REAL : (x))
  |  |  ------------------
  |  |  |  |   58|      0|#define NA_REAL		R_NaReal
  |  |  ------------------
  |  |  |  Branch (4956:29): [True: 0, False: 991]
  |  |  ------------------
  ------------------
 4965|    991|    }
 4966|  1.32k|    return v;
 4967|  1.32k|}
eval.c:SymbolValue:
 6913|  7.00k|{
 6914|  7.00k|    if (IS_ACTIVE_BINDING(sym))
  ------------------
  |  Branch (6914:9): [True: 0, False: 7.00k]
  ------------------
 6915|      0|	return eval(sym, R_BaseEnv);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 6916|  7.00k|    else {
 6917|  7.00k|	SEXP value = SYMVALUE(sym);
 6918|  7.00k|	if (TYPEOF(value) == PROMSXP) {
  ------------------
  |  |  116|  7.00k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (6918:6): [True: 1.00k, False: 6.00k]
  ------------------
 6919|  1.00k|	    if (PROMISE_IS_EVALUATED(value))
  ------------------
  |  Branch (6919:10): [True: 1.00k, False: 0]
  ------------------
 6920|  1.00k|		value = PRVALUE(value);
 6921|      0|	    else
 6922|      0|		value = eval(sym, R_BaseEnv);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 6923|  1.00k|	}
 6924|  7.00k|	return value;
 6925|  7.00k|    }
 6926|  7.00k|}
eval.c:restore_bcEval_globals:
 7241|  8.21M|{
 7242|  8.21M|    R_BCNodeStackTop = R_BCProtTop;
 7243|  8.21M|    DECREMENT_BCSTACK_LINKS(g->old_bcprot_top);
  ------------------
  |  | 1062|  8.21M|#define DECREMENT_BCSTACK_LINKS(oldptop) do {		\
  |  | 1063|  8.21M|	if (R_BCProtTop > (oldptop))			\
  |  |  ------------------
  |  |  |  Branch (1063:6): [True: 8.21M, False: 0]
  |  |  ------------------
  |  | 1064|  8.21M|	    DECLNK_stack(oldptop);			\
  |  | 1065|  8.21M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (1065:14): [Folded, False: 8.21M]
  |  |  ------------------
  ------------------
 7244|  8.21M|    R_EvalDepth = g->oldevdepth;
 7245|  8.21M|    R_BCProtCommitted = g->old_bcprot_committed;
 7246|  8.21M|    R_BCNodeStackTop = g->oldntop;
 7247|  8.21M|    R_BCIntActive = g->oldbcintactive;
 7248|  8.21M|    R_BCbody = g->oldbcbody;
 7249|  8.21M|    R_BCpc = g->oldbcpc;
 7250|  8.21M|    R_BCFrame = g->oldbcframe;
 7251|  8.21M|    R_Srcref = g->oldsrcref;
 7252|       |#ifdef BC_PROFILING
 7253|       |    current_opcode = g->old_current_opcode;
 7254|       |#endif
 7255|  8.21M|}
eval.c:bcEval_init:
 8754|      2|static void bcEval_init(void) {
 8755|       |    bcEval_loop(NULL);
 8756|      2|}
eval.c:STACKVAL_TO_SEXP:
 4913|  3.53M|static R_INLINE SEXP STACKVAL_TO_SEXP(R_bcstack_t x) {
 4914|  3.53M|    return GETSTACK_PTR(&x);
  ------------------
  |  | 4837|  3.53M|#define GETSTACK_PTR(s) ((s)->tag ? GETSTACK_PTR_TAG(s) : (s)->u.sxpval)
  |  |  ------------------
  |  |  |  Branch (4837:26): [True: 2, False: 3.53M]
  |  |  ------------------
  ------------------
 4915|  3.53M|}

Rf_formatString:
   73|    255|{
   74|    255|    int xmax = 0;
   75|    255|    int l;
   76|       |
   77|    510|    for (R_xlen_t i = 0; i < n; i++) {
  ------------------
  |  Branch (77:26): [True: 255, False: 255]
  ------------------
   78|    255|	if (x[i] == NA_STRING) {
  ------------------
  |  |  433|    255|#define NA_STRING	R_NaString
  ------------------
  |  Branch (78:6): [True: 0, False: 255]
  ------------------
   79|      0|	    l = quote ? R_print.na_width : R_print.na_width_noquote;
  ------------------
  |  Branch (79:10): [True: 0, False: 0]
  ------------------
   80|    255|	} else l = Rstrlen(x[i], quote) + (quote ? 2 : 0);
  ------------------
  |  Branch (80:37): [True: 255, False: 0]
  ------------------
   81|    255|	if (l > xmax) xmax = l;
  ------------------
  |  Branch (81:6): [True: 255, False: 0]
  ------------------
   82|    255|    }
   83|    255|    *fieldwidth = xmax;
   84|    255|}
Rf_formatLogical:
  107|    241|{
  108|    241|    *fieldwidth = 1;
  109|    474|    for(R_xlen_t i = 0 ; i < n; i++) {
  ------------------
  |  Branch (109:26): [True: 241, False: 233]
  ------------------
  110|    241|	if (x[i] == NA_LOGICAL) {
  ------------------
  |  |   55|    241|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (110:6): [True: 0, False: 241]
  ------------------
  111|      0|	    if(*fieldwidth < R_print.na_width)
  ------------------
  |  Branch (111:9): [True: 0, False: 0]
  ------------------
  112|      0|		*fieldwidth = R_print.na_width;
  113|    241|	} else if (x[i] != 0 && *fieldwidth < 4) { // 'TRUE'
  ------------------
  |  Branch (113:13): [True: 233, False: 8]
  |  Branch (113:26): [True: 233, False: 0]
  ------------------
  114|    233|	    *fieldwidth = 4;
  115|    233|	} else if (x[i] == 0 && *fieldwidth < 5 ) {// 'FALSE'
  ------------------
  |  Branch (115:13): [True: 8, False: 0]
  |  Branch (115:26): [True: 8, False: 0]
  ------------------
  116|      8|	    *fieldwidth = 5;
  117|      8|	    break;
  118|       |	    // FIXME: Need to ensure that  na_width > 5  is not allowed (*and* document in ?print.default)
  119|       |	    /* this is the widest it can be,  so stop */
  120|      8|	}
  121|    241|    }
  122|    241|}
Rf_formatInteger:
  159|    256|{
  160|    256|    int xmin = INT_MAX, xmax = INT_MIN, naflag = 0;
  161|    256|    int l;
  162|       |
  163|    512|    for (R_xlen_t i = 0; i < n; i++) {
  ------------------
  |  Branch (163:26): [True: 256, False: 256]
  ------------------
  164|    256|	if (x[i] == NA_INTEGER)
  ------------------
  |  |   56|    256|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (164:6): [True: 0, False: 256]
  ------------------
  165|      0|	    naflag = 1;
  166|    256|	else {
  167|    256|	    if (x[i] < xmin) xmin = x[i];
  ------------------
  |  Branch (167:10): [True: 256, False: 0]
  ------------------
  168|    256|	    if (x[i] > xmax) xmax = x[i];
  ------------------
  |  Branch (168:10): [True: 256, False: 0]
  ------------------
  169|    256|	}
  170|    256|    }
  171|    256|    FORMATINT_RETLOGIC;
  ------------------
  |  |  143|    256|#define FORMATINT_RETLOGIC do {					\
  |  |  144|    256|	if (naflag) *fieldwidth = R_print.na_width;		\
  |  |  ------------------
  |  |  |  Branch (144:6): [True: 0, False: 256]
  |  |  ------------------
  |  |  145|    256|	else *fieldwidth = 1;					\
  |  |  146|    256|								\
  |  |  147|    256|	if (xmin < 0) {						\
  |  |  ------------------
  |  |  |  Branch (147:6): [True: 0, False: 256]
  |  |  ------------------
  |  |  148|      0|	    l = IndexWidth(-xmin) + 1;	/* +1 for sign */	\
  |  |  ------------------
  |  |  |  |   48|      0|#define IndexWidth    Rf_IndexWidth
  |  |  ------------------
  |  |  149|      0|	    if (l > *fieldwidth) *fieldwidth = l;		\
  |  |  ------------------
  |  |  |  Branch (149:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  150|      0|	}							\
  |  |  151|    256|	if (xmax > 0) {						\
  |  |  ------------------
  |  |  |  Branch (151:6): [True: 256, False: 0]
  |  |  ------------------
  |  |  152|    256|	    l = IndexWidth(xmax);				\
  |  |  ------------------
  |  |  |  |   48|    256|#define IndexWidth    Rf_IndexWidth
  |  |  ------------------
  |  |  153|    256|	    if (l > *fieldwidth) *fieldwidth = l;		\
  |  |  ------------------
  |  |  |  Branch (153:10): [True: 32, False: 224]
  |  |  ------------------
  |  |  154|    256|	}							\
  |  |  155|    256|    } while(0)
  |  |  ------------------
  |  |  |  Branch (155:13): [Folded, False: 256]
  |  |  ------------------
  ------------------
  172|    256|}
Rf_formatReal:
  436|  3.81k|{
  437|  3.81k|    bool
  438|  3.81k|	naflag = false, nanflag = false,
  439|  3.81k|	posinf = false, neginf = false;
  440|  3.81k|    int neg = 0;
  441|  3.81k|    int mnl = INT_MAX,
  442|  3.81k|	mxl, rgt, mxsl, mxns;
  443|  3.81k|    mxl = rgt = mxsl = mxns = INT_MIN;
  444|       |
  445|  7.63k|    for (R_xlen_t i = 0; i < n; i++) {
  ------------------
  |  Branch (445:26): [True: 3.81k, False: 3.81k]
  ------------------
  446|  3.81k|	if (!R_FINITE(x[i])) {
  ------------------
  |  |   82|  3.81k|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (446:6): [True: 0, False: 3.81k]
  ------------------
  447|      0|	    if(ISNA(x[i])) naflag = true;
  ------------------
  |  |   64|      0|#define ISNA(x)	       R_IsNA(x)
  |  |  ------------------
  |  |  |  Branch (64:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  448|      0|	    else if(ISNAN(x[i])) nanflag = true;
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  449|      0|	    else if(x[i] > 0) posinf = true;
  ------------------
  |  Branch (449:14): [True: 0, False: 0]
  ------------------
  450|      0|	    else neginf = true;
  451|  3.81k|	} else {
  452|  3.81k|	    int neg_i, kpower, nsig;
  453|  3.81k|	    bool roundingwidens;
  454|  3.81k|	    scientific(&x[i], &neg_i, &kpower, &nsig, &roundingwidens);
  455|       |
  456|  3.81k|	    int left = kpower + 1;
  457|  3.81k|	    if (roundingwidens) left--;
  ------------------
  |  Branch (457:10): [True: 0, False: 3.81k]
  ------------------
  458|       |
  459|  3.81k|	    int sleft = neg_i + ((left <= 0) ? 1 : left); /* >= 1 */
  ------------------
  |  Branch (459:27): [True: 48, False: 3.76k]
  ------------------
  460|  3.81k|	    int right = nsig - left; /* #{digits} right of '.' ( > 0 often)*/
  461|  3.81k|	    if (neg_i) neg = 1;	 /* if any < 0, need extra space for sign */
  ------------------
  |  Branch (461:10): [True: 0, False: 3.81k]
  ------------------
  462|       |
  463|       |	    /* Infinite precision "F" Format : */
  464|  3.81k|	    if (right > rgt)  rgt = right;	/* max digits to right of . */
  ------------------
  |  Branch (464:10): [True: 3.81k, False: 0]
  ------------------
  465|  3.81k|	    if (left  > mxl)  mxl = left;	/* max digits to  left of . */
  ------------------
  |  Branch (465:10): [True: 3.81k, False: 0]
  ------------------
  466|  3.81k|	    if (left  < mnl)  mnl = left;	/* min digits to  left of . */
  ------------------
  |  Branch (466:10): [True: 3.81k, False: 0]
  ------------------
  467|  3.81k|	    if (sleft > mxsl) mxsl = sleft;	/* max left including sign(s)*/
  ------------------
  |  Branch (467:10): [True: 3.81k, False: 0]
  ------------------
  468|  3.81k|	    if (nsig  > mxns) mxns = nsig;	/* max sig digits */
  ------------------
  |  Branch (468:10): [True: 3.81k, False: 0]
  ------------------
  469|  3.81k|	}
  470|  3.81k|    }
  471|       |     /* F Format: use "F" format WHENEVER we use not more space than  'E' + scipen
  472|       |     *		and still satisfy 'R_print.digits' {but as if nsmall==0 !}
  473|       |     *
  474|       |     * E Format has the form   [S]X[.XXX]E+XX[X]
  475|       |     *
  476|       |     * This is indicated by setting *e to non-zero (usually 1)
  477|       |     * If the additional exponent digit is required *e is set to 2
  478|       |     */
  479|       |
  480|       |    /*-- These	'mxsl' & 'rgt'	are used in F Format
  481|       |     *	 AND in the	____ if(.) "F" else "E" ___   below: */
  482|  3.81k|    if (R_print.digits == 0) rgt = 0;
  ------------------
  |  Branch (482:9): [True: 0, False: 3.81k]
  ------------------
  483|  3.81k|    if (mxl < 0) mxsl = 1 + neg;  /* we use %#w.dg, so have leading zero */
  ------------------
  |  Branch (483:9): [True: 0, False: 3.81k]
  ------------------
  484|       |
  485|       |    /* use nsmall only *after* comparing "F" vs "E": */
  486|  3.81k|    if (rgt < 0) rgt = 0;// rgt != 0  <==> needs decimal point (OutDec) "."
  ------------------
  |  Branch (486:9): [True: 202, False: 3.61k]
  ------------------
  487|  3.81k|    int wF = mxsl + rgt + (rgt != 0);	/* width for F format */
  488|       |
  489|       |    /*-- 'see' how "E" Exponential format would be like : */
  490|  3.81k|    *e = (mxl > 100 || mnl <= -99) ? 2 /* 3 digit exponent */ : 1;
  ------------------
  |  Branch (490:11): [True: 0, False: 3.81k]
  |  Branch (490:24): [True: 0, False: 3.81k]
  ------------------
  491|  3.81k|    if (mxns != INT_MIN) {
  ------------------
  |  Branch (491:9): [True: 3.81k, False: 0]
  ------------------
  492|  3.81k|	*d = mxns - 1;
  493|  3.81k|	*w = neg + (*d > 0) + *d + 4 + *e; /* width for E format */
  494|  3.81k|	if (wF <= *w + R_print.scipen) { /* Fixpoint if it needs less space */
  ------------------
  |  Branch (494:6): [True: 3.75k, False: 62]
  ------------------
  495|  3.75k|	    *e = 0;
  496|  3.75k|	    if (nsmall > rgt) {
  ------------------
  |  Branch (496:10): [True: 0, False: 3.75k]
  ------------------
  497|      0|		rgt = nsmall;
  498|      0|		wF = mxsl + rgt + (rgt != 0);
  499|      0|	    }
  500|  3.75k|	    *d = rgt;
  501|  3.75k|	    *w = wF;
  502|  3.75k|	} /* else : "E" Exponential format -- all done above */
  503|  3.81k|    }
  504|      0|    else { /* when all x[i] are non-finite */
  505|      0|	*w = 0;/* to be increased */
  506|      0|	*d = 0;
  507|      0|	*e = 0;
  508|      0|    }
  509|  3.81k|    if (naflag && *w < R_print.na_width)
  ------------------
  |  Branch (509:9): [True: 0, False: 3.81k]
  |  Branch (509:19): [True: 0, False: 0]
  ------------------
  510|      0|	*w = R_print.na_width;
  511|  3.81k|    if (nanflag && *w < 3) *w = 3;
  ------------------
  |  Branch (511:9): [True: 0, False: 3.81k]
  |  Branch (511:20): [True: 0, False: 0]
  ------------------
  512|  3.81k|    if (posinf  && *w < 3) *w = 3;
  ------------------
  |  Branch (512:9): [True: 0, False: 3.81k]
  |  Branch (512:20): [True: 0, False: 0]
  ------------------
  513|  3.81k|    if (neginf  && *w < 4) *w = 4;
  ------------------
  |  Branch (513:9): [True: 0, False: 3.81k]
  |  Branch (513:20): [True: 0, False: 0]
  ------------------
  514|  3.81k|}
format.c:scientific:
  315|  3.81k|{
  316|       |    /* for a number x , determine
  317|       |     *	neg    = 1_{x < 0}  {0/1}
  318|       |     *	kpower = Exponent of 10;
  319|       |     *	nsig   = min(R_print.digits, #{significant digits of alpha})
  320|       |     *  roundingwidens = true iff rounding causes x to increase in width
  321|       |     *
  322|       |     * where  |x| = alpha * 10^kpower	and	 1 <= alpha < 10
  323|       |     */
  324|  3.81k|    register double alpha;
  325|  3.81k|    register double r;
  326|  3.81k|    register int kp;
  327|  3.81k|    int j;
  328|       |
  329|  3.81k|    if (*x == 0.0) {
  ------------------
  |  Branch (329:9): [True: 32, False: 3.78k]
  ------------------
  330|     32|	*kpower = 0;
  331|     32|	*nsig = 1;
  332|     32|	*neg = 0;
  333|     32|	*roundingwidens = false;
  334|  3.78k|    } else {
  335|  3.78k|	if(*x < 0.0) {
  ------------------
  |  Branch (335:5): [True: 0, False: 3.78k]
  ------------------
  336|      0|	    *neg = 1; r = -*x;
  337|  3.78k|	} else {
  338|  3.78k|	    *neg = 0; r = *x;
  339|  3.78k|	}
  340|  3.78k|        if (R_print.digits >= DBL_DIG + 1) {
  ------------------
  |  Branch (340:13): [True: 0, False: 3.78k]
  ------------------
  341|      0|            format_via_sprintf(r, R_print.digits, kpower, nsig);
  342|      0|	    *roundingwidens = false;
  343|      0|            return;
  344|      0|        }
  345|  3.78k|        kp = (int) floor(log10(r)) - R_print.digits + 1;/* r = |x|; 10^(kp + digits - 1) <= r */
  346|  3.78k|#if defined(HAVE_LONG_DOUBLE) && (SIZEOF_LONG_DOUBLE > SIZEOF_DOUBLE)
  347|  3.78k|        long double r_prec = r;
  348|       |        /* use exact scaling factor in long double precision, if possible */
  349|  3.78k|        if (abs(kp) <= KP_MAX) {
  ------------------
  |  |  302|  3.78k|#define KP_MAX 27
  ------------------
  |  Branch (349:13): [True: 3.78k, False: 0]
  ------------------
  350|  3.78k|            if (kp > 0) r_prec /= tbl[kp]; else if (kp < 0) r_prec *= tbl[ -kp];
  ------------------
  |  Branch (350:17): [True: 0, False: 3.78k]
  |  Branch (350:53): [True: 3.78k, False: 0]
  ------------------
  351|  3.78k|        }
  352|      0|#  ifdef HAVE_POWL
  353|       |	// powl is C99 but only added to FreeBSD in 2017.
  354|      0|	else
  355|      0|            r_prec /= powl(10.0, (long double) kp);
  356|       |#  else
  357|       |        else if (kp <= R_dec_min_exponent)
  358|       |            r_prec = (r_prec * 1e+303)/Rexp10((double)(kp+303));
  359|       |        else
  360|       |            r_prec /= Rexp10((double) kp);
  361|       |#  endif
  362|  3.78k|        if (r_prec < tbl[R_print.digits - 1]) {
  ------------------
  |  Branch (362:13): [True: 0, False: 3.78k]
  ------------------
  363|      0|            r_prec *= 10.0;
  364|      0|            kp--;
  365|      0|        }
  366|       |        /* round alpha to integer, 10^(digits-1) <= alpha <= 10^digits
  367|       |	   accuracy limited by double rounding problem,
  368|       |	   alpha already rounded to 64 bits */
  369|  3.78k|        alpha = (double) R_nearbyintl(r_prec);
  ------------------
  |  |  261|  3.78k|# define R_nearbyintl nearbyintl
  ------------------
  370|       |#else /* not using long doubles */
  371|       |	double r_prec = r;
  372|       |        /* use exact scaling factor in double precision, if possible */
  373|       |        if (abs(kp) <= KP_MAX) {
  374|       |            if (kp >= 0) r_prec /= tbl[kp]; else r_prec *= tbl[ -kp];
  375|       |        }
  376|       |        /* For IEC60559 1e-308 is not representable except by gradual underflow.
  377|       |           Shifting by 303 allows for any potential denormalized numbers x,
  378|       |           and makes the reasonable assumption that R_dec_min_exponent+303
  379|       |           is in range. Representation of 1e+303 has low error.
  380|       |         */
  381|       |        else if (kp <= R_dec_min_exponent)
  382|       |            r_prec = (r_prec * 1e+303)/Rexp10((double)(kp+303));
  383|       |        else
  384|       |            r_prec /= Rexp10((double)kp);
  385|       |        if (r_prec < tbl[R_print.digits - 1]) {
  386|       |            r_prec *= 10.0;
  387|       |            kp--;
  388|       |        }
  389|       |        /* round alpha to integer, 10^(digits-1) <= alpha <= 10^digits */
  390|       |        /* accuracy limited by double rounding problem,
  391|       |	   alpha already rounded to 53 bits */
  392|       |        alpha = nearbyint(r_prec);
  393|       |#endif
  394|  3.78k|        *nsig = R_print.digits;
  395|  52.8k|        for (j = 1; j <= R_print.digits; j++) {
  ------------------
  |  Branch (395:21): [True: 52.8k, False: 0]
  ------------------
  396|  52.8k|            alpha /= 10.0;
  397|  52.8k|            if (alpha == floor(alpha)) {
  ------------------
  |  Branch (397:17): [True: 49.0k, False: 3.78k]
  ------------------
  398|  49.0k|                (*nsig)--;
  399|  49.0k|            } else {
  400|  3.78k|                break;
  401|  3.78k|            }
  402|  52.8k|        }
  403|  3.78k|        if (*nsig == 0 && R_print.digits > 0) {
  ------------------
  |  Branch (403:13): [True: 0, False: 3.78k]
  |  Branch (403:27): [True: 0, False: 0]
  ------------------
  404|      0|            *nsig = 1;
  405|      0|            kp += 1;
  406|      0|        }
  407|  3.78k|        *kpower = kp + R_print.digits - 1;
  408|       |
  409|       |	/* Scientific format may do more rounding than fixed format, e.g.
  410|       |	   9996 with 3 digits is 1e+04 in scientific, but 9996 in fixed.
  411|       |	   This happens when the true value r is less than 10^(kpower+1)
  412|       |	   and would not round up to it in fixed format.
  413|       |	   Here rgt is the decimal place that will be cut off by rounding */
  414|       |
  415|  3.78k|	int rgt = R_print.digits - *kpower;
  416|       |	/* bound rgt by 0 and KP_MAX */
  417|  3.78k|	rgt = rgt < 0 ? 0 : rgt > KP_MAX ? KP_MAX : rgt;
  ------------------
  |  |  302|  3.78k|#define KP_MAX 27
  ------------------
              	rgt = rgt < 0 ? 0 : rgt > KP_MAX ? KP_MAX : rgt;
  ------------------
  |  |  302|      0|#define KP_MAX 27
  ------------------
  |  Branch (417:8): [True: 0, False: 3.78k]
  |  Branch (417:22): [True: 0, False: 3.78k]
  ------------------
  418|  3.78k|	double fuzz = 0.5/(double)tbl[rgt];
  419|       |	// kpower can be bigger than the table.
  420|  3.78k|	*roundingwidens = *kpower > 0 && *kpower <= KP_MAX && r < tbl[*kpower] - fuzz;
  ------------------
  |  |  302|  5.92k|#define KP_MAX 27
  ------------------
  |  Branch (420:20): [True: 2.14k, False: 1.64k]
  |  Branch (420:35): [True: 2.14k, False: 0]
  |  Branch (420:56): [True: 0, False: 2.14k]
  ------------------
  421|  3.78k|    }
  422|  3.81k|}

R_fgetc:
   36|  25.2k|{
   37|       |#ifdef Win32
   38|       |    int c;
   39|       |    static int nexteof=0;
   40|       |    if (nexteof) {
   41|       |       nexteof = 0;
   42|       |       return R_EOF;
   43|       |    }
   44|       |    c = fgetc(fp);
   45|       |    if (c==EOF) {
   46|       |       nexteof = 1;
   47|       |       return '\n';
   48|       |    }
   49|       |#else
   50|  25.2k|    int c = fgetc(fp);
   51|  25.2k|#endif
   52|       |    /* get rid of  CR in CRLF line termination */
   53|  25.2k|    if (c == '\r') {
  ------------------
  |  Branch (53:9): [True: 0, False: 25.2k]
  ------------------
   54|      0|	c = fgetc(fp);
   55|       |	/* retain CR's with no following linefeed */
   56|      0|	if (c != '\n') {
  ------------------
  |  Branch (56:6): [True: 0, False: 0]
  ------------------
   57|      0|	    ungetc(c,fp);
   58|      0|	    return('\r');
   59|      0|	}
   60|      0|    }
   61|       |#ifdef Win32
   62|       |    return c;
   63|       |#else
   64|  25.2k|    return feof(fp) ? R_EOF : c;
  ------------------
  |  | 1531|      4|#define R_EOF	-1
  ------------------
  |  Branch (64:12): [True: 4, False: 25.2k]
  ------------------
   65|  25.2k|#endif
   66|  25.2k|}

Rf_yyparse:
 2036|    572|{
 2037|    572|    yy_state_fast_t yystate = 0;
 2038|       |    /* Number of tokens to shift before error messages enabled.  */
 2039|    572|    int yyerrstatus = 0;
 2040|       |
 2041|       |    /* Refer to the stacks through separate pointers, to allow yyoverflow
 2042|       |       to reallocate them elsewhere.  */
 2043|       |
 2044|       |    /* Their size.  */
 2045|    572|    YYPTRDIFF_T yystacksize = YYINITDEPTH;
  ------------------
  |  |  838|    572|#  define YYPTRDIFF_T __PTRDIFF_TYPE__
  ------------------
                  YYPTRDIFF_T yystacksize = YYINITDEPTH;
  ------------------
  |  | 1706|    572|# define YYINITDEPTH 200
  ------------------
 2046|       |
 2047|       |    /* The state stack: array, bottom, top.  */
 2048|    572|    yy_state_t yyssa[YYINITDEPTH];
 2049|    572|    yy_state_t *yyss = yyssa;
 2050|    572|    yy_state_t *yyssp = yyss;
 2051|       |
 2052|       |    /* The semantic value stack: array, bottom, top.  */
 2053|    572|    YYSTYPE yyvsa[YYINITDEPTH];
  ------------------
  |  |  484|    572|#define YYSTYPE		SEXP
  ------------------
 2054|    572|    YYSTYPE *yyvs = yyvsa;
  ------------------
  |  |  484|    572|#define YYSTYPE		SEXP
  ------------------
 2055|    572|    YYSTYPE *yyvsp = yyvs;
  ------------------
  |  |  484|    572|#define YYSTYPE		SEXP
  ------------------
 2056|       |
 2057|       |    /* The location stack: array, bottom, top.  */
 2058|    572|    YYLTYPE yylsa[YYINITDEPTH];
  ------------------
  |  |  192|    572|# define YYLTYPE yyltype
  ------------------
 2059|    572|    YYLTYPE *yyls = yylsa;
  ------------------
  |  |  192|    572|# define YYLTYPE yyltype
  ------------------
 2060|    572|    YYLTYPE *yylsp = yyls;
  ------------------
  |  |  192|    572|# define YYLTYPE yyltype
  ------------------
 2061|       |
 2062|    572|  int yyn;
 2063|       |  /* The return value of yyparse.  */
 2064|    572|  int yyresult;
 2065|       |  /* Lookahead symbol kind.  */
 2066|    572|  yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
 2067|       |  /* The variables used to return semantic value and location from the
 2068|       |     action routines.  */
 2069|    572|  YYSTYPE yyval;
  ------------------
  |  |  484|    572|#define YYSTYPE		SEXP
  ------------------
 2070|    572|  YYLTYPE yyloc;
  ------------------
  |  |  192|    572|# define YYLTYPE yyltype
  ------------------
 2071|       |
 2072|       |  /* The locations where the error started and ended.  */
 2073|    572|  YYLTYPE yyerror_range[3];
  ------------------
  |  |  192|    572|# define YYLTYPE yyltype
  ------------------
 2074|       |
 2075|       |  /* Buffer for error messages, and its allocated size.  */
 2076|    572|  char yymsgbuf[128];
 2077|    572|  char *yymsg = yymsgbuf;
 2078|    572|  YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
  ------------------
  |  |  838|    572|#  define YYPTRDIFF_T __PTRDIFF_TYPE__
  ------------------
 2079|       |
 2080|    572|#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
 2081|       |
 2082|       |  /* The number of symbols on the RHS of the reduced rule.
 2083|       |     Keep to zero when no symbol should be popped.  */
 2084|    572|  int yylen = 0;
 2085|       |
 2086|    572|  YYDPRINTF ((stderr, "Starting parse\n"));
  ------------------
  |  | 1697|    572|# define YYDPRINTF(Args) ((void) 0)
  ------------------
 2087|       |
 2088|    572|  yychar = YYEMPTY; /* Cause a token to be read.  */
  ------------------
  |  | 2018|    572|# define yychar			Rf_yychar
  ------------------
                yychar = YYEMPTY; /* Cause a token to be read.  */
  ------------------
  |  |  582|    572|#define YYEMPTY -2
  ------------------
 2089|       |
 2090|    572|  yylsp[0] = yylloc;
 2091|    572|  goto yysetstate;
 2092|       |
 2093|       |
 2094|       |/*------------------------------------------------------------.
 2095|       || yynewstate -- push a new state, which is found in yystate.  |
 2096|       |`------------------------------------------------------------*/
 2097|  18.2k|yynewstate:
 2098|       |  /* In all cases, when you get here, the value and location stacks
 2099|       |     have just been pushed.  So pushing a state here evens the stacks.  */
 2100|  18.2k|  yyssp++;
 2101|       |
 2102|       |
 2103|       |/*--------------------------------------------------------------------.
 2104|       || yysetstate -- set current state (the top of the stack) to yystate.  |
 2105|       |`--------------------------------------------------------------------*/
 2106|  18.8k|yysetstate:
 2107|  18.8k|  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
  ------------------
  |  | 1697|  18.8k|# define YYDPRINTF(Args) ((void) 0)
  ------------------
 2108|  18.8k|  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
  ------------------
  |  |  954|  18.8k|#define YY_ASSERT(E) ((void) (0 && (E)))
  |  |  ------------------
  |  |  |  Branch (954:31): [Folded, False: 18.8k]
  |  |  |  Branch (954:37): [True: 0, False: 0]
  |  |  |  Branch (954:37): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2109|  18.8k|  YY_IGNORE_USELESS_CAST_BEGIN
 2110|  18.8k|  *yyssp = YY_CAST (yy_state_t, yystate);
  ------------------
  |  |  493|  18.8k|#   define YY_CAST(Type, Val) ((Type) (Val))
  ------------------
 2111|  18.8k|  YY_IGNORE_USELESS_CAST_END
 2112|  18.8k|  YY_STACK_PRINT (yyss, yyssp);
 2113|       |
 2114|  18.8k|  if (yyss + yystacksize - 1 <= yyssp)
  ------------------
  |  Branch (2114:7): [True: 0, False: 18.8k]
  ------------------
 2115|       |#if !defined yyoverflow && !defined YYSTACK_RELOCATE
 2116|       |    YYNOMEM;
 2117|       |#else
 2118|      0|    {
 2119|       |      /* Get the current used size of the three stacks, in elements.  */
 2120|      0|      YYPTRDIFF_T yysize = yyssp - yyss + 1;
  ------------------
  |  |  838|      0|#  define YYPTRDIFF_T __PTRDIFF_TYPE__
  ------------------
 2121|       |
 2122|       |# if defined yyoverflow
 2123|       |      {
 2124|       |        /* Give user a chance to reallocate the stack.  Use copies of
 2125|       |           these so that the &'s don't force the real ones into
 2126|       |           memory.  */
 2127|       |        yy_state_t *yyss1 = yyss;
 2128|       |        YYSTYPE *yyvs1 = yyvs;
 2129|       |        YYLTYPE *yyls1 = yyls;
 2130|       |
 2131|       |        /* Each stack pointer address is followed by the size of the
 2132|       |           data in use in that stack, in bytes.  This used to be a
 2133|       |           conditional around just the two extra args, but that might
 2134|       |           be undefined if yyoverflow is a macro.  */
 2135|       |        yyoverflow (YY_("memory exhausted"),
 2136|       |                    &yyss1, yysize * YYSIZEOF (*yyssp),
 2137|       |                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
 2138|       |                    &yyls1, yysize * YYSIZEOF (*yylsp),
 2139|       |                    &yystacksize);
 2140|       |        yyss = yyss1;
 2141|       |        yyvs = yyvs1;
 2142|       |        yyls = yyls1;
 2143|       |      }
 2144|       |# else /* defined YYSTACK_RELOCATE */
 2145|       |      /* Extend the stack our own way.  */
 2146|      0|      if (YYMAXDEPTH <= yystacksize)
  ------------------
  |  | 1717|      0|# define YYMAXDEPTH 10000
  ------------------
  |  Branch (2146:11): [True: 0, False: 0]
  ------------------
 2147|      0|        YYNOMEM;
  ------------------
  |  | 1463|      0|#define YYNOMEM         goto yyexhaustedlab
  ------------------
 2148|      0|      yystacksize *= 2;
 2149|      0|      if (YYMAXDEPTH < yystacksize)
  ------------------
  |  | 1717|      0|# define YYMAXDEPTH 10000
  ------------------
  |  Branch (2149:11): [True: 0, False: 0]
  ------------------
 2150|      0|        yystacksize = YYMAXDEPTH;
  ------------------
  |  | 1717|      0|# define YYMAXDEPTH 10000
  ------------------
 2151|       |
 2152|      0|      {
 2153|      0|        yy_state_t *yyss1 = yyss;
 2154|      0|        union yyalloc *yyptr =
 2155|      0|          YY_CAST (union yyalloc *,
  ------------------
  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  ------------------
 2156|      0|                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
 2157|      0|        if (! yyptr)
  ------------------
  |  Branch (2157:13): [True: 0, False: 0]
  ------------------
 2158|      0|          YYNOMEM;
  ------------------
  |  | 1463|      0|#define YYNOMEM         goto yyexhaustedlab
  ------------------
 2159|      0|        YYSTACK_RELOCATE (yyss_alloc, yyss);
  ------------------
  |  | 1054|      0|    do                                                                  \
  |  | 1055|      0|      {                                                                 \
  |  | 1056|      0|        YYPTRDIFF_T yynewbytes;                                         \
  |  |  ------------------
  |  |  |  |  838|      0|#  define YYPTRDIFF_T __PTRDIFF_TYPE__
  |  |  ------------------
  |  | 1057|      0|        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
  |  |  ------------------
  |  |  |  | 1072|      0|      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1058|      0|        Stack = &yyptr->Stack_alloc;                                    \
  |  | 1059|      0|        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
  |  |  ------------------
  |  |  |  |  871|      0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  ------------------
  |  |  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                       yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
  |  |  ------------------
  |  |  |  | 1037|      0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  871|      0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1060|      0|        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
  |  |  ------------------
  |  |  |  |  871|      0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  ------------------
  |  |  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1061|      0|      }                                                                 \
  |  | 1062|      0|    while (0)
  |  |  ------------------
  |  |  |  Branch (1062:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2160|      0|        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
  ------------------
  |  | 1054|      0|    do                                                                  \
  |  | 1055|      0|      {                                                                 \
  |  | 1056|      0|        YYPTRDIFF_T yynewbytes;                                         \
  |  |  ------------------
  |  |  |  |  838|      0|#  define YYPTRDIFF_T __PTRDIFF_TYPE__
  |  |  ------------------
  |  | 1057|      0|        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
  |  |  ------------------
  |  |  |  | 1072|      0|      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1058|      0|        Stack = &yyptr->Stack_alloc;                                    \
  |  | 1059|      0|        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
  |  |  ------------------
  |  |  |  |  871|      0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  ------------------
  |  |  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                       yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
  |  |  ------------------
  |  |  |  | 1037|      0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  871|      0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1060|      0|        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
  |  |  ------------------
  |  |  |  |  871|      0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  ------------------
  |  |  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1061|      0|      }                                                                 \
  |  | 1062|      0|    while (0)
  |  |  ------------------
  |  |  |  Branch (1062:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2161|      0|        YYSTACK_RELOCATE (yyls_alloc, yyls);
  ------------------
  |  | 1054|      0|    do                                                                  \
  |  | 1055|      0|      {                                                                 \
  |  | 1056|      0|        YYPTRDIFF_T yynewbytes;                                         \
  |  |  ------------------
  |  |  |  |  838|      0|#  define YYPTRDIFF_T __PTRDIFF_TYPE__
  |  |  ------------------
  |  | 1057|      0|        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
  |  |  ------------------
  |  |  |  | 1072|      0|      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1058|      0|        Stack = &yyptr->Stack_alloc;                                    \
  |  | 1059|      0|        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
  |  |  ------------------
  |  |  |  |  871|      0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  ------------------
  |  |  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                       yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
  |  |  ------------------
  |  |  |  | 1037|      0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  871|      0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1060|      0|        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
  |  |  ------------------
  |  |  |  |  871|      0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
  |  |  |  |  ------------------
  |  |  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1061|      0|      }                                                                 \
  |  | 1062|      0|    while (0)
  |  |  ------------------
  |  |  |  Branch (1062:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2162|      0|#  undef YYSTACK_RELOCATE
 2163|      0|        if (yyss1 != yyssa)
  ------------------
  |  Branch (2163:13): [True: 0, False: 0]
  ------------------
 2164|      0|          YYSTACK_FREE (yyss1);
  ------------------
  |  |  996|      0|#  define YYSTACK_FREE YYFREE
  |  |  ------------------
  |  |  |  |  369|      0|#define YYFREE   yystack_free
  |  |  ------------------
  ------------------
 2165|      0|      }
 2166|      0|# endif
 2167|       |
 2168|      0|      yyssp = yyss + yysize - 1;
 2169|      0|      yyvsp = yyvs + yysize - 1;
 2170|      0|      yylsp = yyls + yysize - 1;
 2171|       |
 2172|      0|      YY_IGNORE_USELESS_CAST_BEGIN
 2173|      0|      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
  ------------------
  |  | 1697|      0|# define YYDPRINTF(Args) ((void) 0)
  ------------------
 2174|      0|                  YY_CAST (long, yystacksize)));
 2175|      0|      YY_IGNORE_USELESS_CAST_END
 2176|       |
 2177|      0|      if (yyss + yystacksize - 1 <= yyssp)
  ------------------
  |  Branch (2177:11): [True: 0, False: 0]
  ------------------
 2178|      0|        YYABORT;
  ------------------
  |  | 1461|      0|#define YYABORT         goto yyabortlab
  ------------------
 2179|      0|    }
 2180|  18.8k|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
 2181|       |
 2182|       |
 2183|  18.8k|  if (yystate == YYFINAL)
  ------------------
  |  | 1087|  18.8k|#define YYFINAL  48
  ------------------
  |  Branch (2183:7): [True: 0, False: 18.8k]
  ------------------
 2184|      0|    YYACCEPT;
  ------------------
  |  | 1460|      0|#define YYACCEPT        goto yyacceptlab
  ------------------
 2185|       |
 2186|  18.8k|  goto yybackup;
 2187|       |
 2188|       |
 2189|       |/*-----------.
 2190|       || yybackup.  |
 2191|       |`-----------*/
 2192|  18.8k|yybackup:
 2193|       |  /* Do appropriate processing given the current state.  Read a
 2194|       |     lookahead token if we need one and don't already have one.  */
 2195|       |
 2196|       |  /* First try to decide what to do without reference to lookahead token.  */
 2197|  18.8k|  yyn = yypact[yystate];
 2198|  18.8k|  if (yypact_value_is_default (yyn))
  ------------------
  |  | 1203|  18.8k|  ((Yyn) == YYPACT_NINF)
  |  |  ------------------
  |  |  |  | 1200|  18.8k|#define YYPACT_NINF (-130)
  |  |  ------------------
  |  |  |  Branch (1203:3): [True: 3.63k, False: 15.2k]
  |  |  ------------------
  ------------------
 2199|  3.63k|    goto yydefault;
 2200|       |
 2201|       |  /* Not known => get a lookahead token if don't already have one.  */
 2202|       |
 2203|       |  /* YYCHAR is either empty, or end-of-input, or a valid lookahead.  */
 2204|  15.2k|  if (yychar == YYEMPTY)
  ------------------
  |  | 2018|  15.2k|# define yychar			Rf_yychar
  ------------------
                if (yychar == YYEMPTY)
  ------------------
  |  |  582|  15.2k|#define YYEMPTY -2
  ------------------
  |  Branch (2204:7): [True: 7.63k, False: 7.58k]
  ------------------
 2205|  7.63k|    {
 2206|  7.63k|      YYDPRINTF ((stderr, "Reading a token\n"));
  ------------------
  |  | 1697|  7.63k|# define YYDPRINTF(Args) ((void) 0)
  ------------------
 2207|  7.63k|      yychar = yylex ();
  ------------------
  |  | 2018|  7.63k|# define yychar			Rf_yychar
  ------------------
 2208|  7.63k|    }
 2209|       |
 2210|  15.2k|  if (yychar <= YYEOF)
  ------------------
  |  | 2018|  15.2k|# define yychar			Rf_yychar
  ------------------
                if (yychar <= YYEOF)
  ------------------
  |  |  583|  15.2k|#define YYEOF 0
  ------------------
  |  Branch (2210:7): [True: 0, False: 15.2k]
  ------------------
 2211|      0|    {
 2212|      0|      yychar = YYEOF;
  ------------------
  |  | 2018|      0|# define yychar			Rf_yychar
  ------------------
                    yychar = YYEOF;
  ------------------
  |  |  583|      0|#define YYEOF 0
  ------------------
 2213|      0|      yytoken = YYSYMBOL_YYEOF;
 2214|      0|      YYDPRINTF ((stderr, "Now at end of input.\n"));
  ------------------
  |  | 1697|      0|# define YYDPRINTF(Args) ((void) 0)
  ------------------
 2215|      0|    }
 2216|  15.2k|  else if (yychar == YYerror)
  ------------------
  |  | 2018|  15.2k|# define yychar			Rf_yychar
  ------------------
                else if (yychar == YYerror)
  ------------------
  |  |  584|  15.2k|#define YYerror 256
  ------------------
  |  Branch (2216:12): [True: 0, False: 15.2k]
  ------------------
 2217|      0|    {
 2218|       |      /* The scanner already issued an error message, process directly
 2219|       |         to error recovery.  But do not keep the error token as
 2220|       |         lookahead, it is too special and may lead us to an endless
 2221|       |         loop in error recovery. */
 2222|      0|      yychar = YYUNDEF;
  ------------------
  |  | 2018|      0|# define yychar			Rf_yychar
  ------------------
                    yychar = YYUNDEF;
  ------------------
  |  |  585|      0|#define YYUNDEF 257
  ------------------
 2223|      0|      yytoken = YYSYMBOL_YYerror;
 2224|      0|      yyerror_range[1] = yylloc;
 2225|      0|      goto yyerrlab1;
 2226|      0|    }
 2227|  15.2k|  else
 2228|  15.2k|    {
 2229|  15.2k|      yytoken = YYTRANSLATE (yychar);
  ------------------
  |  | 1107|  15.2k|  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
  |  |  ------------------
  |  |  |  | 1101|  15.2k|#define YYMAXUTOK   308
  |  |  ------------------
  |  |  |  Branch (1107:4): [True: 15.2k, False: 0]
  |  |  |  Branch (1107:18): [True: 15.2k, False: 0]
  |  |  ------------------
  |  | 1108|  15.2k|   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
  |  |  ------------------
  |  |  |  |  493|  15.2k|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  ------------------
  |  | 1109|  15.2k|   : YYSYMBOL_YYUNDEF)
  ------------------
 2230|  15.2k|      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
 2231|  15.2k|    }
 2232|       |
 2233|       |  /* If the proper action on seeing token YYTOKEN is to reduce or to
 2234|       |     detect an error, take that action.  */
 2235|  15.2k|  yyn += yytoken;
 2236|  15.2k|  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
  ------------------
  |  | 1089|  15.2k|#define YYLAST   572
  ------------------
  |  Branch (2236:7): [True: 0, False: 15.2k]
  |  Branch (2236:18): [True: 24, False: 15.1k]
  |  Branch (2236:34): [True: 7.55k, False: 7.63k]
  ------------------
 2237|  7.58k|    goto yydefault;
 2238|  7.63k|  yyn = yytable[yyn];
 2239|  7.63k|  if (yyn <= 0)
  ------------------
  |  Branch (2239:7): [True: 0, False: 7.63k]
  ------------------
 2240|      0|    {
 2241|      0|      if (yytable_value_is_error (yyn))
  ------------------
  |  | 1208|      0|  ((Yyn) == YYTABLE_NINF)
  |  |  ------------------
  |  |  |  | 1205|      0|#define YYTABLE_NINF (-1)
  |  |  ------------------
  |  |  |  Branch (1208:3): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2242|      0|        goto yyerrlab;
 2243|      0|      yyn = -yyn;
 2244|      0|      goto yyreduce;
 2245|      0|    }
 2246|       |
 2247|       |  /* Count tokens shifted since error; after three, turn off error
 2248|       |     status.  */
 2249|  7.63k|  if (yyerrstatus)
  ------------------
  |  Branch (2249:7): [True: 0, False: 7.63k]
  ------------------
 2250|      0|    yyerrstatus--;
 2251|       |
 2252|       |  /* Shift the lookahead token.  */
 2253|  7.63k|  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 2254|  7.63k|  yystate = yyn;
 2255|  7.63k|  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 2256|  7.63k|  *++yyvsp = yylval;
  ------------------
  |  | 2019|  7.63k|# define yylval			Rf_yylval
  ------------------
 2257|  7.63k|  YY_IGNORE_MAYBE_UNINITIALIZED_END
 2258|  7.63k|  *++yylsp = yylloc;
 2259|       |
 2260|       |  /* Discard the shifted token.  */
 2261|  7.63k|  yychar = YYEMPTY;
  ------------------
  |  | 2018|  7.63k|# define yychar			Rf_yychar
  ------------------
                yychar = YYEMPTY;
  ------------------
  |  |  582|  7.63k|#define YYEMPTY -2
  ------------------
 2262|  7.63k|  goto yynewstate;
 2263|       |
 2264|       |
 2265|       |/*-----------------------------------------------------------.
 2266|       || yydefault -- do the default action for the current state.  |
 2267|       |`-----------------------------------------------------------*/
 2268|  11.2k|yydefault:
 2269|  11.2k|  yyn = yydefact[yystate];
 2270|  11.2k|  if (yyn == 0)
  ------------------
  |  Branch (2270:7): [True: 0, False: 11.2k]
  ------------------
 2271|      0|    goto yyerrlab;
 2272|  11.2k|  goto yyreduce;
 2273|       |
 2274|       |
 2275|       |/*-----------------------------.
 2276|       || yyreduce -- do a reduction.  |
 2277|       |`-----------------------------*/
 2278|  11.2k|yyreduce:
 2279|       |  /* yyn is the number of a rule to reduce with.  */
 2280|  11.2k|  yylen = yyr2[yyn];
 2281|       |
 2282|       |  /* If YYLEN is nonzero, implement the default value of the action:
 2283|       |     '$$ = $1'.
 2284|       |
 2285|       |     Otherwise, the following line sets YYVAL to garbage.
 2286|       |     This behavior is undocumented and Bison
 2287|       |     users should not rely upon it.  Assigning to YYVAL
 2288|       |     unconditionally makes the parser a bit smaller, and it avoids a
 2289|       |     GCC warning that YYVAL may be used uninitialized.  */
 2290|  11.2k|  yyval = yyvsp[1-yylen];
 2291|       |
 2292|       |  /* Default location. */
 2293|  11.2k|  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
  ------------------
  |  |  194|  11.2k|    do	{ 								\
  |  |  195|  11.2k|	if (N){								\
  |  |  ------------------
  |  |  |  Branch (195:6): [True: 10.4k, False: 752]
  |  |  ------------------
  |  |  196|  10.4k|	    (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
  |  |  ------------------
  |  |  |  | 1513|  10.4k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  197|  10.4k|	    (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
  |  |  ------------------
  |  |  |  | 1513|  10.4k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  198|  10.4k|	    (Current).first_byte   = YYRHSLOC (Rhs, 1).first_byte;	\
  |  |  ------------------
  |  |  |  | 1513|  10.4k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  199|  10.4k|	    (Current).last_line    = YYRHSLOC (Rhs, N).last_line;	\
  |  |  ------------------
  |  |  |  | 1513|  10.4k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  200|  10.4k|	    (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
  |  |  ------------------
  |  |  |  | 1513|  10.4k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  201|  10.4k|	    (Current).last_byte    = YYRHSLOC (Rhs, N).last_byte;	\
  |  |  ------------------
  |  |  |  | 1513|  10.4k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  202|  10.4k|	    (Current).first_parsed = YYRHSLOC (Rhs, 1).first_parsed;    \
  |  |  ------------------
  |  |  |  | 1513|  10.4k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  203|  10.4k|	    (Current).last_parsed  = YYRHSLOC (Rhs, N).last_parsed;	\
  |  |  ------------------
  |  |  |  | 1513|  10.4k|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  204|  10.4k|	    incrementId( ) ; 						\
  |  |  205|  10.4k|	    (Current).id = identifier ; 				\
  |  |  206|  10.4k|	    _current_token = yyr1[yyn] ; 				\
  |  |  207|  10.4k|	    if (ParseState.keepSrcRefs && ParseState.keepParseData) {	\
  |  |  ------------------
  |  |  |  Branch (207:10): [True: 0, False: 10.4k]
  |  |  |  Branch (207:36): [True: 0, False: 0]
  |  |  ------------------
  |  |  208|      0|	        yyltype childs[N];					\
  |  |  209|      0|	        int ii = 0; 						\
  |  |  210|      0|	        for(ii=0; ii<N; ii++){					\
  |  |  ------------------
  |  |  |  Branch (210:20): [True: 0, False: 0]
  |  |  ------------------
  |  |  211|      0|		      childs[ii] = YYRHSLOC (Rhs, (ii+1) ) ; 		\
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  212|      0|	        } 							\
  |  |  213|      0|	        recordParents( identifier, childs, N) ; 		\
  |  |  214|      0|	    }								\
  |  |  215|  10.4k|	} else	{							\
  |  |  216|    752|	  (Current).first_line   = (Current).last_line   =		\
  |  |  217|    752|	    YYRHSLOC (Rhs, 0).last_line;				\
  |  |  ------------------
  |  |  |  | 1513|    752|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  218|    752|	  (Current).first_parsed   = (Current).last_parsed   =		\
  |  |  219|    752|	    YYRHSLOC (Rhs, 0).last_parsed;				\
  |  |  ------------------
  |  |  |  | 1513|    752|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  220|    752|	  (Current).first_column = YYRHSLOC (Rhs, 0).last_column;	\
  |  |  ------------------
  |  |  |  | 1513|    752|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  221|    752|	  (Current).last_column = (Current).first_column - 1;		\
  |  |  222|    752|	  (Current).first_byte = YYRHSLOC (Rhs, 0).last_byte;		\
  |  |  ------------------
  |  |  |  | 1513|    752|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  223|    752|	  (Current).last_byte = (Current).first_byte - 1;		\
  |  |  224|    752|	  (Current).id = NA_INTEGER;                                    \
  |  |  ------------------
  |  |  |  |   56|    752|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  225|    752|	} 								\
  |  |  226|  11.2k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (226:14): [Folded, False: 11.2k]
  |  |  ------------------
  ------------------
 2294|  11.2k|  yyerror_range[1] = yyloc;
 2295|  11.2k|  YY_REDUCE_PRINT (yyn);
 2296|  11.2k|  switch (yyn)
 2297|  11.2k|    {
 2298|     48|  case 2: /* prog: END_OF_INPUT  */
  ------------------
  |  Branch (2298:3): [True: 48, False: 11.1k]
  ------------------
 2299|     48|                                                { Status = 0; YYACCEPT; }
  ------------------
  |  | 1460|     48|#define YYACCEPT        goto yyacceptlab
  ------------------
 2300|      0|    break;
 2301|       |
 2302|    376|  case 3: /* prog: '\n'  */
  ------------------
  |  Branch (2302:3): [True: 376, False: 10.8k]
  ------------------
 2303|    376|                                                { Status = 2; yyresult = xxvalue(NULL,2,NULL); YYACCEPT; }
  ------------------
  |  | 1460|    376|#define YYACCEPT        goto yyacceptlab
  ------------------
 2304|      0|    break;
 2305|       |
 2306|    148|  case 4: /* prog: expr_or_assign_or_help '\n'  */
  ------------------
  |  Branch (2306:3): [True: 148, False: 11.0k]
  ------------------
 2307|    148|                                                { Status = 3; yyresult = xxvalue(yyvsp[-1],3,&(yylsp[-1])); YYACCEPT; }
  ------------------
  |  | 1460|    148|#define YYACCEPT        goto yyacceptlab
  ------------------
 2308|      0|    break;
 2309|       |
 2310|      0|  case 5: /* prog: expr_or_assign_or_help ';'  */
  ------------------
  |  Branch (2310:3): [True: 0, False: 11.2k]
  ------------------
 2311|      0|                                                { Status = 4; yyresult = xxvalue(yyvsp[-1],4,&(yylsp[-1])); YYACCEPT; }
  ------------------
  |  | 1460|      0|#define YYACCEPT        goto yyacceptlab
  ------------------
 2312|      0|    break;
 2313|       |
 2314|      0|  case 6: /* prog: error  */
  ------------------
  |  Branch (2314:3): [True: 0, False: 11.2k]
  ------------------
 2315|      0|                                                { Status = 1; YYABORT; }
  ------------------
  |  | 1461|      0|#define YYABORT         goto yyabortlab
  ------------------
 2316|      0|    break;
 2317|       |
 2318|    730|  case 7: /* expr_or_assign_or_help: expr  */
  ------------------
  |  Branch (2318:3): [True: 730, False: 10.4k]
  ------------------
 2319|    730|                                                { yyval = yyvsp[0]; }
 2320|    730|    break;
 2321|       |
 2322|      0|  case 8: /* expr_or_assign_or_help: expr_or_assign_or_help EQ_ASSIGN expr_or_assign_or_help  */
  ------------------
  |  Branch (2322:3): [True: 0, False: 11.2k]
  ------------------
 2323|      0|                                                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]); setId((yyloc)); }
 2324|      0|    break;
 2325|       |
 2326|      0|  case 9: /* expr_or_assign_or_help: expr_or_assign_or_help '?' expr_or_assign_or_help  */
  ------------------
  |  Branch (2326:3): [True: 0, False: 11.2k]
  ------------------
 2327|      0|                                                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]); setId((yyloc)); }
 2328|      0|    break;
 2329|       |
 2330|  1.51k|  case 10: /* expr_or_help: expr  */
  ------------------
  |  Branch (2330:3): [True: 1.51k, False: 9.70k]
  ------------------
 2331|  1.51k|                                                    { yyval = yyvsp[0]; }
 2332|  1.51k|    break;
 2333|       |
 2334|      0|  case 11: /* expr_or_help: expr_or_help '?' expr_or_help  */
  ------------------
  |  Branch (2334:3): [True: 0, False: 11.2k]
  ------------------
 2335|      0|                                                    { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]); setId((yyloc)); }
 2336|      0|    break;
 2337|       |
 2338|    300|  case 12: /* expr: NUM_CONST  */
  ------------------
  |  Branch (2338:3): [True: 300, False: 10.9k]
  ------------------
 2339|    300|                                                { yyval = yyvsp[0];	setId((yyloc)); }
 2340|    300|    break;
 2341|       |
 2342|    280|  case 13: /* expr: STR_CONST  */
  ------------------
  |  Branch (2342:3): [True: 280, False: 10.9k]
  ------------------
 2343|    280|                                                { yyval = yyvsp[0];	setId((yyloc)); }
 2344|    280|    break;
 2345|       |
 2346|     22|  case 14: /* expr: NULL_CONST  */
  ------------------
  |  Branch (2346:3): [True: 22, False: 11.1k]
  ------------------
 2347|     22|                                                { yyval = yyvsp[0];	setId((yyloc)); }
 2348|     22|    break;
 2349|       |
 2350|      0|  case 15: /* expr: PLACEHOLDER  */
  ------------------
  |  Branch (2350:3): [True: 0, False: 11.2k]
  ------------------
 2351|      0|                                                { yyval = yyvsp[0];	setId((yyloc)); }
 2352|      0|    break;
 2353|       |
 2354|  1.77k|  case 16: /* expr: SYMBOL  */
  ------------------
  |  Branch (2354:3): [True: 1.77k, False: 9.44k]
  ------------------
 2355|  1.77k|                                                { yyval = yyvsp[0];	setId((yyloc)); }
 2356|  1.77k|    break;
 2357|       |
 2358|    102|  case 17: /* expr: '{' exprlist '}'  */
  ------------------
  |  Branch (2358:3): [True: 102, False: 11.1k]
  ------------------
 2359|    102|                                                { yyval = xxexprlist(yyvsp[-2],&(yylsp[-2]),yyvsp[-1]); setId((yyloc)); }
 2360|    102|    break;
 2361|       |
 2362|      6|  case 18: /* expr: '(' expr_or_assign_or_help ')'  */
  ------------------
  |  Branch (2362:3): [True: 6, False: 11.2k]
  ------------------
 2363|      6|                                                { yyval = xxparen(yyvsp[-2],yyvsp[-1]);	setId((yyloc)); }
 2364|      6|    break;
 2365|       |
 2366|      2|  case 19: /* expr: '-' expr  */
  ------------------
  |  Branch (2366:3): [True: 2, False: 11.2k]
  ------------------
 2367|      2|                                                { yyval = xxunary(yyvsp[-1],yyvsp[0]);	setId((yyloc)); }
 2368|      2|    break;
 2369|       |
 2370|      0|  case 20: /* expr: '+' expr  */
  ------------------
  |  Branch (2370:3): [True: 0, False: 11.2k]
  ------------------
 2371|      0|                                                { yyval = xxunary(yyvsp[-1],yyvsp[0]);	setId((yyloc)); }
 2372|      0|    break;
 2373|       |
 2374|     24|  case 21: /* expr: '!' expr  */
  ------------------
  |  Branch (2374:3): [True: 24, False: 11.1k]
  ------------------
 2375|     24|                                                { yyval = xxunary(yyvsp[-1],yyvsp[0]);	setId((yyloc)); }
 2376|     24|    break;
 2377|       |
 2378|      0|  case 22: /* expr: '~' expr  */
  ------------------
  |  Branch (2378:3): [True: 0, False: 11.2k]
  ------------------
 2379|      0|                                                { yyval = xxunary(yyvsp[-1],yyvsp[0]);	setId((yyloc)); }
 2380|      0|    break;
 2381|       |
 2382|      0|  case 23: /* expr: '?' expr_or_assign_or_help  */
  ------------------
  |  Branch (2382:3): [True: 0, False: 11.2k]
  ------------------
 2383|      0|                                                { yyval = xxunary(yyvsp[-1],yyvsp[0]);	setId((yyloc)); }
 2384|      0|    break;
 2385|       |
 2386|      2|  case 24: /* expr: expr ':' expr  */
  ------------------
  |  Branch (2386:3): [True: 2, False: 11.2k]
  ------------------
 2387|      2|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2388|      2|    break;
 2389|       |
 2390|      0|  case 25: /* expr: expr '+' expr  */
  ------------------
  |  Branch (2390:3): [True: 0, False: 11.2k]
  ------------------
 2391|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2392|      0|    break;
 2393|       |
 2394|      0|  case 26: /* expr: expr '-' expr  */
  ------------------
  |  Branch (2394:3): [True: 0, False: 11.2k]
  ------------------
 2395|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2396|      0|    break;
 2397|       |
 2398|     10|  case 27: /* expr: expr '*' expr  */
  ------------------
  |  Branch (2398:3): [True: 10, False: 11.2k]
  ------------------
 2399|     10|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2400|     10|    break;
 2401|       |
 2402|     14|  case 28: /* expr: expr '/' expr  */
  ------------------
  |  Branch (2402:3): [True: 14, False: 11.1k]
  ------------------
 2403|     14|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2404|     14|    break;
 2405|       |
 2406|      0|  case 29: /* expr: expr '^' expr  */
  ------------------
  |  Branch (2406:3): [True: 0, False: 11.2k]
  ------------------
 2407|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2408|      0|    break;
 2409|       |
 2410|     50|  case 30: /* expr: expr SPECIAL expr  */
  ------------------
  |  Branch (2410:3): [True: 50, False: 11.1k]
  ------------------
 2411|     50|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2412|     50|    break;
 2413|       |
 2414|      0|  case 31: /* expr: expr '~' expr  */
  ------------------
  |  Branch (2414:3): [True: 0, False: 11.2k]
  ------------------
 2415|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2416|      0|    break;
 2417|       |
 2418|      0|  case 32: /* expr: expr LT expr  */
  ------------------
  |  Branch (2418:3): [True: 0, False: 11.2k]
  ------------------
 2419|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2420|      0|    break;
 2421|       |
 2422|      2|  case 33: /* expr: expr LE expr  */
  ------------------
  |  Branch (2422:3): [True: 2, False: 11.2k]
  ------------------
 2423|      2|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2424|      2|    break;
 2425|       |
 2426|      8|  case 34: /* expr: expr EQ expr  */
  ------------------
  |  Branch (2426:3): [True: 8, False: 11.2k]
  ------------------
 2427|      8|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2428|      8|    break;
 2429|       |
 2430|     12|  case 35: /* expr: expr NE expr  */
  ------------------
  |  Branch (2430:3): [True: 12, False: 11.2k]
  ------------------
 2431|     12|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2432|     12|    break;
 2433|       |
 2434|      0|  case 36: /* expr: expr GE expr  */
  ------------------
  |  Branch (2434:3): [True: 0, False: 11.2k]
  ------------------
 2435|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2436|      0|    break;
 2437|       |
 2438|      4|  case 37: /* expr: expr GT expr  */
  ------------------
  |  Branch (2438:3): [True: 4, False: 11.2k]
  ------------------
 2439|      4|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2440|      4|    break;
 2441|       |
 2442|      0|  case 38: /* expr: expr AND expr  */
  ------------------
  |  Branch (2442:3): [True: 0, False: 11.2k]
  ------------------
 2443|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2444|      0|    break;
 2445|       |
 2446|      0|  case 39: /* expr: expr OR expr  */
  ------------------
  |  Branch (2446:3): [True: 0, False: 11.2k]
  ------------------
 2447|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2448|      0|    break;
 2449|       |
 2450|      2|  case 40: /* expr: expr AND2 expr  */
  ------------------
  |  Branch (2450:3): [True: 2, False: 11.2k]
  ------------------
 2451|      2|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2452|      2|    break;
 2453|       |
 2454|      2|  case 41: /* expr: expr OR2 expr  */
  ------------------
  |  Branch (2454:3): [True: 2, False: 11.2k]
  ------------------
 2455|      2|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2456|      2|    break;
 2457|       |
 2458|      0|  case 42: /* expr: expr PIPE expr  */
  ------------------
  |  Branch (2458:3): [True: 0, False: 11.2k]
  ------------------
 2459|      0|                                                { yyval = xxpipe(yyvsp[-2],yyvsp[0],&(yylsp[0]));       setId((yyloc)); }
 2460|      0|    break;
 2461|       |
 2462|      0|  case 43: /* expr: expr PIPEBIND expr  */
  ------------------
  |  Branch (2462:3): [True: 0, False: 11.2k]
  ------------------
 2463|      0|                                                { yyval = xxpipebind(yyvsp[-1],yyvsp[-2],yyvsp[0],&(yylsp[-1]));	setId((yyloc)); }
 2464|      0|    break;
 2465|       |
 2466|    294|  case 44: /* expr: expr LEFT_ASSIGN expr  */
  ------------------
  |  Branch (2466:3): [True: 294, False: 10.9k]
  ------------------
 2467|    294|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2468|    294|    break;
 2469|       |
 2470|      0|  case 45: /* expr: expr RIGHT_ASSIGN expr  */
  ------------------
  |  Branch (2470:3): [True: 0, False: 11.2k]
  ------------------
 2471|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[0],yyvsp[-2]);	setId((yyloc)); }
 2472|      0|    break;
 2473|       |
 2474|     84|  case 46: /* expr: FUNCTION '(' formlist ')' cr expr_or_assign_or_help  */
  ------------------
  |  Branch (2474:3): [True: 84, False: 11.1k]
  ------------------
 2475|     84|                                                { yyval = xxdefun(yyvsp[-5],yyvsp[-3],yyvsp[0],&(yyloc)); 	setId((yyloc)); }
 2476|     84|    break;
 2477|       |
 2478|      0|  case 47: /* expr: '\\' '(' formlist ')' cr expr_or_assign_or_help  */
  ------------------
  |  Branch (2478:3): [True: 0, False: 11.2k]
  ------------------
 2479|      0|                                                                                                                                { yyval = xxdefun(R_FunctionSymbol,yyvsp[-3],yyvsp[0],&(yyloc)); 	setId((yyloc)); }
 2480|      0|    break;
 2481|       |
 2482|    840|  case 48: /* expr: expr '(' sublist ')'  */
  ------------------
  |  Branch (2482:3): [True: 840, False: 10.3k]
  ------------------
 2483|    840|                                                { yyval = xxfuncall(yyvsp[-3],yyvsp[-1]);  setId((yyloc)); modif_token( &(yylsp[-3]), SYMBOL_FUNCTION_CALL ) ; }
  ------------------
  |  |  624|    840|#define SYMBOL_FUNCTION_CALL 296
  ------------------
 2484|    840|    break;
 2485|       |
 2486|     52|  case 49: /* expr: IF ifcond expr_or_assign_or_help  */
  ------------------
  |  Branch (2486:3): [True: 52, False: 11.1k]
  ------------------
 2487|     52|                                                        { yyval = xxif(yyvsp[-2],yyvsp[-1],yyvsp[0]);	setId((yyloc)); }
 2488|     52|    break;
 2489|       |
 2490|     16|  case 50: /* expr: IF ifcond expr_or_assign_or_help ELSE expr_or_assign_or_help  */
  ------------------
  |  Branch (2490:3): [True: 16, False: 11.1k]
  ------------------
 2491|     16|                                                                                { yyval = xxifelse(yyvsp[-4],yyvsp[-3],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2492|     16|    break;
 2493|       |
 2494|      8|  case 51: /* expr: FOR forcond expr_or_assign_or_help  */
  ------------------
  |  Branch (2494:3): [True: 8, False: 11.2k]
  ------------------
 2495|      8|                                                                { yyval = xxfor(yyvsp[-2],yyvsp[-1],yyvsp[0]);	setId((yyloc)); }
 2496|      8|    break;
 2497|       |
 2498|      2|  case 52: /* expr: WHILE cond expr_or_assign_or_help  */
  ------------------
  |  Branch (2498:3): [True: 2, False: 11.2k]
  ------------------
 2499|      2|                                                    { yyval = xxwhile(yyvsp[-2],yyvsp[-1],yyvsp[0]);	setId((yyloc)); }
 2500|      2|    break;
 2501|       |
 2502|      0|  case 53: /* expr: REPEAT expr_or_assign_or_help  */
  ------------------
  |  Branch (2502:3): [True: 0, False: 11.2k]
  ------------------
 2503|      0|                                                    { yyval = xxrepeat(yyvsp[-1],yyvsp[0]);	setId((yyloc)); }
 2504|      0|    break;
 2505|       |
 2506|     44|  case 54: /* expr: expr LBB sublist ']' ']'  */
  ------------------
  |  Branch (2506:3): [True: 44, False: 11.1k]
  ------------------
 2507|     44|                                                { yyval = xxsubscript(yyvsp[-4],yyvsp[-3],yyvsp[-2]);	setId((yyloc)); }
 2508|     44|    break;
 2509|       |
 2510|     32|  case 55: /* expr: expr '[' sublist ']'  */
  ------------------
  |  Branch (2510:3): [True: 32, False: 11.1k]
  ------------------
 2511|     32|                                                { yyval = xxsubscript(yyvsp[-3],yyvsp[-2],yyvsp[-1]);	setId((yyloc)); }
 2512|     32|    break;
 2513|       |
 2514|      0|  case 56: /* expr: SYMBOL NS_GET SYMBOL  */
  ------------------
  |  Branch (2514:3): [True: 0, False: 11.2k]
  ------------------
 2515|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);      setId((yyloc)); modif_token( &(yylsp[-2]), SYMBOL_PACKAGE ) ; }
  ------------------
  |  |  625|      0|#define SYMBOL_PACKAGE 297
  ------------------
 2516|      0|    break;
 2517|       |
 2518|      0|  case 57: /* expr: SYMBOL NS_GET STR_CONST  */
  ------------------
  |  Branch (2518:3): [True: 0, False: 11.2k]
  ------------------
 2519|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);      setId((yyloc)); modif_token( &(yylsp[-2]), SYMBOL_PACKAGE ) ; }
  ------------------
  |  |  625|      0|#define SYMBOL_PACKAGE 297
  ------------------
 2520|      0|    break;
 2521|       |
 2522|      0|  case 58: /* expr: STR_CONST NS_GET SYMBOL  */
  ------------------
  |  Branch (2522:3): [True: 0, False: 11.2k]
  ------------------
 2523|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2524|      0|    break;
 2525|       |
 2526|      0|  case 59: /* expr: STR_CONST NS_GET STR_CONST  */
  ------------------
  |  Branch (2526:3): [True: 0, False: 11.2k]
  ------------------
 2527|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2528|      0|    break;
 2529|       |
 2530|      0|  case 60: /* expr: SYMBOL NS_GET_INT SYMBOL  */
  ------------------
  |  Branch (2530:3): [True: 0, False: 11.2k]
  ------------------
 2531|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);      setId((yyloc)); modif_token( &(yylsp[-2]), SYMBOL_PACKAGE ) ;}
  ------------------
  |  |  625|      0|#define SYMBOL_PACKAGE 297
  ------------------
 2532|      0|    break;
 2533|       |
 2534|      0|  case 61: /* expr: SYMBOL NS_GET_INT STR_CONST  */
  ------------------
  |  Branch (2534:3): [True: 0, False: 11.2k]
  ------------------
 2535|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);      setId((yyloc)); modif_token( &(yylsp[-2]), SYMBOL_PACKAGE ) ;}
  ------------------
  |  |  625|      0|#define SYMBOL_PACKAGE 297
  ------------------
 2536|      0|    break;
 2537|       |
 2538|      0|  case 62: /* expr: STR_CONST NS_GET_INT SYMBOL  */
  ------------------
  |  Branch (2538:3): [True: 0, False: 11.2k]
  ------------------
 2539|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2540|      0|    break;
 2541|       |
 2542|      0|  case 63: /* expr: STR_CONST NS_GET_INT STR_CONST  */
  ------------------
  |  Branch (2542:3): [True: 0, False: 11.2k]
  ------------------
 2543|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2544|      0|    break;
 2545|       |
 2546|     56|  case 64: /* expr: expr '$' SYMBOL  */
  ------------------
  |  Branch (2546:3): [True: 56, False: 11.1k]
  ------------------
 2547|     56|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2548|     56|    break;
 2549|       |
 2550|      0|  case 65: /* expr: expr '$' STR_CONST  */
  ------------------
  |  Branch (2550:3): [True: 0, False: 11.2k]
  ------------------
 2551|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2552|      0|    break;
 2553|       |
 2554|      0|  case 66: /* expr: expr '@' SYMBOL  */
  ------------------
  |  Branch (2554:3): [True: 0, False: 11.2k]
  ------------------
 2555|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);      setId((yyloc)); modif_token( &(yylsp[0]), SLOT ) ; }
  ------------------
  |  |  626|      0|#define SLOT 298
  ------------------
 2556|      0|    break;
 2557|       |
 2558|      0|  case 67: /* expr: expr '@' STR_CONST  */
  ------------------
  |  Branch (2558:3): [True: 0, False: 11.2k]
  ------------------
 2559|      0|                                                { yyval = xxbinary(yyvsp[-1],yyvsp[-2],yyvsp[0]);	setId((yyloc)); }
 2560|      0|    break;
 2561|       |
 2562|      0|  case 68: /* expr: NEXT  */
  ------------------
  |  Branch (2562:3): [True: 0, False: 11.2k]
  ------------------
 2563|      0|                                                { yyval = xxnxtbrk(yyvsp[0]);	setId((yyloc)); }
 2564|      0|    break;
 2565|       |
 2566|      0|  case 69: /* expr: BREAK  */
  ------------------
  |  Branch (2566:3): [True: 0, False: 11.2k]
  ------------------
 2567|      0|                                                { yyval = xxnxtbrk(yyvsp[0]);	setId((yyloc)); }
 2568|      0|    break;
 2569|       |
 2570|      2|  case 70: /* cond: '(' expr_or_help ')'  */
  ------------------
  |  Branch (2570:3): [True: 2, False: 11.2k]
  ------------------
 2571|      2|                                                        { yyval = xxcond(yyvsp[-1]);   }
 2572|      2|    break;
 2573|       |
 2574|     68|  case 71: /* ifcond: '(' expr_or_help ')'  */
  ------------------
  |  Branch (2574:3): [True: 68, False: 11.1k]
  ------------------
 2575|     68|                                                        { yyval = xxifcond(yyvsp[-1]); }
 2576|     68|    break;
 2577|       |
 2578|      8|  case 72: /* forcond: '(' SYMBOL IN expr_or_help ')'  */
  ------------------
  |  Branch (2578:3): [True: 8, False: 11.2k]
  ------------------
 2579|      8|                                                        { yyval = xxforcond(yyvsp[-3],yyvsp[-1]);	setId((yyloc)); }
 2580|      8|    break;
 2581|       |
 2582|      0|  case 73: /* exprlist: %empty  */
  ------------------
  |  Branch (2582:3): [True: 0, False: 11.2k]
  ------------------
 2583|      0|                                                { yyval = xxexprlist0();	setId((yyloc)); }
 2584|      0|    break;
 2585|       |
 2586|    102|  case 74: /* exprlist: expr_or_assign_or_help  */
  ------------------
  |  Branch (2586:3): [True: 102, False: 11.1k]
  ------------------
 2587|    102|                                                        { yyval = xxexprlist1(yyvsp[0], &(yylsp[0])); }
 2588|    102|    break;
 2589|       |
 2590|     74|  case 75: /* exprlist: exprlist ';' expr_or_assign_or_help  */
  ------------------
  |  Branch (2590:3): [True: 74, False: 11.1k]
  ------------------
 2591|     74|                                                        { yyval = xxexprlist2(yyvsp[-2], yyvsp[0], &(yylsp[0])); }
 2592|     74|    break;
 2593|       |
 2594|     12|  case 76: /* exprlist: exprlist ';'  */
  ------------------
  |  Branch (2594:3): [True: 12, False: 11.2k]
  ------------------
 2595|     12|                                                { yyval = yyvsp[-1];		setId((yyloc)); }
 2596|     12|    break;
 2597|       |
 2598|    222|  case 77: /* exprlist: exprlist '\n' expr_or_assign_or_help  */
  ------------------
  |  Branch (2598:3): [True: 222, False: 10.9k]
  ------------------
 2599|    222|                                                        { yyval = xxexprlist2(yyvsp[-2], yyvsp[0], &(yylsp[0])); }
 2600|    222|    break;
 2601|       |
 2602|     96|  case 78: /* exprlist: exprlist '\n'  */
  ------------------
  |  Branch (2602:3): [True: 96, False: 11.1k]
  ------------------
 2603|     96|                                                { yyval = yyvsp[-1];}
 2604|     96|    break;
 2605|       |
 2606|    916|  case 79: /* sublist: sub  */
  ------------------
  |  Branch (2606:3): [True: 916, False: 10.2k]
  ------------------
 2607|    916|                                                { yyval = xxsublist1(yyvsp[0]);	  }
 2608|    916|    break;
 2609|       |
 2610|    584|  case 80: /* sublist: sublist cr ',' sub  */
  ------------------
  |  Branch (2610:3): [True: 584, False: 10.6k]
  ------------------
 2611|    584|                                                { yyval = xxsublist2(yyvsp[-3],yyvsp[0]); }
 2612|    584|    break;
 2613|       |
 2614|     74|  case 81: /* sub: %empty  */
  ------------------
  |  Branch (2614:3): [True: 74, False: 11.1k]
  ------------------
 2615|     74|                                                { yyval = xxsub0();	 }
 2616|     74|    break;
 2617|       |
 2618|  1.21k|  case 82: /* sub: expr_or_help  */
  ------------------
  |  Branch (2618:3): [True: 1.21k, False: 9.99k]
  ------------------
 2619|  1.21k|                                                { yyval = xxsub1(yyvsp[0], &(yylsp[0]));  }
 2620|  1.21k|    break;
 2621|       |
 2622|      0|  case 83: /* sub: SYMBOL EQ_ASSIGN  */
  ------------------
  |  Branch (2622:3): [True: 0, False: 11.2k]
  ------------------
 2623|      0|                                                { yyval = xxsymsub0(yyvsp[-1], &(yylsp[-1])); 	modif_token( &(yylsp[0]), EQ_SUB ) ; modif_token( &(yylsp[-1]), SYMBOL_SUB ) ; }
  ------------------
  |  |  622|      0|#define EQ_SUB 294
  ------------------
                                                              { yyval = xxsymsub0(yyvsp[-1], &(yylsp[-1])); 	modif_token( &(yylsp[0]), EQ_SUB ) ; modif_token( &(yylsp[-1]), SYMBOL_SUB ) ; }
  ------------------
  |  |  623|      0|#define SYMBOL_SUB 295
  ------------------
 2624|      0|    break;
 2625|       |
 2626|    208|  case 84: /* sub: SYMBOL EQ_ASSIGN expr_or_help  */
  ------------------
  |  Branch (2626:3): [True: 208, False: 11.0k]
  ------------------
 2627|    208|                                                { yyval = xxsymsub1(yyvsp[-2],yyvsp[0], &(yylsp[-2])); 	modif_token( &(yylsp[-1]), EQ_SUB ) ; modif_token( &(yylsp[-2]), SYMBOL_SUB ) ; }
  ------------------
  |  |  622|    208|#define EQ_SUB 294
  ------------------
                                                              { yyval = xxsymsub1(yyvsp[-2],yyvsp[0], &(yylsp[-2])); 	modif_token( &(yylsp[-1]), EQ_SUB ) ; modif_token( &(yylsp[-2]), SYMBOL_SUB ) ; }
  ------------------
  |  |  623|    208|#define SYMBOL_SUB 295
  ------------------
 2628|    208|    break;
 2629|       |
 2630|      0|  case 85: /* sub: STR_CONST EQ_ASSIGN  */
  ------------------
  |  Branch (2630:3): [True: 0, False: 11.2k]
  ------------------
 2631|      0|                                                { yyval = xxsymsub0(yyvsp[-1], &(yylsp[-1])); 	modif_token( &(yylsp[0]), EQ_SUB ) ; }
  ------------------
  |  |  622|      0|#define EQ_SUB 294
  ------------------
 2632|      0|    break;
 2633|       |
 2634|      4|  case 86: /* sub: STR_CONST EQ_ASSIGN expr_or_help  */
  ------------------
  |  Branch (2634:3): [True: 4, False: 11.2k]
  ------------------
 2635|      4|                                                    { yyval = xxsymsub1(yyvsp[-2],yyvsp[0], &(yylsp[-2])); 	modif_token( &(yylsp[-1]), EQ_SUB ) ; }
  ------------------
  |  |  622|      4|#define EQ_SUB 294
  ------------------
 2636|      4|    break;
 2637|       |
 2638|      0|  case 87: /* sub: NULL_CONST EQ_ASSIGN  */
  ------------------
  |  Branch (2638:3): [True: 0, False: 11.2k]
  ------------------
 2639|      0|                                                { yyval = xxnullsub0(&(yylsp[-1])); 	modif_token( &(yylsp[0]), EQ_SUB ) ; }
  ------------------
  |  |  622|      0|#define EQ_SUB 294
  ------------------
 2640|      0|    break;
 2641|       |
 2642|      0|  case 88: /* sub: NULL_CONST EQ_ASSIGN expr_or_help  */
  ------------------
  |  Branch (2642:3): [True: 0, False: 11.2k]
  ------------------
 2643|      0|                                                    { yyval = xxnullsub1(yyvsp[0], &(yylsp[-2])); 	modif_token( &(yylsp[-1]), EQ_SUB ) ; }
  ------------------
  |  |  622|      0|#define EQ_SUB 294
  ------------------
 2644|      0|    break;
 2645|       |
 2646|     10|  case 89: /* formlist: %empty  */
  ------------------
  |  Branch (2646:3): [True: 10, False: 11.2k]
  ------------------
 2647|     10|                                                { yyval = xxnullformal(); }
 2648|     10|    break;
 2649|       |
 2650|     74|  case 90: /* formlist: SYMBOL  */
  ------------------
  |  Branch (2650:3): [True: 74, False: 11.1k]
  ------------------
 2651|     74|                                                { yyval = xxfirstformal0(yyvsp[0]); 	modif_token( &(yylsp[0]), SYMBOL_FORMALS ) ; }
  ------------------
  |  |  620|     74|#define SYMBOL_FORMALS 292
  ------------------
 2652|     74|    break;
 2653|       |
 2654|      0|  case 91: /* formlist: SYMBOL EQ_ASSIGN expr_or_help  */
  ------------------
  |  Branch (2654:3): [True: 0, False: 11.2k]
  ------------------
 2655|      0|                                                { yyval = xxfirstformal1(yyvsp[-2],yyvsp[0]); 	modif_token( &(yylsp[-2]), SYMBOL_FORMALS ) ; modif_token( &(yylsp[-1]), EQ_FORMALS ) ; }
  ------------------
  |  |  620|      0|#define SYMBOL_FORMALS 292
  ------------------
                                                              { yyval = xxfirstformal1(yyvsp[-2],yyvsp[0]); 	modif_token( &(yylsp[-2]), SYMBOL_FORMALS ) ; modif_token( &(yylsp[-1]), EQ_FORMALS ) ; }
  ------------------
  |  |  621|      0|#define EQ_FORMALS 293
  ------------------
 2656|      0|    break;
 2657|       |
 2658|     14|  case 92: /* formlist: formlist ',' SYMBOL  */
  ------------------
  |  Branch (2658:3): [True: 14, False: 11.1k]
  ------------------
 2659|     14|                                                { yyval = xxaddformal0(yyvsp[-2],yyvsp[0], &(yylsp[0]));   modif_token( &(yylsp[0]), SYMBOL_FORMALS ) ; }
  ------------------
  |  |  620|     14|#define SYMBOL_FORMALS 292
  ------------------
 2660|     14|    break;
 2661|       |
 2662|      8|  case 93: /* formlist: formlist ',' SYMBOL EQ_ASSIGN expr_or_help  */
  ------------------
  |  Branch (2662:3): [True: 8, False: 11.2k]
  ------------------
 2663|      8|                                                { yyval = xxaddformal1(yyvsp[-4],yyvsp[-2],yyvsp[0],&(yylsp[-2])); modif_token( &(yylsp[-2]), SYMBOL_FORMALS ) ; modif_token( &(yylsp[-1]), EQ_FORMALS ) ;}
  ------------------
  |  |  620|      8|#define SYMBOL_FORMALS 292
  ------------------
                                                              { yyval = xxaddformal1(yyvsp[-4],yyvsp[-2],yyvsp[0],&(yylsp[-2])); modif_token( &(yylsp[-2]), SYMBOL_FORMALS ) ; modif_token( &(yylsp[-1]), EQ_FORMALS ) ;}
  ------------------
  |  |  621|      8|#define EQ_FORMALS 293
  ------------------
 2664|      8|    break;
 2665|       |
 2666|    668|  case 94: /* cr: %empty  */
  ------------------
  |  Branch (2666:3): [True: 668, False: 10.5k]
  ------------------
 2667|    668|                                                { EatLines = 1; }
 2668|    668|    break;
 2669|       |
 2670|       |
 2671|       |
 2672|      0|      default: break;
  ------------------
  |  Branch (2672:7): [True: 0, False: 11.2k]
  ------------------
 2673|  11.2k|    }
 2674|       |  /* User semantic actions sometimes alter yychar, and that requires
 2675|       |     that yytoken be updated with the new translation.  We take the
 2676|       |     approach of translating immediately before every use of yytoken.
 2677|       |     One alternative is translating here after every semantic action,
 2678|       |     but that translation would be missed if the semantic action invokes
 2679|       |     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
 2680|       |     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
 2681|       |     incorrect destructor might then be invoked immediately.  In the
 2682|       |     case of YYERROR or YYBACKUP, subsequent parser actions might lead
 2683|       |     to an incorrect destructor call or verbose syntax error message
 2684|       |     before the lookahead is translated.  */
 2685|  10.6k|  YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
 2686|       |
 2687|  10.6k|  YYPOPSTACK (yylen);
  ------------------
  |  | 2080|  10.6k|#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
  ------------------
 2688|  10.6k|  yylen = 0;
 2689|       |
 2690|  10.6k|  *++yyvsp = yyval;
 2691|  10.6k|  *++yylsp = yyloc;
 2692|       |
 2693|       |  /* Now 'shift' the result of the reduction.  Determine what state
 2694|       |     that goes to, based on the state we popped back to and the rule
 2695|       |     number reduced by.  */
 2696|  10.6k|  {
 2697|  10.6k|    const int yylhs = yyr1[yyn] - YYNTOKENS;
  ------------------
  |  | 1092|  10.6k|#define YYNTOKENS  75
  ------------------
 2698|  10.6k|    const int yyi = yypgoto[yylhs] + *yyssp;
 2699|  10.6k|    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
  ------------------
  |  | 1089|  20.4k|#define YYLAST   572
  ------------------
  |  Branch (2699:16): [True: 9.80k, False: 840]
  |  Branch (2699:28): [True: 9.80k, False: 0]
  |  Branch (2699:45): [True: 5.75k, False: 4.05k]
  ------------------
 2700|  10.6k|               ? yytable[yyi]
 2701|  10.6k|               : yydefgoto[yylhs]);
 2702|  10.6k|  }
 2703|       |
 2704|  10.6k|  goto yynewstate;
 2705|       |
 2706|       |
 2707|       |/*--------------------------------------.
 2708|       || yyerrlab -- here on detecting error.  |
 2709|       |`--------------------------------------*/
 2710|      0|yyerrlab:
 2711|       |  /* Make sure we have latest lookahead translation.  See comments at
 2712|       |     user semantic actions for why this is necessary.  */
 2713|      0|  yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
  ------------------
  |  | 2018|      0|# define yychar			Rf_yychar
  ------------------
                yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
  ------------------
  |  |  582|      0|#define YYEMPTY -2
  ------------------
                yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
  ------------------
  |  | 1107|      0|  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
  |  |  ------------------
  |  |  |  | 1101|      0|#define YYMAXUTOK   308
  |  |  ------------------
  |  |  |  Branch (1107:4): [True: 0, False: 0]
  |  |  |  Branch (1107:18): [True: 0, False: 0]
  |  |  ------------------
  |  | 1108|      0|   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
  |  |  ------------------
  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  ------------------
  |  | 1109|      0|   : YYSYMBOL_YYUNDEF)
  ------------------
  |  Branch (2713:13): [True: 0, False: 0]
  ------------------
 2714|       |  /* If not already recovering from an error, report this error.  */
 2715|      0|  if (!yyerrstatus)
  ------------------
  |  Branch (2715:7): [True: 0, False: 0]
  ------------------
 2716|      0|    {
 2717|      0|      ++yynerrs;
  ------------------
  |  | 2020|      0|# define yynerrs		Rf_yynerrs
  ------------------
 2718|      0|      {
 2719|      0|        yypcontext_t yyctx
 2720|      0|          = {yyssp, yytoken, &yylloc};
 2721|      0|        char const *yymsgp = YY_("syntax error");
  ------------------
  |  |  888|      0|#  define YY_(Msgid) Msgid
  ------------------
 2722|      0|        int yysyntax_error_status;
 2723|      0|        yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx);
 2724|      0|        if (yysyntax_error_status == 0)
  ------------------
  |  Branch (2724:13): [True: 0, False: 0]
  ------------------
 2725|      0|          yymsgp = yymsg;
 2726|      0|        else if (yysyntax_error_status == -1)
  ------------------
  |  Branch (2726:18): [True: 0, False: 0]
  ------------------
 2727|      0|          {
 2728|      0|            if (yymsg != yymsgbuf)
  ------------------
  |  Branch (2728:17): [True: 0, False: 0]
  ------------------
 2729|      0|              YYSTACK_FREE (yymsg);
  ------------------
  |  |  996|      0|#  define YYSTACK_FREE YYFREE
  |  |  ------------------
  |  |  |  |  369|      0|#define YYFREE   yystack_free
  |  |  ------------------
  ------------------
 2730|      0|            yymsg = YY_CAST (char *,
  ------------------
  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  ------------------
 2731|      0|                             YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
 2732|      0|            if (yymsg)
  ------------------
  |  Branch (2732:17): [True: 0, False: 0]
  ------------------
 2733|      0|              {
 2734|      0|                yysyntax_error_status
 2735|      0|                  = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx);
 2736|      0|                yymsgp = yymsg;
 2737|      0|              }
 2738|      0|            else
 2739|      0|              {
 2740|      0|                yymsg = yymsgbuf;
 2741|      0|                yymsg_alloc = sizeof yymsgbuf;
 2742|      0|                yysyntax_error_status = YYENOMEM;
 2743|      0|              }
 2744|      0|          }
 2745|      0|        yyerror (yymsgp);
 2746|      0|        if (yysyntax_error_status == YYENOMEM)
  ------------------
  |  Branch (2746:13): [True: 0, False: 0]
  ------------------
 2747|      0|          YYNOMEM;
  ------------------
  |  | 1463|      0|#define YYNOMEM         goto yyexhaustedlab
  ------------------
 2748|      0|      }
 2749|      0|    }
 2750|       |
 2751|      0|  yyerror_range[1] = yylloc;
 2752|      0|  if (yyerrstatus == 3)
  ------------------
  |  Branch (2752:7): [True: 0, False: 0]
  ------------------
 2753|      0|    {
 2754|       |      /* If just tried and failed to reuse lookahead token after an
 2755|       |         error, discard it.  */
 2756|       |
 2757|      0|      if (yychar <= YYEOF)
  ------------------
  |  | 2018|      0|# define yychar			Rf_yychar
  ------------------
                    if (yychar <= YYEOF)
  ------------------
  |  |  583|      0|#define YYEOF 0
  ------------------
  |  Branch (2757:11): [True: 0, False: 0]
  ------------------
 2758|      0|        {
 2759|       |          /* Return failure if at end of input.  */
 2760|      0|          if (yychar == YYEOF)
  ------------------
  |  | 2018|      0|# define yychar			Rf_yychar
  ------------------
                        if (yychar == YYEOF)
  ------------------
  |  |  583|      0|#define YYEOF 0
  ------------------
  |  Branch (2760:15): [True: 0, False: 0]
  ------------------
 2761|      0|            YYABORT;
  ------------------
  |  | 1461|      0|#define YYABORT         goto yyabortlab
  ------------------
 2762|      0|        }
 2763|      0|      else
 2764|      0|        {
 2765|      0|          yydestruct ("Error: discarding",
 2766|      0|                      yytoken, &yylval, &yylloc);
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 2767|      0|          yychar = YYEMPTY;
  ------------------
  |  | 2018|      0|# define yychar			Rf_yychar
  ------------------
                        yychar = YYEMPTY;
  ------------------
  |  |  582|      0|#define YYEMPTY -2
  ------------------
 2768|      0|        }
 2769|      0|    }
 2770|       |
 2771|       |  /* Else will try to reuse lookahead token after shifting the error
 2772|       |     token.  */
 2773|      0|  goto yyerrlab1;
 2774|       |
 2775|       |
 2776|       |/*---------------------------------------------------.
 2777|       || yyerrorlab -- error raised explicitly by YYERROR.  |
 2778|       |`---------------------------------------------------*/
 2779|      0|yyerrorlab:
 2780|       |  /* Pacify compilers when the user code never invokes YYERROR and the
 2781|       |     label yyerrorlab therefore never appears in user code.  */
 2782|      0|  if (0)
  ------------------
  |  Branch (2782:7): [Folded, False: 0]
  ------------------
 2783|      0|    YYERROR;
  ------------------
  |  | 1462|      0|#define YYERROR         goto yyerrorlab
  ------------------
 2784|      0|  ++yynerrs;
  ------------------
  |  | 2020|      0|# define yynerrs		Rf_yynerrs
  ------------------
 2785|       |
 2786|       |  /* Do not reclaim the symbols of the rule whose action triggered
 2787|       |     this YYERROR.  */
 2788|      0|  YYPOPSTACK (yylen);
  ------------------
  |  | 2080|      0|#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
  ------------------
 2789|      0|  yylen = 0;
 2790|      0|  YY_STACK_PRINT (yyss, yyssp);
 2791|      0|  yystate = *yyssp;
 2792|      0|  goto yyerrlab1;
 2793|       |
 2794|       |
 2795|       |/*-------------------------------------------------------------.
 2796|       || yyerrlab1 -- common code for both syntax error and YYERROR.  |
 2797|       |`-------------------------------------------------------------*/
 2798|      0|yyerrlab1:
 2799|      0|  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
 2800|       |
 2801|       |  /* Pop stack until we find a state that shifts the error token.  */
 2802|      0|  for (;;)
 2803|      0|    {
 2804|      0|      yyn = yypact[yystate];
 2805|      0|      if (!yypact_value_is_default (yyn))
  ------------------
  |  | 1203|      0|  ((Yyn) == YYPACT_NINF)
  |  |  ------------------
  |  |  |  | 1200|      0|#define YYPACT_NINF (-130)
  |  |  ------------------
  ------------------
  |  Branch (2805:11): [True: 0, False: 0]
  ------------------
 2806|      0|        {
 2807|      0|          yyn += YYSYMBOL_YYerror;
 2808|      0|          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
  ------------------
  |  | 1089|      0|#define YYLAST   572
  ------------------
  |  Branch (2808:15): [True: 0, False: 0]
  |  Branch (2808:27): [True: 0, False: 0]
  |  Branch (2808:44): [True: 0, False: 0]
  ------------------
 2809|      0|            {
 2810|      0|              yyn = yytable[yyn];
 2811|      0|              if (0 < yyn)
  ------------------
  |  Branch (2811:19): [True: 0, False: 0]
  ------------------
 2812|      0|                break;
 2813|      0|            }
 2814|      0|        }
 2815|       |
 2816|       |      /* Pop the current state because it cannot handle the error token.  */
 2817|      0|      if (yyssp == yyss)
  ------------------
  |  Branch (2817:11): [True: 0, False: 0]
  ------------------
 2818|      0|        YYABORT;
  ------------------
  |  | 1461|      0|#define YYABORT         goto yyabortlab
  ------------------
 2819|       |
 2820|      0|      yyerror_range[1] = *yylsp;
 2821|      0|      yydestruct ("Error: popping",
 2822|      0|                  YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp);
  ------------------
  |  | 1166|      0|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
  |  |  ------------------
  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  ------------------
  ------------------
 2823|      0|      YYPOPSTACK (1);
  ------------------
  |  | 2080|      0|#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
  ------------------
 2824|      0|      yystate = *yyssp;
 2825|      0|      YY_STACK_PRINT (yyss, yyssp);
 2826|      0|    }
 2827|       |
 2828|      0|  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 2829|      0|  *++yyvsp = yylval;
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 2830|      0|  YY_IGNORE_MAYBE_UNINITIALIZED_END
 2831|       |
 2832|      0|  yyerror_range[2] = yylloc;
 2833|      0|  ++yylsp;
 2834|      0|  YYLLOC_DEFAULT (*yylsp, yyerror_range, 2);
  ------------------
  |  |  194|      0|    do	{ 								\
  |  |  195|      0|	if (N){								\
  |  |  ------------------
  |  |  |  Branch (195:6): [True: 0, Folded]
  |  |  ------------------
  |  |  196|      0|	    (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  197|      0|	    (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  198|      0|	    (Current).first_byte   = YYRHSLOC (Rhs, 1).first_byte;	\
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  199|      0|	    (Current).last_line    = YYRHSLOC (Rhs, N).last_line;	\
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  200|      0|	    (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  201|      0|	    (Current).last_byte    = YYRHSLOC (Rhs, N).last_byte;	\
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  202|      0|	    (Current).first_parsed = YYRHSLOC (Rhs, 1).first_parsed;    \
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  203|      0|	    (Current).last_parsed  = YYRHSLOC (Rhs, N).last_parsed;	\
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  204|      0|	    incrementId( ) ; 						\
  |  |  205|      0|	    (Current).id = identifier ; 				\
  |  |  206|      0|	    _current_token = yyr1[yyn] ; 				\
  |  |  207|      0|	    if (ParseState.keepSrcRefs && ParseState.keepParseData) {	\
  |  |  ------------------
  |  |  |  Branch (207:10): [True: 0, False: 0]
  |  |  |  Branch (207:36): [True: 0, False: 0]
  |  |  ------------------
  |  |  208|      0|	        yyltype childs[N];					\
  |  |  209|      0|	        int ii = 0; 						\
  |  |  210|      0|	        for(ii=0; ii<N; ii++){					\
  |  |  ------------------
  |  |  |  Branch (210:20): [True: 0, False: 0]
  |  |  ------------------
  |  |  211|      0|		      childs[ii] = YYRHSLOC (Rhs, (ii+1) ) ; 		\
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  212|      0|	        } 							\
  |  |  213|      0|	        recordParents( identifier, childs, N) ; 		\
  |  |  214|      0|	    }								\
  |  |  215|      0|	} else	{							\
  |  |  216|      0|	  (Current).first_line   = (Current).last_line   =		\
  |  |  217|      0|	    YYRHSLOC (Rhs, 0).last_line;				\
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  218|      0|	  (Current).first_parsed   = (Current).last_parsed   =		\
  |  |  219|      0|	    YYRHSLOC (Rhs, 0).last_parsed;				\
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  220|      0|	  (Current).first_column = YYRHSLOC (Rhs, 0).last_column;	\
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  221|      0|	  (Current).last_column = (Current).first_column - 1;		\
  |  |  222|      0|	  (Current).first_byte = YYRHSLOC (Rhs, 0).last_byte;		\
  |  |  ------------------
  |  |  |  | 1513|      0|#define YYRHSLOC(Rhs, K) ((Rhs)[K])
  |  |  ------------------
  |  |  223|      0|	  (Current).last_byte = (Current).first_byte - 1;		\
  |  |  224|      0|	  (Current).id = NA_INTEGER;                                    \
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  225|      0|	} 								\
  |  |  226|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (226:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2835|       |
 2836|       |  /* Shift the error token.  */
 2837|      0|  YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
 2838|       |
 2839|      0|  yystate = yyn;
 2840|      0|  goto yynewstate;
 2841|       |
 2842|       |
 2843|       |/*-------------------------------------.
 2844|       || yyacceptlab -- YYACCEPT comes here.  |
 2845|       |`-------------------------------------*/
 2846|    572|yyacceptlab:
 2847|    572|  yyresult = 0;
 2848|    572|  goto yyreturnlab;
 2849|       |
 2850|       |
 2851|       |/*-----------------------------------.
 2852|       || yyabortlab -- YYABORT comes here.  |
 2853|       |`-----------------------------------*/
 2854|      0|yyabortlab:
 2855|      0|  yyresult = 1;
 2856|      0|  goto yyreturnlab;
 2857|       |
 2858|       |
 2859|       |/*-----------------------------------------------------------.
 2860|       || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here.  |
 2861|       |`-----------------------------------------------------------*/
 2862|      0|yyexhaustedlab:
 2863|      0|  yyerror (YY_("memory exhausted"));
  ------------------
  |  |  888|      0|#  define YY_(Msgid) Msgid
  ------------------
 2864|      0|  yyresult = 2;
 2865|      0|  goto yyreturnlab;
 2866|       |
 2867|       |
 2868|       |/*----------------------------------------------------------.
 2869|       || yyreturnlab -- parsing is finished, clean up and return.  |
 2870|       |`----------------------------------------------------------*/
 2871|    572|yyreturnlab:
 2872|    572|  if (yychar != YYEMPTY)
  ------------------
  |  | 2018|    572|# define yychar			Rf_yychar
  ------------------
                if (yychar != YYEMPTY)
  ------------------
  |  |  582|    572|#define YYEMPTY -2
  ------------------
  |  Branch (2872:7): [True: 0, False: 572]
  ------------------
 2873|      0|    {
 2874|       |      /* Make sure we have latest lookahead translation.  See comments at
 2875|       |         user semantic actions for why this is necessary.  */
 2876|      0|      yytoken = YYTRANSLATE (yychar);
  ------------------
  |  | 1107|      0|  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
  |  |  ------------------
  |  |  |  | 1101|      0|#define YYMAXUTOK   308
  |  |  ------------------
  |  |  |  Branch (1107:4): [True: 0, False: 0]
  |  |  |  Branch (1107:18): [True: 0, False: 0]
  |  |  ------------------
  |  | 1108|      0|   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
  |  |  ------------------
  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  ------------------
  |  | 1109|      0|   : YYSYMBOL_YYUNDEF)
  ------------------
 2877|      0|      yydestruct ("Cleanup: discarding lookahead",
 2878|      0|                  yytoken, &yylval, &yylloc);
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 2879|      0|    }
 2880|       |  /* Do not reclaim the symbols of the rule whose action triggered
 2881|       |     this YYABORT or YYACCEPT.  */
 2882|    572|  YYPOPSTACK (yylen);
  ------------------
  |  | 2080|    572|#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
  ------------------
 2883|    572|  YY_STACK_PRINT (yyss, yyssp);
 2884|    572|  while (yyssp != yyss)
  ------------------
  |  Branch (2884:10): [True: 0, False: 572]
  ------------------
 2885|      0|    {
 2886|      0|      yydestruct ("Cleanup: popping",
 2887|      0|                  YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp);
  ------------------
  |  | 1166|      0|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
  |  |  ------------------
  |  |  |  |  493|      0|#   define YY_CAST(Type, Val) ((Type) (Val))
  |  |  ------------------
  ------------------
 2888|      0|      YYPOPSTACK (1);
  ------------------
  |  | 2080|      0|#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
  ------------------
 2889|      0|    }
 2890|    572|#ifndef yyoverflow
 2891|    572|  if (yyss != yyssa)
  ------------------
  |  Branch (2891:7): [True: 0, False: 572]
  ------------------
 2892|      0|    YYSTACK_FREE (yyss);
  ------------------
  |  |  996|      0|#  define YYSTACK_FREE YYFREE
  |  |  ------------------
  |  |  |  |  369|      0|#define YYFREE   yystack_free
  |  |  ------------------
  ------------------
 2893|    572|#endif
 2894|    572|  if (yymsg != yymsgbuf)
  ------------------
  |  Branch (2894:7): [True: 0, False: 572]
  ------------------
 2895|      0|    YYSTACK_FREE (yymsg);
  ------------------
  |  |  996|      0|#  define YYSTACK_FREE YYFREE
  |  |  ------------------
  |  |  |  |  369|      0|#define YYFREE   yystack_free
  |  |  ------------------
  ------------------
 2896|    572|  return yyresult;
 2897|      0|}
InitParser:
 3904|      2|{
 3905|      2|    ParseState.sexps = allocVector(VECSXP, 7); /* initialized to R_NilValue */
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
                  ParseState.sexps = allocVector(VECSXP, 7); /* initialized to R_NilValue */
  ------------------
  |  |  131|      2|#define VECSXP	    19	  /* generic vectors */
  ------------------
 3906|      2|    ParseState.data = R_NilValue;
 3907|      2|    INIT_SVS();
  ------------------
  |  |  349|      2|#define INIT_SVS()     PS_SET_SVS(R_NewPreciousMSet(200))
  |  |  ------------------
  |  |  |  |  300|      2|#define PS_SET_SVS(x)       SET_VECTOR_ELT(ParseState.sexps, 6, (x))
  |  |  ------------------
  ------------------
 3908|      2|    R_PreserveObject(ParseState.sexps); /* never released in an R session */
 3909|      2|    R_NullSymbol = install("NULL");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 3910|      2|    R_PlaceholderToken = ScalarString(mkChar("_"));
  ------------------
  |  | 1025|      2|#define ScalarString		Rf_ScalarString
  ------------------
                  R_PlaceholderToken = ScalarString(mkChar("_"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 3911|      2|    MARK_NOT_MUTABLE(R_PlaceholderToken);
 3912|      2|    R_PreserveObject(R_PlaceholderToken);
 3913|      2|    R_PipeBindSymbol = install("=>");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 3914|      2|}
R_InitSrcRefState:
 3924|     48|{
 3925|     48|    if (busy) {
  ------------------
  |  Branch (3925:9): [True: 0, False: 48]
  ------------------
 3926|      0|    	SrcRefState *prev = malloc(sizeof(SrcRefState));
 3927|      0|	if (prev == NULL)
  ------------------
  |  Branch (3927:6): [True: 0, False: 0]
  ------------------
 3928|      0|	    error(_("allocation of source reference state failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("allocation of source reference state failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3929|      0|    	PutSrcRefState(prev);
 3930|      0|	ParseState.yystack = NULL;
 3931|      0|	ParseState.prevState = prev;
 3932|      0|	ParseState.sexps = allocVector(VECSXP, 7);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	ParseState.sexps = allocVector(VECSXP, 7);
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
 3933|      0|	ParseState.data = R_NilValue;
 3934|      0|	INIT_SVS();
  ------------------
  |  |  349|      0|#define INIT_SVS()     PS_SET_SVS(R_NewPreciousMSet(200))
  |  |  ------------------
  |  |  |  |  300|      0|#define PS_SET_SVS(x)       SET_VECTOR_ELT(ParseState.sexps, 6, (x))
  |  |  ------------------
  ------------------
 3935|      0|	R_PreserveObject(ParseState.sexps);
 3936|       |	/* ParseState.sexps released in R_FinalizeSrcRefState */
 3937|      0|    } else
 3938|       |	/* re-use data, text, ids arrays */
 3939|     48|        ParseState.prevState = NULL;
 3940|       |    /* set up context _after_ PutSrcRefState */
 3941|     48|    begincontext(cptr, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
  ------------------
  |  | 1864|     48|# define begincontext		Rf_begincontext
  ------------------
 3942|     48|                 R_NilValue, R_NilValue);
 3943|     48|    cptr->cend = &FinalizeSrcRefStateOnError;
 3944|     48|    cptr->cenddata = NULL;
 3945|     48|    ParseState.keepSrcRefs = false;
 3946|     48|    ParseState.keepParseData = true;
 3947|     48|    ParseState.didAttach = false;
 3948|     48|    PS_SET_SRCFILE(R_NilValue);
  ------------------
  |  |  288|     48|#define PS_SET_SRCFILE(x)   SET_VECTOR_ELT(ParseState.sexps, 1, (x))
  ------------------
 3949|     48|    PS_SET_ORIGINAL(R_NilValue);
  ------------------
  |  |  289|     48|#define PS_SET_ORIGINAL(x)  SET_VECTOR_ELT(ParseState.sexps, 2, (x))
  ------------------
 3950|     48|    ParseState.data_count = 0;
 3951|     48|    ParseState.xxlineno = 1;
 3952|     48|    ParseState.xxcolno = 0;
 3953|     48|    ParseState.xxbyteno = 0;
 3954|     48|    ParseState.xxparseno = 1;
 3955|     48|    busy = true;
 3956|     48|}
R_FinalizeSrcRefState:
 3960|     48|{
 3961|     48|    PS_SET_SRCFILE(R_NilValue);
  ------------------
  |  |  288|     48|#define PS_SET_SRCFILE(x)   SET_VECTOR_ELT(ParseState.sexps, 1, (x))
  ------------------
 3962|     48|    PS_SET_ORIGINAL(R_NilValue);
  ------------------
  |  |  289|     48|#define PS_SET_ORIGINAL(x)  SET_VECTOR_ELT(ParseState.sexps, 2, (x))
  ------------------
 3963|     48|    CLEAR_SVS();
  ------------------
  |  |  352|     48|#define CLEAR_SVS()    R_ReleaseMSet(PS_SVS, 500)
  |  |  ------------------
  |  |  |  |  308|     48|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3964|       |
 3965|       |    /* a stack yyparse() was still using when an error unwound past it */
 3966|     48|    if (ParseState.yystack) {
  ------------------
  |  Branch (3966:9): [True: 0, False: 48]
  ------------------
 3967|      0|	free(ParseState.yystack);
 3968|      0|	ParseState.yystack = NULL;
 3969|      0|    }
 3970|       |
 3971|       |    /* Free the data, text and ids if we are restoring a previous state,
 3972|       |       or if they have grown too large */
 3973|     48|    if (PS_DATA != R_NilValue) {
  ------------------
  |  |  305|     48|#define PS_DATA             ParseState.data
  ------------------
  |  Branch (3973:9): [True: 0, False: 48]
  ------------------
 3974|      0|    	if (ParseState.prevState || DATA_COUNT > MAX_DATA_COUNT) {
  ------------------
  |  |  155|      0|#define DATA_COUNT  (length( PS_DATA ) / DATA_ROWS)
  |  |  ------------------
  |  |  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  ------------------
  |  |               #define DATA_COUNT  (length( PS_DATA ) / DATA_ROWS)
  |  |  ------------------
  |  |  |  |  162|      0|#define DATA_ROWS 8
  |  |  ------------------
  ------------------
                  	if (ParseState.prevState || DATA_COUNT > MAX_DATA_COUNT) {
  ------------------
  |  |  153|      0|#define MAX_DATA_COUNT   65536		/* release it at the end if it is this size or larger*/
  ------------------
  |  Branch (3974:10): [True: 0, False: 0]
  |  Branch (3974:34): [True: 0, False: 0]
  ------------------
 3975|      0|	    PS_SET_DATA(R_NilValue);
  ------------------
  |  |  292|      0|#define PS_SET_DATA(x)      do {                \
  |  |  293|      0|    SEXP __x__ = (x);                           \
  |  |  294|      0|    SET_VECTOR_ELT(ParseState.sexps, 3, __x__); \
  |  |  295|      0|    ParseState.data = __x__;                    \
  |  |  296|      0|} while(0);
  |  |  ------------------
  |  |  |  Branch (296:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3976|      0|	    PS_SET_TEXT(R_NilValue);
  ------------------
  |  |  298|      0|#define PS_SET_TEXT(x)      SET_VECTOR_ELT(ParseState.sexps, 4, (x))
  ------------------
 3977|      0|	} else /* Remove all the strings from the text vector so they don't take up memory, and clean up data */
 3978|      0|	    for (int i=0; i < ParseState.data_count; i++) {
  ------------------
  |  Branch (3978:20): [True: 0, False: 0]
  ------------------
 3979|      0|		SET_STRING_ELT(PS_TEXT, i, R_BlankString);
  ------------------
  |  |  306|      0|#define PS_TEXT             VECTOR_ELT(ParseState.sexps, 4)
  ------------------
 3980|      0|		_PARENT(i) = 0;
  ------------------
  |  |  171|      0|#define _PARENT(i)         INTEGER( PS_DATA )[ DATA_ROWS*(i) + 7 ]
  |  |  ------------------
  |  |  |  |  305|      0|#define PS_DATA             ParseState.data
  |  |  ------------------
  |  |               #define _PARENT(i)         INTEGER( PS_DATA )[ DATA_ROWS*(i) + 7 ]
  |  |  ------------------
  |  |  |  |  162|      0|#define DATA_ROWS 8
  |  |  ------------------
  ------------------
 3981|      0|	    }
 3982|      0|    } 
 3983|     48|    if (PS_IDS != R_NilValue) {
  ------------------
  |  |  307|     48|#define PS_IDS              VECTOR_ELT(ParseState.sexps, 5)
  ------------------
  |  Branch (3983:9): [True: 0, False: 48]
  ------------------
 3984|      0|	if (ParseState.prevState || ID_COUNT > MAX_DATA_COUNT) {
  ------------------
  |  |  156|      0|#define ID_COUNT    ((length( PS_IDS ) / 2) - 1)
  |  |  ------------------
  |  |  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  ------------------
  ------------------
              	if (ParseState.prevState || ID_COUNT > MAX_DATA_COUNT) {
  ------------------
  |  |  153|      0|#define MAX_DATA_COUNT   65536		/* release it at the end if it is this size or larger*/
  ------------------
  |  Branch (3984:6): [True: 0, False: 0]
  |  Branch (3984:30): [True: 0, False: 0]
  ------------------
 3985|      0|	    PS_SET_IDS(R_NilValue);
  ------------------
  |  |  299|      0|#define PS_SET_IDS(x)       SET_VECTOR_ELT(ParseState.sexps, 5, (x))
  ------------------
 3986|      0|        } else {
 3987|       |	    /* Remove the parent records.  'identifier' is the id of the
 3988|       |	       last node, not a count, so include it: when a lexer error
 3989|       |	       unwinds mid-expression that node is a recorded one, and a
 3990|       |	       stale ID_ID would make finalizeData() treat an unrecorded
 3991|       |	       node of the next parse as present in its parse data, in
 3992|       |	       which case the comment-parent walk can loop forever. */
 3993|      0|            if (identifier > ID_COUNT) identifier = ID_COUNT;
  ------------------
  |  |  156|      0|#define ID_COUNT    ((length( PS_IDS ) / 2) - 1)
  |  |  ------------------
  |  |  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  ------------------
  ------------------
                          if (identifier > ID_COUNT) identifier = ID_COUNT;
  ------------------
  |  |  156|      0|#define ID_COUNT    ((length( PS_IDS ) / 2) - 1)
  |  |  ------------------
  |  |  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  ------------------
  ------------------
  |  Branch (3993:17): [True: 0, False: 0]
  ------------------
 3994|      0|            for (int i=0; i <= identifier; i++) {
  ------------------
  |  Branch (3994:27): [True: 0, False: 0]
  ------------------
 3995|      0|		ID_ID(i) = 0;
  ------------------
  |  |  173|      0|#define ID_ID( i )      INTEGER(PS_IDS)[ 2*(i) ]
  |  |  ------------------
  |  |  |  |  307|      0|#define PS_IDS              VECTOR_ELT(ParseState.sexps, 5)
  |  |  ------------------
  ------------------
 3996|      0|	        ID_PARENT(i) = 0;
  ------------------
  |  |  174|      0|#define ID_PARENT( i )  INTEGER(PS_IDS)[ 2*(i) + 1 ]
  |  |  ------------------
  |  |  |  |  307|      0|#define PS_IDS              VECTOR_ELT(ParseState.sexps, 5)
  |  |  ------------------
  ------------------
 3997|      0|	    }
 3998|      0|	}
 3999|      0|    }
 4000|     48|    ParseState.data_count = NA_INTEGER;
  ------------------
  |  |   56|     48|#define NA_INTEGER	R_NaInt
  ------------------
 4001|     48|    if (ParseState.prevState) {
  ------------------
  |  Branch (4001:9): [True: 0, False: 48]
  ------------------
 4002|      0|	R_ReleaseObject(ParseState.sexps);
 4003|      0|        SrcRefState *prev = ParseState.prevState;
 4004|      0|    	UseSrcRefState(prev);
 4005|      0|    	free(prev);
 4006|      0|    } else
 4007|     48|        busy = false;
 4008|     48|}
R_Parse1File:
 4149|    268|{
 4150|    268|    ParseInit();
 4151|    268|    ParseContextInit();
 4152|    268|    GenerateCode = gencode;
 4153|    268|    fp_parse = fp;
 4154|    268|    ptr_getc = file_getc;
 4155|    268|    R_Parse1(status);
 4156|    268|    CLEAR_SVS();
  ------------------
  |  |  352|    268|#define CLEAR_SVS()    R_ReleaseMSet(PS_SVS, 500)
  |  |  ------------------
  |  |  |  |  308|    268|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 4157|    268|    return R_CurrentExpr;
 4158|    268|}
R_ParseConn:
 4322|     12|{
 4323|     12|    GenerateCode = 1;
 4324|     12|    con_parse = con;
 4325|     12|    ptr_getc = con_getc;
 4326|     12|    return R_Parse(n, status, srcfile);
 4327|     12|}
R_ParseVector:
 4331|     32|{
 4332|     32|    SEXP rval;
 4333|     32|    TextBuffer textb;
 4334|     32|    R_TextBufferInit(&textb, text);
 4335|     32|    txtb = &textb;
 4336|     32|    GenerateCode = 1;
 4337|     32|    ptr_getc = text_getc;
 4338|     32|    rval = R_Parse(n, status, srcfile);
 4339|     32|    R_TextBufferFree(&textb);
 4340|     32|    return rval;
 4341|     32|}
Rf_mkTrue:
 4652|  1.98k|{
 4653|  1.98k|    SEXP s = allocVector(LGLSXP, 1);
  ------------------
  |  |  875|  1.98k|#define allocVector		Rf_allocVector
  ------------------
                  SEXP s = allocVector(LGLSXP, 1);
  ------------------
  |  |  121|  1.98k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
 4654|  1.98k|    LOGICAL(s)[0] = 1;
 4655|  1.98k|    return s;
 4656|  1.98k|}
Rf_mkFalse:
 4659|  1.51k|{
 4660|  1.51k|    SEXP s = allocVector(LGLSXP, 1);
  ------------------
  |  |  875|  1.51k|#define allocVector		Rf_allocVector
  ------------------
                  SEXP s = allocVector(LGLSXP, 1);
  ------------------
  |  |  121|  1.51k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
 4661|  1.51k|    LOGICAL(s)[0] = 0;
 4662|  1.51k|    return s;
 4663|  1.51k|}
Rf_isValidName:
 5716|  9.89k|{
 5717|  9.89k|    const char *p = name;
 5718|  9.89k|    int i;
 5719|       |
 5720|  9.89k|    if(mbcslocale) {
  ------------------
  |  Branch (5720:8): [True: 0, False: 9.89k]
  ------------------
 5721|       |	/* the only way to establish which chars are alpha etc is to
 5722|       |	   use the wchar variants */
 5723|      0|	size_t n = strlen(name), used;
 5724|      0|	wchar_t wc;
 5725|       |	/* This is not necessarily correct for stateful MBCS */
 5726|      0|	mbstate_t mb_st;
 5727|      0|	mbs_init(&mb_st);
  ------------------
  |  | 2454|      0|#define mbs_init(x) memset(x, 0, sizeof(mbstate_t))
  ------------------
 5728|       |	/* mbrtowc, not Mbrtowc: an undecodable string is not a valid name,
 5729|       |	   and must not signal an error, as this is reached while deparsing
 5730|       |	   calls for error messages */
 5731|      0|	used = mbrtowc(&wc, p, n, &mb_st);
 5732|      0|	if((int) used <= 0) return 0;
  ------------------
  |  Branch (5732:5): [True: 0, False: 0]
  ------------------
 5733|      0|	p += used; n -= used;
 5734|      0|	if (wc != L'.' && !iswalpha(wc) ) return 0;
  ------------------
  |  Branch (5734:6): [True: 0, False: 0]
  |  Branch (5734:20): [True: 0, False: 0]
  ------------------
 5735|      0|	if (wc == L'.') {
  ------------------
  |  Branch (5735:6): [True: 0, False: 0]
  ------------------
 5736|       |	    /* We don't care about other than ASCII digits */
 5737|      0|	    if(isdigit(0xff & (int)*p)) return 0;
  ------------------
  |  Branch (5737:9): [True: 0, False: 0]
  ------------------
 5738|       |	    /* Mbrtowc(&wc, p, n, NULL); if(iswdigit(wc)) return 0; */
 5739|      0|	}
 5740|      0|	while(n > 0) {
  ------------------
  |  Branch (5740:8): [True: 0, False: 0]
  ------------------
 5741|      0|	    used = mbrtowc(&wc, p, n, &mb_st);
 5742|      0|	    if((int) used <= 0) break;
  ------------------
  |  Branch (5742:9): [True: 0, False: 0]
  ------------------
 5743|      0|	    if (!(iswalnum(wc) || wc == L'.' || wc == L'_')) break;
  ------------------
  |  Branch (5743:12): [True: 0, False: 0]
  |  Branch (5743:28): [True: 0, False: 0]
  |  Branch (5743:42): [True: 0, False: 0]
  ------------------
 5744|      0|	    p += used; n -= used;
 5745|      0|	}
 5746|      0|	if (*p != '\0') return 0;
  ------------------
  |  Branch (5746:6): [True: 0, False: 0]
  ------------------
 5747|  9.89k|    } else {
 5748|  9.89k|	int c = 0xff & *p++;
 5749|  9.89k|	if (c != '.' && !isalpha(c) ) return 0;
  ------------------
  |  Branch (5749:6): [True: 9.89k, False: 0]
  |  Branch (5749:18): [True: 0, False: 9.89k]
  ------------------
 5750|  9.89k|	if (c == '.' && isdigit(0xff & (int)*p)) return 0;
  ------------------
  |  Branch (5750:6): [True: 0, False: 9.89k]
  |  Branch (5750:18): [True: 0, False: 0]
  ------------------
 5751|  44.8k|	while ( c = 0xff & *p++, (isalnum(c) || c == '.' || c == '_') ) ;
  ------------------
  |  Branch (5751:10): [True: 34.9k, False: 9.89k]
  |  Branch (5751:28): [True: 34.7k, False: 10.1k]
  |  Branch (5751:42): [True: 240, False: 9.91k]
  |  Branch (5751:54): [True: 18, False: 9.89k]
  ------------------
 5752|  9.89k|	if (c != '\0') return 0;
  ------------------
  |  Branch (5752:6): [True: 0, False: 9.89k]
  ------------------
 5753|  9.89k|    }
 5754|       |
 5755|  9.89k|    if (strcmp(name, "...") == 0) return 1;
  ------------------
  |  Branch (5755:9): [True: 0, False: 9.89k]
  ------------------
 5756|       |
 5757|   207k|    for (i = 0; keywords[i].name != NULL; i++)
  ------------------
  |  Branch (5757:17): [True: 197k, False: 9.89k]
  ------------------
 5758|   197k|	if (strcmp(keywords[i].name, name) == 0) return 0;
  ------------------
  |  Branch (5758:6): [True: 0, False: 197k]
  ------------------
 5759|       |
 5760|  9.89k|    return 1;
 5761|  9.89k|}
gram.c:setId:
  186|  4.06k|static void setId(yyltype loc){
  187|  4.06k|    record_( 
  188|  4.06k|	    (loc).first_parsed, (loc).first_column, (loc).last_parsed, (loc).last_column, 
  189|  4.06k|	    _current_token, (loc).id, 0 ) ;
  190|  4.06k|}
gram.c:record_:
 6406|  11.1k|	int token, int id, char* text_in ){
 6407|       |	
 6408|  11.1k|	if (!ParseState.keepSrcRefs || !ParseState.keepParseData
  ------------------
  |  Branch (6408:6): [True: 11.1k, False: 0]
  |  Branch (6408:33): [True: 0, False: 0]
  ------------------
 6409|  11.1k|	    || id == NA_INTEGER) return;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (6409:9): [True: 0, False: 0]
  ------------------
 6410|       |	
 6411|       |	// don't care about zero sized things
 6412|      0|	if( !yytext[0] ) return ;
  ------------------
  |  Branch (6412:6): [True: 0, False: 0]
  ------------------
 6413|       |	
 6414|      0|	if (ParseState.data_count == DATA_COUNT)
  ------------------
  |  |  155|      0|#define DATA_COUNT  (length( PS_DATA ) / DATA_ROWS)
  |  |  ------------------
  |  |  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  ------------------
  |  |               #define DATA_COUNT  (length( PS_DATA ) / DATA_ROWS)
  |  |  ------------------
  |  |  |  |  162|      0|#define DATA_ROWS 8
  |  |  ------------------
  ------------------
  |  Branch (6414:6): [True: 0, False: 0]
  ------------------
 6415|      0|	    growData();
 6416|       |	
 6417|      0|	_FIRST_COLUMN( ParseState.data_count ) = first_column; 
  ------------------
  |  |  165|      0|#define _FIRST_COLUMN( i ) INTEGER( PS_DATA )[ DATA_ROWS*(i) + 1 ]
  |  |  ------------------
  |  |  |  |  305|      0|#define PS_DATA             ParseState.data
  |  |  ------------------
  |  |               #define _FIRST_COLUMN( i ) INTEGER( PS_DATA )[ DATA_ROWS*(i) + 1 ]
  |  |  ------------------
  |  |  |  |  162|      0|#define DATA_ROWS 8
  |  |  ------------------
  ------------------
 6418|      0|	_FIRST_PARSED( ParseState.data_count ) = first_parsed;
  ------------------
  |  |  164|      0|#define _FIRST_PARSED( i ) INTEGER( PS_DATA )[ DATA_ROWS*(i)     ]
  |  |  ------------------
  |  |  |  |  305|      0|#define PS_DATA             ParseState.data
  |  |  ------------------
  |  |               #define _FIRST_PARSED( i ) INTEGER( PS_DATA )[ DATA_ROWS*(i)     ]
  |  |  ------------------
  |  |  |  |  162|      0|#define DATA_ROWS 8
  |  |  ------------------
  ------------------
 6419|      0|	_LAST_COLUMN( ParseState.data_count )  = last_column;  
  ------------------
  |  |  167|      0|#define _LAST_COLUMN( i )  INTEGER( PS_DATA )[ DATA_ROWS*(i) + 3 ]
  |  |  ------------------
  |  |  |  |  305|      0|#define PS_DATA             ParseState.data
  |  |  ------------------
  |  |               #define _LAST_COLUMN( i )  INTEGER( PS_DATA )[ DATA_ROWS*(i) + 3 ]
  |  |  ------------------
  |  |  |  |  162|      0|#define DATA_ROWS 8
  |  |  ------------------
  ------------------
 6420|      0|	_LAST_PARSED( ParseState.data_count )  = last_parsed; 
  ------------------
  |  |  166|      0|#define _LAST_PARSED( i )  INTEGER( PS_DATA )[ DATA_ROWS*(i) + 2 ]
  |  |  ------------------
  |  |  |  |  305|      0|#define PS_DATA             ParseState.data
  |  |  ------------------
  |  |               #define _LAST_PARSED( i )  INTEGER( PS_DATA )[ DATA_ROWS*(i) + 2 ]
  |  |  ------------------
  |  |  |  |  162|      0|#define DATA_ROWS 8
  |  |  ------------------
  ------------------
 6421|      0|	_TOKEN( ParseState.data_count )        = token;        
  ------------------
  |  |  169|      0|#define _TOKEN( i )        INTEGER( PS_DATA )[ DATA_ROWS*(i) + 5 ]
  |  |  ------------------
  |  |  |  |  305|      0|#define PS_DATA             ParseState.data
  |  |  ------------------
  |  |               #define _TOKEN( i )        INTEGER( PS_DATA )[ DATA_ROWS*(i) + 5 ]
  |  |  ------------------
  |  |  |  |  162|      0|#define DATA_ROWS 8
  |  |  ------------------
  ------------------
 6422|      0|	_ID( ParseState.data_count )           = id ;          
  ------------------
  |  |  170|      0|#define _ID( i )           INTEGER( PS_DATA )[ DATA_ROWS*(i) + 6 ]
  |  |  ------------------
  |  |  |  |  305|      0|#define PS_DATA             ParseState.data
  |  |  ------------------
  |  |               #define _ID( i )           INTEGER( PS_DATA )[ DATA_ROWS*(i) + 6 ]
  |  |  ------------------
  |  |  |  |  162|      0|#define DATA_ROWS 8
  |  |  ------------------
  ------------------
 6423|      0|	_PARENT(ParseState.data_count)         = 0 ; 
  ------------------
  |  |  171|      0|#define _PARENT(i)         INTEGER( PS_DATA )[ DATA_ROWS*(i) + 7 ]
  |  |  ------------------
  |  |  |  |  305|      0|#define PS_DATA             ParseState.data
  |  |  ------------------
  |  |               #define _PARENT(i)         INTEGER( PS_DATA )[ DATA_ROWS*(i) + 7 ]
  |  |  ------------------
  |  |  |  |  162|      0|#define DATA_ROWS 8
  |  |  ------------------
  ------------------
 6424|      0|	if ( text_in )
  ------------------
  |  Branch (6424:7): [True: 0, False: 0]
  ------------------
 6425|      0|	    SET_STRING_ELT(PS_TEXT, ParseState.data_count, mkChar2(text_in));
  ------------------
  |  |  306|      0|#define PS_TEXT             VECTOR_ELT(ParseState.sexps, 4)
  ------------------
 6426|      0|	else
 6427|      0|	    SET_STRING_ELT(PS_TEXT, ParseState.data_count, mkChar(""));
  ------------------
  |  |  306|      0|#define PS_TEXT             VECTOR_ELT(ParseState.sexps, 4)
  ------------------
              	    SET_STRING_ELT(PS_TEXT, ParseState.data_count, mkChar(""));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 6428|       |	
 6429|      0|	if( id > ID_COUNT )
  ------------------
  |  |  156|      0|#define ID_COUNT    ((length( PS_IDS ) / 2) - 1)
  |  |  ------------------
  |  |  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  ------------------
  ------------------
  |  Branch (6429:6): [True: 0, False: 0]
  ------------------
 6430|      0|	    growID(id) ;
 6431|       |
 6432|      0|	ID_ID( id ) = ParseState.data_count ; 
  ------------------
  |  |  173|      0|#define ID_ID( i )      INTEGER(PS_IDS)[ 2*(i) ]
  |  |  ------------------
  |  |  |  |  307|      0|#define PS_IDS              VECTOR_ELT(ParseState.sexps, 5)
  |  |  ------------------
  ------------------
 6433|       |	
 6434|      0|	ParseState.data_count++ ;
 6435|      0|}
gram.c:incrementId:
 3085|  18.7k|static void incrementId(void){
 3086|  18.7k|	identifier++; 
 3087|  18.7k|}
gram.c:xxvalue:
 3139|    524|{
 3140|    524|    if (k > 2) {
  ------------------
  |  Branch (3140:9): [True: 148, False: 376]
  ------------------
 3141|    148|	if (ParseState.keepSrcRefs) {
  ------------------
  |  Branch (3141:6): [True: 0, False: 148]
  ------------------
 3142|      0|	    SEXP s = PROTECT(makeSrcref(lloc, PS_SRCFILE));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3143|      0|	    AppendToSrcRefs(s);
 3144|      0|	    UNPROTECT(1); /* s */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3145|      0|	}
 3146|    148|	RELEASE_SV(v);
  ------------------
  |  |  351|    148|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    148|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3147|    148|    }
 3148|    524|    R_CurrentExpr = v;
 3149|    524|    return k;
 3150|    524|}
gram.c:xxnullformal:
 3153|     10|{
 3154|     10|    SEXP ans;
 3155|     10|    PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|     10|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     10|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3156|     10|    return ans;
 3157|     10|}
gram.c:xxfirstformal0:
 3160|     74|{
 3161|     74|    SEXP ans;
 3162|     74|    if (GenerateCode)
  ------------------
  |  Branch (3162:9): [True: 74, False: 0]
  ------------------
 3163|     74|	PRESERVE_SV(ans = FirstArg(R_MissingArg, sym));
  ------------------
  |  |  350|     74|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     74|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3164|      0|    else
 3165|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3166|     74|    RELEASE_SV(sym);
  ------------------
  |  |  351|     74|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     74|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3167|     74|    return ans;
 3168|     74|}
gram.c:FirstArg:
 3782|    990|{
 3783|    990|    SEXP tmp;
 3784|    990|    PROTECT(tmp = NewList());
  ------------------
  |  |  357|    990|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3785|    990|    GrowList(tmp, s);
 3786|    990|    SET_TAG(CAR(tmp), tag);
 3787|    990|    UNPROTECT(1); /* tmp */
  ------------------
  |  |  358|    990|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3788|    990|    return tmp;
 3789|    990|}
gram.c:xxaddformal0:
 3183|     14|{
 3184|     14|    SEXP ans;
 3185|     14|    if (GenerateCode) {
  ------------------
  |  Branch (3185:9): [True: 14, False: 0]
  ------------------
 3186|     14|	CheckFormalArgs(formlist, sym, lloc);
 3187|     14|	NextArg(formlist, R_MissingArg, sym);
 3188|     14|	ans = formlist;
 3189|     14|    } else {
 3190|      0|	RELEASE_SV(formlist);
  ------------------
  |  |  351|      0|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3191|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3192|      0|    }
 3193|     14|    RELEASE_SV(sym);
  ------------------
  |  |  351|     14|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     14|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3194|     14|    return ans;
 3195|     14|}
gram.c:CheckFormalArgs:
 4791|     22|{
 4792|     74|    while (formlist != R_NilValue) {
  ------------------
  |  Branch (4792:12): [True: 52, False: 22]
  ------------------
 4793|     52|	if (TAG(formlist) == _new) {
  ------------------
  |  Branch (4793:6): [True: 0, False: 52]
  ------------------
 4794|      0|	    raiseParseError("repeatedFormal", R_NilValue, 
 4795|      0|	                    STRING_VALUE, EncodeChar(PRINTNAME(_new)), lloc,
  ------------------
  |  |  312|      0|#define STRING_VALUE 1
  ------------------
              	                    STRING_VALUE, EncodeChar(PRINTNAME(_new)), lloc,
  ------------------
  |  | 1890|      0|# define EncodeChar             Rf_EncodeChar
  ------------------
 4796|       |	    _("repeated formal argument '%s' (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4797|      0|	}
 4798|     52|	formlist = CDR(formlist);
 4799|     52|    }
 4800|     22|}
gram.c:NextArg:
 3793|    606|{
 3794|    606|    GrowList(l, s);
 3795|    606|    SET_TAG(CAR(l), tag);
 3796|    606|}
gram.c:xxaddformal1:
 3198|      8|{
 3199|      8|    SEXP ans;
 3200|      8|    if (GenerateCode) {
  ------------------
  |  Branch (3200:9): [True: 8, False: 0]
  ------------------
 3201|      8|	CheckFormalArgs(formlist, sym, lloc);
 3202|      8|	NextArg(formlist, expr, sym);
 3203|      8|	ans = formlist;
 3204|      8|    } else {
 3205|      0|	RELEASE_SV(formlist);
  ------------------
  |  |  351|      0|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3206|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3207|      0|    }
 3208|      8|    RELEASE_SV(expr);
  ------------------
  |  |  351|      8|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      8|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3209|      8|    RELEASE_SV(sym);
  ------------------
  |  |  351|      8|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      8|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3210|      8|    return ans;
 3211|      8|}
gram.c:xxexprlist1:
 3229|    102|{
 3230|    102|    SEXP ans;
 3231|    102|    if (GenerateCode) {
  ------------------
  |  Branch (3231:9): [True: 102, False: 0]
  ------------------
 3232|    102|	PRESERVE_SV(ans = NewList());
  ------------------
  |  |  350|    102|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    102|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3233|    102|	if (ParseState.keepSrcRefs) {
  ------------------
  |  Branch (3233:6): [True: 0, False: 102]
  ------------------
 3234|      0|	    setAttrib(ans, R_SrcrefSymbol, PS_SRCREFS);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              	    setAttrib(ans, R_SrcrefSymbol, PS_SRCREFS);
  ------------------
  |  |  302|      0|#define PS_SRCREFS          VECTOR_ELT(ParseState.sexps, 0)
  ------------------
 3235|      0|	    SEXP s = PROTECT(makeSrcref(lloc, PS_SRCFILE));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3236|      0|	    SetSingleSrcRef(s);
 3237|      0|	    UNPROTECT(1); /* s */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3238|      0|	}
 3239|    102|	GrowList(ans, expr);
 3240|    102|    }
 3241|      0|    else
 3242|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3243|    102|    RELEASE_SV(expr);
  ------------------
  |  |  351|    102|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    102|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3244|    102|    return ans;
 3245|    102|}
gram.c:xxexprlist2:
 3248|    296|{
 3249|    296|    SEXP ans;
 3250|    296|    if (GenerateCode) {
  ------------------
  |  Branch (3250:9): [True: 296, False: 0]
  ------------------
 3251|    296|	if (ParseState.keepSrcRefs) {
  ------------------
  |  Branch (3251:6): [True: 0, False: 296]
  ------------------
 3252|      0|	    SEXP s = PROTECT(makeSrcref(lloc, PS_SRCFILE));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3253|      0|	    AppendToSrcRefs(s);
 3254|      0|	    UNPROTECT(1); /* s */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3255|      0|	}
 3256|    296|	GrowList(exprlist, expr);
 3257|    296|	ans = exprlist;
 3258|    296|    } else {
 3259|      0|	RELEASE_SV(exprlist);
  ------------------
  |  |  351|      0|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3260|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3261|      0|    }
 3262|    296|    RELEASE_SV(expr);
  ------------------
  |  |  351|    296|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    296|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3263|    296|    return ans;
 3264|    296|}
gram.c:xxsub0:
 3267|     74|{
 3268|     74|    SEXP ans;
 3269|     74|    if (GenerateCode)
  ------------------
  |  Branch (3269:9): [True: 74, False: 0]
  ------------------
 3270|     74|	PRESERVE_SV(ans = lang2(R_MissingArg,R_NilValue));
  ------------------
  |  |  350|     74|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     74|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3271|      0|    else
 3272|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3273|     74|    return ans;
 3274|     74|}
gram.c:xxsub1:
 3277|  1.21k|{
 3278|  1.21k|    SEXP ans;
 3279|  1.21k|    if (GenerateCode)
  ------------------
  |  Branch (3279:9): [True: 1.21k, False: 0]
  ------------------
 3280|  1.21k|	PRESERVE_SV(ans = TagArg(expr, R_NilValue, lloc));
  ------------------
  |  |  350|  1.21k|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|  1.21k|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3281|      0|    else
 3282|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3283|  1.21k|    RELEASE_SV(expr);
  ------------------
  |  |  351|  1.21k|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|  1.21k|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3284|  1.21k|    return ans;
 3285|  1.21k|}
gram.c:TagArg:
 3739|  1.42k|{
 3740|  1.42k|    switch (TYPEOF(tag)) {
 3741|      4|    case STRSXP:
  ------------------
  |  |  126|      4|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (3741:5): [True: 4, False: 1.42k]
  ------------------
 3742|      4|	tag = installTrChar(STRING_ELT(tag, 0));
  ------------------
  |  |  937|      4|#define installTrChar		Rf_installTrChar
  ------------------
 3743|  1.21k|    case NILSXP:
  ------------------
  |  |  111|  1.21k|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (3743:5): [True: 1.21k, False: 212]
  ------------------
 3744|  1.42k|    case SYMSXP:
  ------------------
  |  |  112|  1.42k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (3744:5): [True: 208, False: 1.21k]
  ------------------
 3745|  1.42k|	return lang2(arg, tag);
  ------------------
  |  |  979|  1.42k|#define lang2			Rf_lang2
  ------------------
 3746|      0|    default:
  ------------------
  |  Branch (3746:5): [True: 0, False: 1.42k]
  ------------------
 3747|      0|	raiseParseError("badTagType", R_NilValue, 
 3748|      0|	                NO_VALUE, NULL, lloc, 
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 3749|       |	                _("incorrect tag type (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3750|      0|	                return R_NilValue/* -Wall */;
 3751|  1.42k|    }
 3752|  1.42k|}
gram.c:xxsymsub1:
 3299|    212|{
 3300|    212|    SEXP ans;
 3301|    212|    if (GenerateCode)
  ------------------
  |  Branch (3301:9): [True: 212, False: 0]
  ------------------
 3302|    212|	PRESERVE_SV(ans = TagArg(expr, sym, lloc));
  ------------------
  |  |  350|    212|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    212|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3303|      0|    else
 3304|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3305|    212|    RELEASE_SV(expr);
  ------------------
  |  |  351|    212|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    212|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3306|    212|    RELEASE_SV(sym);
  ------------------
  |  |  351|    212|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    212|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3307|    212|    return ans;
 3308|    212|}
gram.c:xxsublist1:
 3335|    916|{
 3336|    916|    SEXP ans;
 3337|    916|    if (GenerateCode)
  ------------------
  |  Branch (3337:9): [True: 916, False: 0]
  ------------------
 3338|    916|	PRESERVE_SV(ans = FirstArg(CAR(sub),CADR(sub)));
  ------------------
  |  |  350|    916|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    916|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3339|      0|    else
 3340|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3341|    916|    RELEASE_SV(sub);
  ------------------
  |  |  351|    916|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    916|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3342|    916|    return ans;
 3343|    916|}
gram.c:xxsublist2:
 3346|    584|{
 3347|    584|    SEXP ans;
 3348|    584|    if (GenerateCode) {
  ------------------
  |  Branch (3348:9): [True: 584, False: 0]
  ------------------
 3349|    584|	NextArg(sublist, CAR(sub), CADR(sub));
 3350|    584|	ans = sublist;
 3351|    584|    } else {
 3352|      0|	RELEASE_SV(sublist);
  ------------------
  |  |  351|      0|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3353|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3354|      0|    }
 3355|    584|    RELEASE_SV(sub);
  ------------------
  |  |  351|    584|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    584|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3356|    584|    return ans;
 3357|    584|}
gram.c:xxcond:
 3360|      2|{
 3361|      2|    EatLines = 1;
 3362|      2|    return expr;
 3363|      2|}
gram.c:xxifcond:
 3366|     68|{
 3367|     68|    EatLines = 1;
 3368|     68|    return expr;
 3369|     68|}
gram.c:xxif:
 3372|     52|{
 3373|     52|    SEXP ans;
 3374|     52|    if (GenerateCode)
  ------------------
  |  Branch (3374:9): [True: 52, False: 0]
  ------------------
 3375|     52|	PRESERVE_SV(ans = lang3(ifsym, cond, expr));
  ------------------
  |  |  350|     52|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     52|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3376|      0|    else
 3377|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3378|     52|    RELEASE_SV(expr);
  ------------------
  |  |  351|     52|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     52|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3379|     52|    RELEASE_SV(cond);
  ------------------
  |  |  351|     52|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     52|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3380|     52|    return ans;
 3381|     52|}
gram.c:xxifelse:
 3384|     16|{
 3385|     16|    SEXP ans;
 3386|     16|    if (GenerateCode)
  ------------------
  |  Branch (3386:9): [True: 16, False: 0]
  ------------------
 3387|     16|	PRESERVE_SV(ans = lang4(ifsym, cond, ifexpr, elseexpr));
  ------------------
  |  |  350|     16|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     16|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3388|      0|    else
 3389|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3390|     16|    RELEASE_SV(elseexpr);
  ------------------
  |  |  351|     16|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     16|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3391|     16|    RELEASE_SV(ifexpr);
  ------------------
  |  |  351|     16|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     16|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3392|     16|    RELEASE_SV(cond);
  ------------------
  |  |  351|     16|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     16|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3393|     16|    return ans;
 3394|     16|}
gram.c:xxforcond:
 3397|      8|{
 3398|      8|    SEXP ans;
 3399|      8|    EatLines = 1;
 3400|      8|    if (GenerateCode)
  ------------------
  |  Branch (3400:9): [True: 8, False: 0]
  ------------------
 3401|      8|	PRESERVE_SV(ans = LCONS(sym, expr));
  ------------------
  |  |  350|      8|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      8|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3402|      0|    else
 3403|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3404|      8|    RELEASE_SV(expr);
  ------------------
  |  |  351|      8|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      8|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3405|      8|    RELEASE_SV(sym);
  ------------------
  |  |  351|      8|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      8|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3406|      8|    return ans;
 3407|      8|}
gram.c:xxfor:
 3410|      8|{
 3411|      8|    SEXP ans;
 3412|      8|    if (GenerateCode)
  ------------------
  |  Branch (3412:9): [True: 8, False: 0]
  ------------------
 3413|      8|	PRESERVE_SV(ans = lang4(forsym, CAR(forcond), CDR(forcond), body));
  ------------------
  |  |  350|      8|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      8|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3414|      0|    else
 3415|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3416|      8|    RELEASE_SV(body);
  ------------------
  |  |  351|      8|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      8|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3417|      8|    RELEASE_SV(forcond);
  ------------------
  |  |  351|      8|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      8|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3418|      8|    return ans;
 3419|      8|}
gram.c:xxwhile:
 3422|      2|{
 3423|      2|    SEXP ans;
 3424|      2|    if (GenerateCode)
  ------------------
  |  Branch (3424:9): [True: 2, False: 0]
  ------------------
 3425|      2|	PRESERVE_SV(ans = lang3(whilesym, cond, body));
  ------------------
  |  |  350|      2|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      2|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3426|      0|    else
 3427|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3428|      2|    RELEASE_SV(body);
  ------------------
  |  |  351|      2|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      2|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3429|      2|    RELEASE_SV(cond);
  ------------------
  |  |  351|      2|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      2|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3430|      2|    return ans;
 3431|      2|}
gram.c:xxfuncall:
 3454|    840|{
 3455|    840|    SEXP ans, sav_expr = expr;
 3456|    840|    if (GenerateCode) {
  ------------------
  |  Branch (3456:9): [True: 840, False: 0]
  ------------------
 3457|    840|	if (isString(expr) && expr != R_PlaceholderToken)
  ------------------
  |  |  966|    840|#define isString		Rf_isString
  ------------------
  |  Branch (3457:6): [True: 0, False: 840]
  |  Branch (3457:24): [True: 0, False: 0]
  ------------------
 3458|      0|	    expr = installTrChar(STRING_ELT(expr, 0));
  ------------------
  |  |  937|      0|#define installTrChar		Rf_installTrChar
  ------------------
 3459|    840|	PROTECT(expr);
  ------------------
  |  |  357|    840|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3460|    840|	if (length(CDR(args)) == 1 && CADR(args) == R_MissingArg && TAG(CDR(args)) == R_NilValue )
  ------------------
  |  |  987|    840|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (3460:6): [True: 544, False: 296]
  |  Branch (3460:32): [True: 70, False: 474]
  |  Branch (3460:62): [True: 70, False: 0]
  ------------------
 3461|     70|	    ans = lang1(expr);
  ------------------
  |  |  978|     70|#define lang1			Rf_lang1
  ------------------
 3462|    770|	else
 3463|    770|	    ans = LCONS(expr, CDR(args));
  ------------------
  |  |  310|    770|#define LCONS(a, b)	Rf_lcons((a), (b))		/* language lists */
  ------------------
 3464|    840|	UNPROTECT(1); /* expr */
  ------------------
  |  |  358|    840|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3465|    840|	PRESERVE_SV(ans);
  ------------------
  |  |  350|    840|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    840|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3466|    840|    } else
 3467|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3468|       |
 3469|    840|    RELEASE_SV(args);
  ------------------
  |  |  351|    840|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    840|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3470|    840|    RELEASE_SV(sav_expr);
  ------------------
  |  |  351|    840|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    840|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3471|    840|    return ans;
 3472|    840|}
gram.c:xxdefun:
 3499|     84|{
 3500|     84|    SEXP ans, srcref;
 3501|       |
 3502|     84|    if (GenerateCode) {
  ------------------
  |  Branch (3502:9): [True: 84, False: 0]
  ------------------
 3503|     84|    	if (ParseState.keepSrcRefs) {
  ------------------
  |  Branch (3503:10): [True: 0, False: 84]
  ------------------
 3504|      0|	    srcref = makeSrcref(lloc, PS_SRCFILE);
  ------------------
  |  |  303|      0|#define PS_SRCFILE          VECTOR_ELT(ParseState.sexps, 1)
  ------------------
 3505|      0|    	    ParseState.didAttach = true;
 3506|      0|    	} else
 3507|     84|    	    srcref = R_NilValue;
 3508|     84|	PRESERVE_SV(ans = lang4(fname, CDR(formals), body, PROTECT(srcref)));
  ------------------
  |  |  350|     84|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     84|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3509|     84|	UNPROTECT(1);
  ------------------
  |  |  358|     84|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3510|     84|    } else
 3511|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3512|     84|    RELEASE_SV(body);
  ------------------
  |  |  351|     84|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     84|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3513|     84|    RELEASE_SV(formals);
  ------------------
  |  |  351|     84|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     84|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3514|     84|    return ans;
 3515|     84|}
gram.c:xxunary:
 3518|     26|{
 3519|     26|    SEXP ans;
 3520|     26|    if (GenerateCode)
  ------------------
  |  Branch (3520:9): [True: 26, False: 0]
  ------------------
 3521|     26|	PRESERVE_SV(ans = lang2(op, arg));
  ------------------
  |  |  350|     26|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     26|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3522|      0|    else
 3523|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3524|     26|    RELEASE_SV(arg);
  ------------------
  |  |  351|     26|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     26|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3525|     26|    return ans;
 3526|     26|}
gram.c:xxbinary:
 3529|    456|{
 3530|    456|    SEXP ans;
 3531|    456|    if (GenerateCode)
  ------------------
  |  Branch (3531:9): [True: 456, False: 0]
  ------------------
 3532|    456|	PRESERVE_SV(ans = lang3(n1, n2, n3));
  ------------------
  |  |  350|    456|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    456|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3533|      0|    else
 3534|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3535|    456|    RELEASE_SV(n2);
  ------------------
  |  |  351|    456|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    456|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3536|    456|    RELEASE_SV(n3);
  ------------------
  |  |  351|    456|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    456|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3537|    456|    return ans;
 3538|    456|}
gram.c:checkForPlaceholder:
 6773|    148|{
 6774|    148|    if (! HavePlaceholder)
  ------------------
  |  Branch (6774:9): [True: 148, False: 0]
  ------------------
 6775|    148|    	return false;
 6776|      0|    else if (arg == placeholder)
  ------------------
  |  Branch (6776:14): [True: 0, False: 0]
  ------------------
 6777|      0|	return true;
 6778|      0|    else if (TYPEOF(arg) == LANGSXP)
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (6778:14): [True: 0, False: 0]
  ------------------
 6779|      0|	for (SEXP cur = arg; cur != R_NilValue; cur = CDR(cur))
  ------------------
  |  Branch (6779:23): [True: 0, False: 0]
  ------------------
 6780|      0|	    if (checkForPlaceholder(placeholder, CAR(cur)))
  ------------------
  |  Branch (6780:10): [True: 0, False: 0]
  ------------------
 6781|      0|		return true;
 6782|      0|    return false;
 6783|    148|}
gram.c:xxparen:
 3677|      6|{
 3678|      6|    SEXP ans;
 3679|      6|    if (GenerateCode)
  ------------------
  |  Branch (3679:9): [True: 6, False: 0]
  ------------------
 3680|      6|	PRESERVE_SV(ans = lang2(n1, n2));
  ------------------
  |  |  350|      6|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      6|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3681|      0|    else
 3682|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3683|      6|    RELEASE_SV(n2);
  ------------------
  |  |  351|      6|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      6|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3684|      6|    return ans;
 3685|      6|}
gram.c:xxsubscript:
 3693|     76|{
 3694|     76|    SEXP ans;
 3695|     76|    if (GenerateCode)
  ------------------
  |  Branch (3695:9): [True: 76, False: 0]
  ------------------
 3696|     76|	PRESERVE_SV(ans = LCONS(a2, CONS(a1, CDR(a3))));
  ------------------
  |  |  350|     76|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     76|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3697|      0|    else
 3698|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3699|     76|    RELEASE_SV(a3);
  ------------------
  |  |  351|     76|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     76|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3700|     76|    RELEASE_SV(a1);
  ------------------
  |  |  351|     76|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     76|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3701|     76|    return ans;
 3702|     76|}
gram.c:xxexprlist:
 3705|    102|{
 3706|    102|    SEXP ans;
 3707|    102|    SEXP prevSrcrefs;
 3708|       |
 3709|    102|    EatLines = 0;
 3710|    102|    if (GenerateCode) {
  ------------------
  |  Branch (3710:9): [True: 102, False: 0]
  ------------------
 3711|    102|	SET_TYPEOF(a2, LANGSXP);
  ------------------
  |  |  117|    102|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
 3712|    102|	SETCAR(a2, a1);
 3713|    102|	if (ParseState.keepSrcRefs) {
  ------------------
  |  Branch (3713:6): [True: 0, False: 102]
  ------------------
 3714|      0|	    PROTECT(prevSrcrefs = getAttrib(a2, R_SrcrefSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3715|      0|	    SEXP s = PROTECT(makeSrcref(lloc, PS_SRCFILE));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3716|      0|	    PrependToSrcRefs(s);
 3717|      0|	    attachSrcrefs(a2);
 3718|      0|	    UNPROTECT(2); /* prevSrcrefs, s */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3719|       |#ifndef SWITCH_TO_REFCNT
 3720|       |	    /* SrcRefs got NAMED by being an attribute, preventively
 3721|       |	       getAttrib(), but it has not in fact been referenced. Set NAMED
 3722|       |	       to 0 to avoid overhead in further setAttrib calls due to cycle
 3723|       |	       detection. */
 3724|       |	    SET_NAMED(prevSrcrefs, 0);
 3725|       |#endif
 3726|      0|	    PS_SET_SRCREFS(prevSrcrefs);
  ------------------
  |  |  287|      0|#define PS_SET_SRCREFS(x)   SET_VECTOR_ELT(ParseState.sexps, 0, (x))
  ------------------
 3727|      0|	}
 3728|    102|	PRESERVE_SV(ans = a2);
  ------------------
  |  |  350|    102|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    102|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3729|    102|    }
 3730|      0|    else
 3731|      0|	PRESERVE_SV(ans = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3732|    102|    RELEASE_SV(a2);
  ------------------
  |  |  351|    102|#define RELEASE_SV(x)  R_ReleaseFromMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    102|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 3733|    102|    return ans;
 3734|    102|}
gram.c:ParseInit:
 4042|    572|{
 4043|    572|    contextp = contextstack;
 4044|    572|    *contextp = ' ';
 4045|    572|    SavedToken = 0;
 4046|    572|    SavedLval = R_NilValue;
 4047|    572|    EatLines = 0;
 4048|    572|    EndOfFile = 0;
 4049|    572|    xxcharcount = 0;
 4050|    572|    npush = 0;
 4051|    572|    HavePipeBind = FALSE;
 4052|    572|}
gram.c:ParseContextInit:
 4061|    312|{
 4062|    312|    R_ParseContextLast = 0;
 4063|    312|    R_ParseContext[0] = '\0';
 4064|       |    
 4065|       |    /* starts the identifier counter*/
 4066|    312|    initId();
 4067|    312|    initData();
 4068|    312|}
gram.c:initId:
 3089|    312|static void initId(void){
 3090|    312|	identifier = 0 ;
 3091|    312|}
gram.c:initData:
 4055|    312|{
 4056|    312|    ParseState.data_count = 0 ;
 4057|    312|}
gram.c:file_getc:
 4142|  25.2k|{
 4143|  25.2k|    return R_fgetc(fp_parse);
 4144|  25.2k|}
gram.c:R_Parse1:
 4089|    572|{
 4090|    572|    Status = 1; /* safety */
 4091|    572|    switch(yyparse()) {
  ------------------
  |  | 2021|    572|# define yyparse		Rf_yyparse
  ------------------
  |  Branch (4091:12): [True: 572, False: 0]
  ------------------
 4092|    572|    case 0:
  ------------------
  |  Branch (4092:5): [True: 572, False: 0]
  ------------------
 4093|    572|	switch(Status) {
  ------------------
  |  Branch (4093:9): [True: 572, False: 0]
  ------------------
 4094|     48|	case 0:                     /* End of file */
  ------------------
  |  Branch (4094:2): [True: 48, False: 524]
  ------------------
 4095|     48|	    *status = PARSE_EOF;
 4096|     48|	    if (EndOfFile == 2) *status = PARSE_INCOMPLETE;
  ------------------
  |  Branch (4096:10): [True: 0, False: 48]
  ------------------
 4097|     48|	    break;
 4098|      0|	case 1:                     /* Error (currently unreachable) */
  ------------------
  |  Branch (4098:2): [True: 0, False: 572]
  ------------------
 4099|      0|	    *status = PARSE_ERROR;
 4100|      0|	    if (EndOfFile) *status = PARSE_INCOMPLETE;
  ------------------
  |  Branch (4100:10): [True: 0, False: 0]
  ------------------
 4101|      0|	    break;
 4102|    376|	case 2:                     /* Empty Line */
  ------------------
  |  Branch (4102:2): [True: 376, False: 196]
  ------------------
 4103|    376|	    *status = PARSE_NULL;
 4104|    376|	    break;
 4105|    148|	case 3:                     /* Valid expr '\n' terminated */
  ------------------
  |  Branch (4105:2): [True: 148, False: 424]
  ------------------
 4106|    148|	case 4:                     /* Valid expr ';' terminated */
  ------------------
  |  Branch (4106:2): [True: 0, False: 572]
  ------------------
 4107|    148|	    if (checkForPlaceholder(R_PlaceholderToken, R_CurrentExpr)) {
  ------------------
  |  Branch (4107:10): [True: 0, False: 148]
  ------------------
 4108|      0|	        YYLTYPE lloc;
  ------------------
  |  |  192|      0|# define YYLTYPE yyltype
  ------------------
 4109|      0|	        lloc.first_line = ParseState.xxlineno;
 4110|      0|		lloc.first_column = ParseState.xxcolno;
 4111|      0|	        if (Status == 3) lloc.first_line--;
  ------------------
  |  Branch (4111:14): [True: 0, False: 0]
  ------------------
 4112|      0|		raiseParseError("invalidPlaceholder", R_CurrentExpr,
 4113|      0|		                NO_VALUE, NULL, &lloc,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 4114|      0|			  _("invalid use of pipe placeholder (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4115|      0|            }
 4116|    148|	    if (checkForPipeBind(R_CurrentExpr)) {
  ------------------
  |  Branch (4116:10): [True: 0, False: 148]
  ------------------
 4117|      0|	        YYLTYPE lloc;
  ------------------
  |  |  192|      0|# define YYLTYPE yyltype
  ------------------
 4118|      0|	        lloc.first_line = ParseState.xxlineno;
 4119|      0|		lloc.first_column = ParseState.xxcolno;
 4120|      0|	        if (Status == 3) lloc.first_line--;
  ------------------
  |  Branch (4120:14): [True: 0, False: 0]
  ------------------
 4121|      0|		raiseParseError("invalidPipeBind", R_CurrentExpr, 
 4122|      0|		                NO_VALUE, NULL, &lloc,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 4123|      0|			  _("invalid use of pipe bind symbol (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4124|      0|	    }
 4125|    148|	    *status = PARSE_OK;
 4126|    148|	    break;
 4127|    572|	}
 4128|    572|	break;
 4129|    572|    case 1:                     /* Syntax error / incomplete */
  ------------------
  |  Branch (4129:5): [True: 0, False: 572]
  ------------------
 4130|      0|	*status = PARSE_ERROR;
 4131|      0|	if (EndOfFile) *status = PARSE_INCOMPLETE;
  ------------------
  |  Branch (4131:6): [True: 0, False: 0]
  ------------------
 4132|      0|	break;
 4133|      0|    case 2:
  ------------------
  |  Branch (4133:5): [True: 0, False: 572]
  ------------------
 4134|      0|	error(_("out of memory while parsing"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("out of memory while parsing"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4135|    572|    }
 4136|    572|    return R_CurrentExpr;
 4137|    572|}
gram.c:checkForPipeBind:
 4071|    148|{
 4072|    148|    if (! HavePipeBind)
  ------------------
  |  Branch (4072:9): [True: 148, False: 0]
  ------------------
 4073|    148|    	return false;
 4074|      0|    else if (arg == R_PipeBindSymbol)
  ------------------
  |  Branch (4074:14): [True: 0, False: 0]
  ------------------
 4075|      0|	return true;
 4076|      0|    else if (TYPEOF(arg) == LANGSXP)
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (4076:14): [True: 0, False: 0]
  ------------------
 4077|      0|	for (SEXP cur = arg; cur != R_NilValue; cur = CDR(cur))
  ------------------
  |  Branch (4077:23): [True: 0, False: 0]
  ------------------
 4078|      0|	    if (checkForPipeBind(CAR(cur)))
  ------------------
  |  Branch (4078:10): [True: 0, False: 0]
  ------------------
 4079|      0|		return true;
 4080|      0|    return false;
 4081|    148|}
gram.c:R_Parse:
 4228|     44|{
 4229|     44|    int i;
 4230|     44|    SEXP t, rval;
 4231|     44|    RCNTXT cntxt;
 4232|       |
 4233|     44|    R_InitSrcRefState(&cntxt);
 4234|     44|    ParseContextInit();
 4235|       |
 4236|     44|    PS_SET_SRCFILE(srcfile);
  ------------------
  |  |  288|     44|#define PS_SET_SRCFILE(x)   SET_VECTOR_ELT(ParseState.sexps, 1, (x))
  ------------------
 4237|     44|    PS_SET_ORIGINAL(srcfile);
  ------------------
  |  |  289|     44|#define PS_SET_ORIGINAL(x)  SET_VECTOR_ELT(ParseState.sexps, 2, (x))
  ------------------
 4238|       |    
 4239|     44|    if (isEnvironment(srcfile)) {
  ------------------
  |  |  944|     44|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (4239:9): [True: 0, False: 44]
  ------------------
 4240|      0|    	ParseState.keepSrcRefs = true;
 4241|      0|	ParseState.keepParseData =
 4242|      0|	    asRbool(GetOption1(install("keep.parse.data")), R_NilValue);
  ------------------
  |  | 1861|      0|# define asRbool		Rf_asRbool
  ------------------
              	    asRbool(GetOption1(install("keep.parse.data")), R_NilValue);
  ------------------
  |  |  928|      0|#define GetOption1		Rf_GetOption1
  ------------------
              	    asRbool(GetOption1(install("keep.parse.data")), R_NilValue);
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 4243|      0|	PS_SET_SRCREFS(R_NilValue);
  ------------------
  |  |  287|      0|#define PS_SET_SRCREFS(x)   SET_VECTOR_ELT(ParseState.sexps, 0, (x))
  ------------------
 4244|      0|    }
 4245|       |    
 4246|     44|    PROTECT(t = NewList());
  ------------------
  |  |  357|     44|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4247|    304|    for(i = 0; ; ) {
 4248|    304|	if(n >= 0 && i >= n) break;
  ------------------
  |  Branch (4248:5): [True: 0, False: 304]
  |  Branch (4248:15): [True: 0, False: 0]
  ------------------
 4249|    304|	ParseInit();
 4250|    304|	rval = R_Parse1(status);
 4251|    304|	switch(*status) {
  ------------------
  |  Branch (4251:9): [True: 304, False: 0]
  ------------------
 4252|    216|	case PARSE_NULL:
  ------------------
  |  Branch (4252:2): [True: 216, False: 88]
  ------------------
 4253|    216|	    break;
 4254|     44|	case PARSE_OK:
  ------------------
  |  Branch (4254:2): [True: 44, False: 260]
  ------------------
 4255|     44|	    PROTECT(rval);
  ------------------
  |  |  357|     44|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4256|     44|	    GrowList(t, rval);
 4257|     44|	    UNPROTECT(1); /* rval */
  ------------------
  |  |  358|     44|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4258|     44|	    i++;
 4259|     44|	    break;
 4260|      0|	case PARSE_INCOMPLETE:
  ------------------
  |  Branch (4260:2): [True: 0, False: 304]
  ------------------
 4261|      0|	case PARSE_ERROR:
  ------------------
  |  Branch (4261:2): [True: 0, False: 304]
  ------------------
 4262|      0|	    UNPROTECT(1); /* t */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4263|      0|	    if (ParseState.keepSrcRefs && ParseState.keepParseData)
  ------------------
  |  Branch (4263:10): [True: 0, False: 0]
  |  Branch (4263:36): [True: 0, False: 0]
  ------------------
 4264|      0|	        finalizeData();
 4265|      0|	    endcontext(&cntxt);
  ------------------
  |  | 1895|      0|# define endcontext		Rf_endcontext
  ------------------
 4266|      0|	    R_FinalizeSrcRefState();	    
 4267|      0|	    return R_NilValue;
 4268|      0|	    break;
 4269|     44|	case PARSE_EOF:
  ------------------
  |  Branch (4269:2): [True: 44, False: 260]
  ------------------
 4270|     44|	    goto finish;
 4271|      0|	    break;
 4272|    304|	}
 4273|    304|    }
 4274|       |
 4275|     44|finish:
 4276|       |
 4277|     44|    t = CDR(t);
 4278|     44|    PROTECT(rval = allocVector(EXPRSXP, length(t)));
  ------------------
  |  |  357|     44|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4279|     88|    for (n = 0 ; n < LENGTH(rval) ; n++, t = CDR(t))
  ------------------
  |  Branch (4279:18): [True: 44, False: 44]
  ------------------
 4280|     44|	SET_VECTOR_ELT(rval, n, CAR(t));
 4281|     44|    if (ParseState.keepSrcRefs) {
  ------------------
  |  Branch (4281:9): [True: 0, False: 44]
  ------------------
 4282|      0|	if (ParseState.keepParseData)
  ------------------
  |  Branch (4282:6): [True: 0, False: 0]
  ------------------
 4283|      0|	    finalizeData();
 4284|      0|	attachSrcrefs(rval);
 4285|      0|    }
 4286|     44|    UNPROTECT(2); /* t, rval */
  ------------------
  |  |  358|     44|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4287|     44|    PROTECT(rval);
  ------------------
  |  |  357|     44|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4288|     44|    endcontext(&cntxt);
  ------------------
  |  | 1895|     44|# define endcontext		Rf_endcontext
  ------------------
 4289|     44|    R_FinalizeSrcRefState();
 4290|     44|    UNPROTECT(1); /* rval */
  ------------------
  |  |  358|     44|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4291|     44|    *status = PARSE_OK;
 4292|     44|    return rval;
 4293|     44|}
gram.c:con_getc:
 4310|  12.7k|{
 4311|  12.7k|    int c;
 4312|  12.7k|    static int last=-1000;
 4313|       |
 4314|  12.7k|    c = Rconn_fgetc(con_parse);
 4315|  12.7k|    if (c == EOF && last != '\n') c = '\n';
  ------------------
  |  Branch (4315:9): [True: 12, False: 12.6k]
  |  Branch (4315:21): [True: 0, False: 12]
  ------------------
 4316|  12.7k|    return (last = c);
 4317|  12.7k|}
gram.c:text_getc:
 4223|  6.17k|{
 4224|  6.17k|    return R_TextBufferGetc(txtb);
 4225|  6.17k|}
gram.c:NewList:
 3765|  1.13k|{
 3766|  1.13k|    SEXP s = CONS(R_NilValue, R_NilValue);
  ------------------
  |  |  309|  1.13k|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3767|  1.13k|    SETCAR(s, s);
 3768|  1.13k|    return s;
 3769|  1.13k|}
gram.c:GrowList:
 3773|  2.03k|{
 3774|  2.03k|    SEXP tmp;
 3775|  2.03k|    tmp = CONS(s, R_NilValue);
  ------------------
  |  |  309|  2.03k|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3776|  2.03k|    SETCDR(CAR(l), tmp);
 3777|  2.03k|    SETCAR(l, tmp);
 3778|  2.03k|}
gram.c:yylex:
 6170|  7.63k|{
 6171|  7.63k|    int tok;
 6172|       |
 6173|  7.82k| again:
 6174|       |
 6175|  7.82k|    tok = token_();
 6176|       |
 6177|       |    /* Newlines must be handled in a context */
 6178|       |    /* sensitive way.  The following block of */
 6179|       |    /* deals directly with newlines in the */
 6180|       |    /* body of "if" statements. */
 6181|       |
 6182|  7.82k|    if (tok == '\n') {
  ------------------
  |  Branch (6182:9): [True: 1.05k, False: 6.76k]
  ------------------
 6183|       |
 6184|  1.05k|	if (EatLines || *contextp == '[' || *contextp == '(')
  ------------------
  |  Branch (6184:6): [True: 196, False: 862]
  |  Branch (6184:18): [True: 0, False: 862]
  |  Branch (6184:38): [True: 0, False: 862]
  ------------------
 6185|    196|	    goto again;
 6186|       |
 6187|       |	/* The essence of this is that in the body of */
 6188|       |	/* an "if", any newline must be checked to */
 6189|       |	/* see if it is followed by an "else". */
 6190|       |	/* such newlines are discarded. */
 6191|       |
 6192|    862|	if (*contextp == 'i') {
  ------------------
  |  Branch (6192:6): [True: 38, False: 824]
  ------------------
 6193|       |
 6194|       |	    /* Find the next non-newline token */
 6195|       |
 6196|     82|	    while(tok == '\n')
  ------------------
  |  Branch (6196:12): [True: 44, False: 38]
  ------------------
 6197|     44|		tok = token_();
 6198|       |
 6199|       |	    /* If we encounter "}", ")" or "]" then */
 6200|       |	    /* we know that all immediately preceding */
 6201|       |	    /* "if" bodies have been terminated. */
 6202|       |	    /* The corresponding "i" values are */
 6203|       |	    /* popped off the context stack. */
 6204|       |
 6205|     38|	    if (tok == RBRACE || tok == ')' || tok == ']' ) {
  ------------------
  |  |  238|     76|#define RBRACE	'}'
  ------------------
  |  Branch (6205:10): [True: 12, False: 26]
  |  Branch (6205:27): [True: 0, False: 26]
  |  Branch (6205:41): [True: 0, False: 26]
  ------------------
 6206|     26|		while (*contextp == 'i')
  ------------------
  |  Branch (6206:10): [True: 14, False: 12]
  ------------------
 6207|     14|		    ifpop();
 6208|     12|		*contextp-- = 0;
 6209|     12|		setlastloc();
 6210|     12|		return tok;
 6211|     12|	    }
 6212|       |
 6213|       |	    /* When a "," is encountered, it terminates */
 6214|       |	    /* just the immediately preceding "if" body */
 6215|       |	    /* so we pop just a single "i" of the */
 6216|       |	    /* context stack. */
 6217|       |
 6218|     26|	    if (tok == ',') {
  ------------------
  |  Branch (6218:10): [True: 0, False: 26]
  ------------------
 6219|      0|		ifpop();
 6220|      0|		setlastloc();
 6221|      0|		return tok;
 6222|      0|	    }
 6223|       |
 6224|       |	    /* Tricky! If we find an "else" we must */
 6225|       |	    /* ignore the preceding newline.  Any other */
 6226|       |	    /* token means that we must return the newline */
 6227|       |	    /* to terminate the "if" and "push back" that */
 6228|       |	    /* token so that we will obtain it on the next */
 6229|       |	    /* call to token.  In either case sensitivity */
 6230|       |	    /* is lost, so we pop the "i" from the context */
 6231|       |	    /* stack. */
 6232|       |
 6233|     26|	    if(tok == ELSE) {
  ------------------
  |  |  601|     26|#define ELSE 273
  ------------------
  |  Branch (6233:9): [True: 8, False: 18]
  ------------------
 6234|      8|		EatLines = 1;
 6235|      8|		ifpop();
 6236|      8|		setlastloc();
 6237|      8|		return ELSE;
  ------------------
  |  |  601|      8|#define ELSE 273
  ------------------
 6238|      8|	    }
 6239|     18|	    else {
 6240|     18|		ifpop();
 6241|     18|		SavedToken = tok;
 6242|     18|		xxlinesave = yylloc.first_line;
 6243|     18|		xxcolsave  = yylloc.first_column;
 6244|     18|		xxbytesave = yylloc.first_byte;
 6245|     18|		xxparsesave = yylloc.first_parsed;
 6246|     18|		SavedLval = yylval;
  ------------------
  |  | 2019|     18|# define yylval			Rf_yylval
  ------------------
 6247|     18|		setlastloc();
 6248|     18|		if (ParseState.keepSrcRefs && ParseState.keepParseData &&
  ------------------
  |  Branch (6248:7): [True: 0, False: 18]
  |  Branch (6248:33): [True: 0, False: 0]
  ------------------
 6249|      0|		    yytext[0])
  ------------------
  |  Branch (6249:7): [True: 0, False: 0]
  ------------------
 6250|       |
 6251|       |		    /* unrecord the pushed back token if not null */
 6252|      0|		    ParseState.data_count--;
 6253|     18|		return '\n';
 6254|     18|	    }
 6255|     26|	}
 6256|    824|	else {
 6257|    824|	    setlastloc();
 6258|    824|	    return '\n';
 6259|    824|	}
 6260|    862|    }
 6261|       |
 6262|       |    /* Additional context sensitivities */
 6263|       |
 6264|  6.76k|    switch(tok) {
  ------------------
  |  Branch (6264:12): [True: 6.72k, False: 48]
  ------------------
 6265|       |
 6266|       |	/* Any newlines immediately following the */
 6267|       |	/* the following tokens are discarded. The */
 6268|       |	/* expressions are clearly incomplete. */
 6269|       |
 6270|      0|    case '+':
  ------------------
  |  Branch (6270:5): [True: 0, False: 6.76k]
  ------------------
 6271|      2|    case '-':
  ------------------
  |  Branch (6271:5): [True: 2, False: 6.76k]
  ------------------
 6272|     12|    case '*':
  ------------------
  |  Branch (6272:5): [True: 10, False: 6.75k]
  ------------------
 6273|     26|    case '/':
  ------------------
  |  Branch (6273:5): [True: 14, False: 6.75k]
  ------------------
 6274|     26|    case '^':
  ------------------
  |  Branch (6274:5): [True: 0, False: 6.76k]
  ------------------
 6275|     26|    case LT:
  ------------------
  |  |  608|     26|#define LT 280
  ------------------
  |  Branch (6275:5): [True: 0, False: 6.76k]
  ------------------
 6276|     28|    case LE:
  ------------------
  |  |  609|     28|#define LE 281
  ------------------
  |  Branch (6276:5): [True: 2, False: 6.76k]
  ------------------
 6277|     28|    case GE:
  ------------------
  |  |  607|     28|#define GE 279
  ------------------
  |  Branch (6277:5): [True: 0, False: 6.76k]
  ------------------
 6278|     32|    case GT:
  ------------------
  |  |  606|     32|#define GT 278
  ------------------
  |  Branch (6278:5): [True: 4, False: 6.76k]
  ------------------
 6279|     40|    case EQ:
  ------------------
  |  |  610|     40|#define EQ 282
  ------------------
  |  Branch (6279:5): [True: 8, False: 6.76k]
  ------------------
 6280|     52|    case NE:
  ------------------
  |  |  611|     52|#define NE 283
  ------------------
  |  Branch (6280:5): [True: 12, False: 6.75k]
  ------------------
 6281|     52|    case OR:
  ------------------
  |  |  613|     52|#define OR 285
  ------------------
  |  Branch (6281:5): [True: 0, False: 6.76k]
  ------------------
 6282|     52|    case AND:
  ------------------
  |  |  612|     52|#define AND 284
  ------------------
  |  Branch (6282:5): [True: 0, False: 6.76k]
  ------------------
 6283|     54|    case OR2:
  ------------------
  |  |  615|     54|#define OR2 287
  ------------------
  |  Branch (6283:5): [True: 2, False: 6.76k]
  ------------------
 6284|     56|    case AND2:
  ------------------
  |  |  614|     56|#define AND2 286
  ------------------
  |  Branch (6284:5): [True: 2, False: 6.76k]
  ------------------
 6285|     56|    case PIPE:
  ------------------
  |  |  627|     56|#define PIPE 299
  ------------------
  |  Branch (6285:5): [True: 0, False: 6.76k]
  ------------------
 6286|     56|    case PIPEBIND:
  ------------------
  |  |  629|     56|#define PIPEBIND 301
  ------------------
  |  Branch (6286:5): [True: 0, False: 6.76k]
  ------------------
 6287|    106|    case SPECIAL:
  ------------------
  |  |  634|    106|#define SPECIAL 306
  ------------------
  |  Branch (6287:5): [True: 50, False: 6.71k]
  ------------------
 6288|    190|    case FUNCTION:
  ------------------
  |  |  592|    190|#define FUNCTION 264
  ------------------
  |  Branch (6288:5): [True: 84, False: 6.68k]
  ------------------
 6289|    192|    case WHILE:
  ------------------
  |  |  602|    192|#define WHILE 274
  ------------------
  |  Branch (6289:5): [True: 2, False: 6.76k]
  ------------------
 6290|    192|    case REPEAT:
  ------------------
  |  |  605|    192|#define REPEAT 277
  ------------------
  |  Branch (6290:5): [True: 0, False: 6.76k]
  ------------------
 6291|    200|    case FOR:
  ------------------
  |  |  598|    200|#define FOR 270
  ------------------
  |  Branch (6291:5): [True: 8, False: 6.76k]
  ------------------
 6292|    208|    case IN:
  ------------------
  |  |  599|    208|#define IN 271
  ------------------
  |  Branch (6292:5): [True: 8, False: 6.76k]
  ------------------
 6293|    208|    case '?':
  ------------------
  |  Branch (6293:5): [True: 0, False: 6.76k]
  ------------------
 6294|    232|    case '!':
  ------------------
  |  Branch (6294:5): [True: 24, False: 6.74k]
  ------------------
 6295|    232|    case '=':
  ------------------
  |  Branch (6295:5): [True: 0, False: 6.76k]
  ------------------
 6296|    234|    case ':':
  ------------------
  |  Branch (6296:5): [True: 2, False: 6.76k]
  ------------------
 6297|    234|    case '~':
  ------------------
  |  Branch (6297:5): [True: 0, False: 6.76k]
  ------------------
 6298|    290|    case '$':
  ------------------
  |  Branch (6298:5): [True: 56, False: 6.71k]
  ------------------
 6299|    290|    case '@':
  ------------------
  |  Branch (6299:5): [True: 0, False: 6.76k]
  ------------------
 6300|    584|    case LEFT_ASSIGN:
  ------------------
  |  |  594|    584|#define LEFT_ASSIGN 266
  ------------------
  |  Branch (6300:5): [True: 294, False: 6.47k]
  ------------------
 6301|    584|    case RIGHT_ASSIGN:
  ------------------
  |  |  596|    584|#define RIGHT_ASSIGN 268
  ------------------
  |  Branch (6301:5): [True: 0, False: 6.76k]
  ------------------
 6302|    804|    case EQ_ASSIGN:
  ------------------
  |  |  595|    804|#define EQ_ASSIGN 267
  ------------------
  |  Branch (6302:5): [True: 220, False: 6.54k]
  ------------------
 6303|    804|	EatLines = 1;
 6304|    804|	break;
 6305|       |
 6306|       |	/* Push any "if" statements found and */
 6307|       |	/* discard any immediately following newlines. */
 6308|       |
 6309|     68|    case IF:
  ------------------
  |  |  600|     68|#define IF 272
  ------------------
  |  Branch (6309:5): [True: 68, False: 6.70k]
  ------------------
 6310|     68|	IfPush();
 6311|     68|	EatLines = 1;
 6312|     68|	break;
 6313|       |
 6314|       |	/* Terminate any immediately preceding "if" */
 6315|       |	/* statements and discard any immediately */
 6316|       |	/* following newlines. */
 6317|       |
 6318|      8|    case ELSE:
  ------------------
  |  |  601|      8|#define ELSE 273
  ------------------
  |  Branch (6318:5): [True: 8, False: 6.76k]
  ------------------
 6319|      8|	ifpop();
 6320|      8|	EatLines = 1;
 6321|      8|	break;
 6322|       |
 6323|       |	/* These tokens terminate any immediately */
 6324|       |	/* preceding "if" statements. */
 6325|       |
 6326|     86|    case ';':
  ------------------
  |  Branch (6326:5): [True: 86, False: 6.68k]
  ------------------
 6327|    692|    case ',':
  ------------------
  |  Branch (6327:5): [True: 606, False: 6.16k]
  ------------------
 6328|    692|	ifpop();
 6329|    692|	break;
 6330|       |
 6331|       |	/* Any newlines following these tokens can */
 6332|       |	/* indicate the end of an expression. */
 6333|       |
 6334|  2.13k|    case SYMBOL:
  ------------------
  |  |  591|  2.13k|#define SYMBOL 263
  ------------------
  |  Branch (6334:5): [True: 2.13k, False: 4.63k]
  ------------------
 6335|  2.13k|    case PLACEHOLDER:
  ------------------
  |  |  628|  2.13k|#define PLACEHOLDER 300
  ------------------
  |  Branch (6335:5): [True: 0, False: 6.76k]
  ------------------
 6336|  2.42k|    case STR_CONST:
  ------------------
  |  |  588|  2.42k|#define STR_CONST 260
  ------------------
  |  Branch (6336:5): [True: 284, False: 6.48k]
  ------------------
 6337|  2.72k|    case NUM_CONST:
  ------------------
  |  |  589|  2.72k|#define NUM_CONST 261
  ------------------
  |  Branch (6337:5): [True: 300, False: 6.46k]
  ------------------
 6338|  2.74k|    case NULL_CONST:
  ------------------
  |  |  590|  2.74k|#define NULL_CONST 262
  ------------------
  |  Branch (6338:5): [True: 22, False: 6.74k]
  ------------------
 6339|  2.74k|    case NEXT:
  ------------------
  |  |  603|  2.74k|#define NEXT 275
  ------------------
  |  Branch (6339:5): [True: 0, False: 6.76k]
  ------------------
 6340|  2.74k|    case BREAK:
  ------------------
  |  |  604|  2.74k|#define BREAK 276
  ------------------
  |  Branch (6340:5): [True: 0, False: 6.76k]
  ------------------
 6341|  2.74k|	EatLines = 0;
 6342|  2.74k|	break;
 6343|       |
 6344|       |	/* Handle brackets, braces and parentheses */
 6345|       |
 6346|     44|    case LBB:
  ------------------
  |  |  597|     44|#define LBB 269
  ------------------
  |  Branch (6346:5): [True: 44, False: 6.72k]
  ------------------
 6347|     44|	if(contextp - contextstack >= CONTEXTSTACK_SIZE - 2)
  ------------------
  |  | 3893|     44|#define CONTEXTSTACK_SIZE 50
  ------------------
  |  Branch (6347:5): [True: 0, False: 44]
  ------------------
 6348|      0|	    raiseLexError("contextstackOverflow", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 6349|      0|	        _("contextstack overflow (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6350|     44|	*++contextp = '[';
 6351|     44|	*++contextp = '[';
 6352|     44|	break;
 6353|       |
 6354|     32|    case '[':
  ------------------
  |  Branch (6354:5): [True: 32, False: 6.73k]
  ------------------
 6355|     32|	if(contextp - contextstack >= CONTEXTSTACK_SIZE - 1)
  ------------------
  |  | 3893|     32|#define CONTEXTSTACK_SIZE 50
  ------------------
  |  Branch (6355:5): [True: 0, False: 32]
  ------------------
 6356|      0|	    raiseLexError("contextstackOverflow", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 6357|      0|	        _("contextstack overflow (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6358|     32|	*++contextp = (char) tok;
 6359|     32|	break;
 6360|       |
 6361|    102|    case LBRACE:
  ------------------
  |  |  237|    102|#define LBRACE	'{'
  ------------------
  |  Branch (6361:5): [True: 102, False: 6.66k]
  ------------------
 6362|    102|	if(contextp - contextstack >= CONTEXTSTACK_SIZE - 1)
  ------------------
  |  | 3893|    102|#define CONTEXTSTACK_SIZE 50
  ------------------
  |  Branch (6362:5): [True: 0, False: 102]
  ------------------
 6363|      0|	    raiseLexError("contextstackOverflow", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 6364|      0|	        _("contextstack overflow (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6365|    102|	*++contextp = (char) tok;
 6366|    102|	EatLines = 1;
 6367|    102|	break;
 6368|       |
 6369|  1.00k|    case '(':
  ------------------
  |  Branch (6369:5): [True: 1.00k, False: 5.76k]
  ------------------
 6370|  1.00k|	if(contextp - contextstack >= CONTEXTSTACK_SIZE - 1)
  ------------------
  |  | 3893|  1.00k|#define CONTEXTSTACK_SIZE 50
  ------------------
  |  Branch (6370:5): [True: 0, False: 1.00k]
  ------------------
 6371|      0|	    raiseLexError("contextstackOverflow", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 6372|      0|	        _("contextstack overflow (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 6373|  1.00k|	*++contextp = (char) tok;
 6374|  1.00k|	break;
 6375|       |
 6376|    120|    case ']':
  ------------------
  |  Branch (6376:5): [True: 120, False: 6.64k]
  ------------------
 6377|    120|	while (*contextp == 'i')
  ------------------
  |  Branch (6377:9): [True: 0, False: 120]
  ------------------
 6378|      0|	    ifpop();
 6379|    120|	*contextp-- = 0;
 6380|    120|	EatLines = 0;
 6381|    120|	break;
 6382|       |
 6383|     90|    case RBRACE:
  ------------------
  |  |  238|     90|#define RBRACE	'}'
  ------------------
  |  Branch (6383:5): [True: 90, False: 6.67k]
  ------------------
 6384|     90|	while (*contextp == 'i')
  ------------------
  |  Branch (6384:9): [True: 0, False: 90]
  ------------------
 6385|      0|	    ifpop();
 6386|     90|	*contextp-- = 0;
 6387|     90|	break;
 6388|       |
 6389|  1.00k|    case ')':
  ------------------
  |  Branch (6389:5): [True: 1.00k, False: 5.76k]
  ------------------
 6390|  1.00k|	while (*contextp == 'i')
  ------------------
  |  Branch (6390:9): [True: 0, False: 1.00k]
  ------------------
 6391|      0|	    ifpop();
 6392|  1.00k|	*contextp-- = 0;
 6393|  1.00k|	EatLines = 0;
 6394|  1.00k|	break;
 6395|       |
 6396|  6.76k|    }
 6397|  6.76k|    setlastloc();
 6398|  6.76k|    return tok;
 6399|  6.76k|}
gram.c:token_:
 6144|  7.87k|static int token_(void){
 6145|       |    // capture the position before retrieving the token
 6146|  7.87k|    setfirstloc( ) ;
 6147|       |
 6148|       |    // get the token
 6149|  7.87k|    int res = token( ) ;
 6150|       |
 6151|       |    // capture the position after
 6152|  7.87k|    int _last_col  = ParseState.xxcolno ;
 6153|  7.87k|    int _last_parsed = ParseState.xxparseno ;
 6154|       |
 6155|  7.87k|    _current_token = res ;
 6156|  7.87k|    incrementId( ) ;
 6157|  7.87k|    yylloc.id = identifier ;
 6158|       |
 6159|       |    // record the position
 6160|  7.87k|    if( res != '\n' && res != END_OF_INPUT)
  ------------------
  |  |  586|  6.80k|#define END_OF_INPUT 258
  ------------------
  |  Branch (6160:9): [True: 6.80k, False: 1.06k]
  |  Branch (6160:24): [True: 6.75k, False: 48]
  ------------------
 6161|  6.75k|	record_( yylloc.first_parsed, yylloc.first_column, 
 6162|  6.75k|	         _last_parsed, _last_col,
 6163|  6.75k|		res, identifier, yytext );
 6164|       |
 6165|  7.87k|    return res; 
 6166|  7.87k|}
gram.c:setfirstloc:
 6120|  7.87k|{
 6121|  7.87k|    yylloc.first_line   = ParseState.xxlineno;
 6122|  7.87k|    yylloc.first_column = ParseState.xxcolno;
 6123|  7.87k|    yylloc.first_byte   = ParseState.xxbyteno;
 6124|  7.87k|    yylloc.first_parsed = ParseState.xxparseno;
 6125|  7.87k|}
gram.c:token:
 5874|  7.87k|{
 5875|  7.87k|    int c, clen, i;
 5876|  7.87k|    wchar_t wc;
 5877|       |
 5878|  7.87k|    if (SavedToken) {
  ------------------
  |  Branch (5878:9): [True: 18, False: 7.85k]
  ------------------
 5879|     18|	c = SavedToken;
 5880|     18|	yylval = SavedLval;
  ------------------
  |  | 2019|     18|# define yylval			Rf_yylval
  ------------------
 5881|     18|	SavedLval = R_NilValue;
 5882|     18|	SavedToken = 0;
 5883|     18|	yylloc.first_line = xxlinesave;
 5884|     18|	yylloc.first_column = xxcolsave;
 5885|     18|	yylloc.first_byte = xxbytesave;
 5886|     18|	yylloc.first_parsed = xxparsesave;
 5887|     18|	return c;
 5888|     18|    }
 5889|  7.85k|    xxcharsave = xxcharcount; /* want to be able to go back one token */
 5890|       |
 5891|  7.85k|    c = SkipSpace();
 5892|  7.85k|    if (c == '#') c = SkipComment();
  ------------------
  |  Branch (5892:9): [True: 380, False: 7.47k]
  ------------------
 5893|       |
 5894|  7.85k|    yylloc.first_line = ParseState.xxlineno;
 5895|  7.85k|    yylloc.first_column = ParseState.xxcolno;
 5896|  7.85k|    yylloc.first_byte = ParseState.xxbyteno;
 5897|  7.85k|    yylloc.first_parsed = ParseState.xxparseno;
 5898|       |
 5899|  7.85k|    if (c == R_EOF) return END_OF_INPUT;
  ------------------
  |  | 1531|  7.85k|#define R_EOF	-1
  ------------------
                  if (c == R_EOF) return END_OF_INPUT;
  ------------------
  |  |  586|     48|#define END_OF_INPUT 258
  ------------------
  |  Branch (5899:9): [True: 48, False: 7.80k]
  ------------------
 5900|       |
 5901|       |    /* Either digits or symbols can start with a "." */
 5902|       |    /* so we need to decide which it is and jump to  */
 5903|       |    /* the correct spot. */
 5904|       |
 5905|  7.80k|    if (c == '.' && typeofnext() >= 2) goto symbol;
  ------------------
  |  Branch (5905:9): [True: 132, False: 7.67k]
  |  Branch (5905:21): [True: 132, False: 0]
  ------------------
 5906|       |
 5907|       |    /* literal numbers */
 5908|       |
 5909|  7.67k|    if (c == '.') return NumericValue(c);
  ------------------
  |  Branch (5909:9): [True: 0, False: 7.67k]
  ------------------
 5910|       |    /* We don't care about other than ASCII digits */
 5911|  7.67k|    if (isdigit(c)) return NumericValue(c);
  ------------------
  |  Branch (5911:9): [True: 194, False: 7.47k]
  ------------------
 5912|       |
 5913|       |    /* raw string literal */
 5914|       |
 5915|  7.47k|    if (c == 'r' || c == 'R') {
  ------------------
  |  Branch (5915:9): [True: 76, False: 7.40k]
  |  Branch (5915:21): [True: 26, False: 7.37k]
  ------------------
 5916|    102|	if (nextchar('"'))
  ------------------
  |  Branch (5916:6): [True: 0, False: 102]
  ------------------
 5917|      0|	    return RawStringValue(c, '"');
 5918|    102|	else if (nextchar('\''))
  ------------------
  |  Branch (5918:11): [True: 0, False: 102]
  ------------------
 5919|      0|	    return RawStringValue(c, '\'');
 5920|    102|    }
 5921|       |
 5922|       |    /* literal strings */
 5923|       |
 5924|  7.47k|    if (c == '\"' || c == '\'')
  ------------------
  |  Branch (5924:9): [True: 280, False: 7.19k]
  |  Branch (5924:22): [True: 4, False: 7.19k]
  ------------------
 5925|    284|	return StringValue(c, false);
 5926|       |
 5927|       |    /* special functions */
 5928|       |
 5929|  7.19k|    if (c == '%')
  ------------------
  |  Branch (5929:9): [True: 50, False: 7.14k]
  ------------------
 5930|     50|	return SpecialValue(c);
 5931|       |
 5932|       |    /* functions, constants and variables */
 5933|       |
 5934|  7.14k|    if (c == '`')
  ------------------
  |  Branch (5934:9): [True: 4, False: 7.14k]
  ------------------
 5935|      4|	return StringValue(c, true);
 5936|  7.27k| symbol:
 5937|       |
 5938|  7.27k|    if (c == '.') return SymbolValue(c);
  ------------------
  |  Branch (5938:9): [True: 132, False: 7.14k]
  ------------------
 5939|  7.14k|    if (c == '_') return Placeholder(c);
  ------------------
  |  Branch (5939:9): [True: 0, False: 7.14k]
  ------------------
 5940|  7.14k|    if(mbcslocale) {
  ------------------
  |  Branch (5940:8): [True: 0, False: 7.14k]
  ------------------
 5941|       |	// FIXME potentially need R_wchar_t with UTF-8 Windows.
 5942|      0|	if (mbcs_get_next(c, &wc) == -1)
  ------------------
  |  Branch (5942:6): [True: 0, False: 0]
  ------------------
 5943|      0|	    return END_OF_INPUT; /* EOF whilst reading MBCS char */
  ------------------
  |  |  586|      0|#define END_OF_INPUT 258
  ------------------
 5944|      0|	if (iswalpha(wc)) return SymbolValue(c);
  ------------------
  |  Branch (5944:6): [True: 0, False: 0]
  ------------------
 5945|      0|    } else
 5946|  7.14k|	if (isalpha(c)) return SymbolValue(c);
  ------------------
  |  Branch (5946:6): [True: 2.31k, False: 4.82k]
  ------------------
 5947|       |
 5948|       |    /* compound tokens */
 5949|       |
 5950|  4.82k|    switch (c) {
 5951|    296|    case '<':
  ------------------
  |  Branch (5951:5): [True: 296, False: 4.52k]
  ------------------
 5952|    296|	if (nextchar('=')) {
  ------------------
  |  Branch (5952:6): [True: 2, False: 294]
  ------------------
 5953|      2|	    yylval = install_and_save("<=");
  ------------------
  |  | 2019|      2|# define yylval			Rf_yylval
  ------------------
 5954|      2|	    return LE;
  ------------------
  |  |  609|      2|#define LE 281
  ------------------
 5955|      2|	}
 5956|    294|	if (nextchar('-')) {
  ------------------
  |  Branch (5956:6): [True: 292, False: 2]
  ------------------
 5957|    292|	    yylval = install_and_save("<-");
  ------------------
  |  | 2019|    292|# define yylval			Rf_yylval
  ------------------
 5958|    292|	    return LEFT_ASSIGN;
  ------------------
  |  |  594|    292|#define LEFT_ASSIGN 266
  ------------------
 5959|    292|	}
 5960|      2|	if (nextchar('<')) {
  ------------------
  |  Branch (5960:6): [True: 2, False: 0]
  ------------------
 5961|      2|	    if (nextchar('-')) {
  ------------------
  |  Branch (5961:10): [True: 2, False: 0]
  ------------------
 5962|      2|		yylval = install_and_save("<<-");
  ------------------
  |  | 2019|      2|# define yylval			Rf_yylval
  ------------------
 5963|      2|		return LEFT_ASSIGN;
  ------------------
  |  |  594|      2|#define LEFT_ASSIGN 266
  ------------------
 5964|      2|	    }
 5965|      0|	    else
 5966|      0|		return ERROR;
  ------------------
  |  |  587|      0|#define ERROR 259
  ------------------
 5967|      2|	}
 5968|      0|	yylval = install_and_save("<");
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 5969|      0|	return LT;
  ------------------
  |  |  608|      0|#define LT 280
  ------------------
 5970|      2|    case '-':
  ------------------
  |  Branch (5970:5): [True: 2, False: 4.82k]
  ------------------
 5971|      2|	if (nextchar('>')) {
  ------------------
  |  Branch (5971:6): [True: 0, False: 2]
  ------------------
 5972|      0|	    if (nextchar('>')) {
  ------------------
  |  Branch (5972:10): [True: 0, False: 0]
  ------------------
 5973|      0|		yylval = install_and_save2("<<-", "->>");
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 5974|      0|		return RIGHT_ASSIGN;
  ------------------
  |  |  596|      0|#define RIGHT_ASSIGN 268
  ------------------
 5975|      0|	    }
 5976|      0|	    else {
 5977|      0|		yylval = install_and_save2("<-", "->");
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 5978|      0|		return RIGHT_ASSIGN;
  ------------------
  |  |  596|      0|#define RIGHT_ASSIGN 268
  ------------------
 5979|      0|	    }
 5980|      0|	}
 5981|      2|	yylval = install_and_save("-");
  ------------------
  |  | 2019|      2|# define yylval			Rf_yylval
  ------------------
 5982|      2|	return '-';
 5983|      4|    case '>':
  ------------------
  |  Branch (5983:5): [True: 4, False: 4.82k]
  ------------------
 5984|      4|	if (nextchar('=')) {
  ------------------
  |  Branch (5984:6): [True: 0, False: 4]
  ------------------
 5985|      0|	    yylval = install_and_save(">=");
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 5986|      0|	    return GE;
  ------------------
  |  |  607|      0|#define GE 279
  ------------------
 5987|      0|	}
 5988|      4|	yylval = install_and_save(">");
  ------------------
  |  | 2019|      4|# define yylval			Rf_yylval
  ------------------
 5989|      4|	return GT;
  ------------------
  |  |  606|      4|#define GT 278
  ------------------
 5990|     36|    case '!':
  ------------------
  |  Branch (5990:5): [True: 36, False: 4.78k]
  ------------------
 5991|     36|	if (nextchar('=')) {
  ------------------
  |  Branch (5991:6): [True: 12, False: 24]
  ------------------
 5992|     12|	    yylval = install_and_save("!=");
  ------------------
  |  | 2019|     12|# define yylval			Rf_yylval
  ------------------
 5993|     12|	    return NE;
  ------------------
  |  |  611|     12|#define NE 283
  ------------------
 5994|     12|	}
 5995|     24|	yylval = install_and_save("!");
  ------------------
  |  | 2019|     24|# define yylval			Rf_yylval
  ------------------
 5996|     24|	return '!';
 5997|    228|    case '=':
  ------------------
  |  Branch (5997:5): [True: 228, False: 4.59k]
  ------------------
 5998|    228|	if (nextchar('=')) {
  ------------------
  |  Branch (5998:6): [True: 8, False: 220]
  ------------------
 5999|      8|	    yylval = install_and_save("==");
  ------------------
  |  | 2019|      8|# define yylval			Rf_yylval
  ------------------
 6000|      8|	    return EQ;
  ------------------
  |  |  610|      8|#define EQ 282
  ------------------
 6001|      8|	}
 6002|    220|	else if (nextchar('>')) {
  ------------------
  |  Branch (6002:11): [True: 0, False: 220]
  ------------------
 6003|      0|	    yylval = install_and_save("=>");
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 6004|      0|	    HavePipeBind = true;
 6005|      0|	    return PIPEBIND;
  ------------------
  |  |  629|      0|#define PIPEBIND 301
  ------------------
 6006|      0|	}		 
 6007|    220|	yylval = install_and_save("=");
  ------------------
  |  | 2019|    220|# define yylval			Rf_yylval
  ------------------
 6008|    220|	return EQ_ASSIGN;
  ------------------
  |  |  595|    220|#define EQ_ASSIGN 267
  ------------------
 6009|      2|    case ':':
  ------------------
  |  Branch (6009:5): [True: 2, False: 4.82k]
  ------------------
 6010|      2|	if (nextchar(':')) {
  ------------------
  |  Branch (6010:6): [True: 0, False: 2]
  ------------------
 6011|      0|	    if (nextchar(':')) {
  ------------------
  |  Branch (6011:10): [True: 0, False: 0]
  ------------------
 6012|      0|		yylval = install_and_save(":::");
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 6013|      0|		return NS_GET_INT;
  ------------------
  |  |  617|      0|#define NS_GET_INT 289
  ------------------
 6014|      0|	    }
 6015|      0|	    else {
 6016|      0|		yylval = install_and_save("::");
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 6017|      0|		return NS_GET;
  ------------------
  |  |  616|      0|#define NS_GET 288
  ------------------
 6018|      0|	    }
 6019|      0|	}
 6020|      2|	if (nextchar('=')) {
  ------------------
  |  Branch (6020:6): [True: 0, False: 2]
  ------------------
 6021|      0|	    yylval = install_and_save(":=");
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 6022|      0|	    return LEFT_ASSIGN;
  ------------------
  |  |  594|      0|#define LEFT_ASSIGN 266
  ------------------
 6023|      0|	}
 6024|      2|	yylval = install_and_save(":");
  ------------------
  |  | 2019|      2|# define yylval			Rf_yylval
  ------------------
 6025|      2|	return ':';
 6026|      2|    case '&':
  ------------------
  |  Branch (6026:5): [True: 2, False: 4.82k]
  ------------------
 6027|      2|	if (nextchar('&')) {
  ------------------
  |  Branch (6027:6): [True: 2, False: 0]
  ------------------
 6028|      2|	    yylval = install_and_save("&&");
  ------------------
  |  | 2019|      2|# define yylval			Rf_yylval
  ------------------
 6029|      2|	    return AND2;
  ------------------
  |  |  614|      2|#define AND2 286
  ------------------
 6030|      2|	}
 6031|      0|	yylval = install_and_save("&");
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 6032|      0|	return AND;
  ------------------
  |  |  612|      0|#define AND 284
  ------------------
 6033|      2|    case '|':
  ------------------
  |  Branch (6033:5): [True: 2, False: 4.82k]
  ------------------
 6034|      2|	if (nextchar('|')) {
  ------------------
  |  Branch (6034:6): [True: 2, False: 0]
  ------------------
 6035|      2|	    yylval = install_and_save("||");
  ------------------
  |  | 2019|      2|# define yylval			Rf_yylval
  ------------------
 6036|      2|	    return OR2;
  ------------------
  |  |  615|      2|#define OR2 287
  ------------------
 6037|      2|	}
 6038|      0|	else if (nextchar('>')) {
  ------------------
  |  Branch (6038:11): [True: 0, False: 0]
  ------------------
 6039|      0|	    yylval = install_and_save("|>");
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 6040|      0|	    return PIPE;
  ------------------
  |  |  627|      0|#define PIPE 299
  ------------------
 6041|      0|	}
 6042|      0|	yylval = install_and_save("|");
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 6043|      0|	return OR;
  ------------------
  |  |  613|      0|#define OR 285
  ------------------
 6044|    102|    case LBRACE:
  ------------------
  |  |  237|    102|#define LBRACE	'{'
  ------------------
  |  Branch (6044:5): [True: 102, False: 4.72k]
  ------------------
 6045|    102|	yylval = install_and_save("{");
  ------------------
  |  | 2019|    102|# define yylval			Rf_yylval
  ------------------
 6046|    102|	return c;
 6047|    102|    case RBRACE:
  ------------------
  |  |  238|    102|#define RBRACE	'}'
  ------------------
  |  Branch (6047:5): [True: 102, False: 4.72k]
  ------------------
 6048|    102|        strcpy(yytext, "}");
 6049|    102|	return c;
 6050|  1.00k|    case '(':
  ------------------
  |  Branch (6050:5): [True: 1.00k, False: 3.81k]
  ------------------
 6051|  1.00k|	yylval = install_and_save("(");
  ------------------
  |  | 2019|  1.00k|# define yylval			Rf_yylval
  ------------------
 6052|  1.00k|	return c;
 6053|  1.00k|    case ')':
  ------------------
  |  Branch (6053:5): [True: 1.00k, False: 3.81k]
  ------------------
 6054|  1.00k|        strcpy(yytext, ")");
 6055|  1.00k|	return c;
 6056|     76|    case '[':
  ------------------
  |  Branch (6056:5): [True: 76, False: 4.74k]
  ------------------
 6057|     76|	if (nextchar('[')) {
  ------------------
  |  Branch (6057:6): [True: 44, False: 32]
  ------------------
 6058|     44|	    yylval = install_and_save("[[");
  ------------------
  |  | 2019|     44|# define yylval			Rf_yylval
  ------------------
 6059|     44|	    return LBB;
  ------------------
  |  |  597|     44|#define LBB 269
  ------------------
 6060|     44|	}
 6061|     32|	yylval = install_and_save("[");
  ------------------
  |  | 2019|     32|# define yylval			Rf_yylval
  ------------------
 6062|     32|	return c;
 6063|    120|    case ']':
  ------------------
  |  Branch (6063:5): [True: 120, False: 4.70k]
  ------------------
 6064|    120|        strcpy(yytext, "]");
 6065|    120|	return c;
 6066|      0|    case '?':
  ------------------
  |  Branch (6066:5): [True: 0, False: 4.82k]
  ------------------
 6067|      0|	yylval = install_and_save("?");
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 6068|      0|	return c;
 6069|     10|    case '*':
  ------------------
  |  Branch (6069:5): [True: 10, False: 4.81k]
  ------------------
 6070|       |	/* Replace ** by ^.  This has been here since 1998, but is
 6071|       |	   undocumented (at least in the obvious places).  It is in
 6072|       |	   the index of the Blue Book with a reference to p. 431, the
 6073|       |	   help for 'Deprecated'.  S-PLUS 6.2 still allowed this, so
 6074|       |	   presumably it was for compatibility with S. */
 6075|     10|	if (nextchar('*')) {
  ------------------
  |  Branch (6075:6): [True: 0, False: 10]
  ------------------
 6076|      0|	    yylval = install_and_save2("^", "**");
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 6077|      0|	    return '^';
 6078|      0|	} else
 6079|     10|	    yylval = install_and_save("*");
  ------------------
  |  | 2019|     10|# define yylval			Rf_yylval
  ------------------
 6080|     10|	return c;
 6081|      0|    case '+':
  ------------------
  |  Branch (6081:5): [True: 0, False: 4.82k]
  ------------------
 6082|     14|    case '/':
  ------------------
  |  Branch (6082:5): [True: 14, False: 4.81k]
  ------------------
 6083|     14|    case '^':
  ------------------
  |  Branch (6083:5): [True: 0, False: 4.82k]
  ------------------
 6084|     14|    case '~':
  ------------------
  |  Branch (6084:5): [True: 0, False: 4.82k]
  ------------------
 6085|     70|    case '$':
  ------------------
  |  Branch (6085:5): [True: 56, False: 4.76k]
  ------------------
 6086|     70|    case '@':
  ------------------
  |  Branch (6086:5): [True: 0, False: 4.82k]
  ------------------
 6087|     70|    case '\\':
  ------------------
  |  Branch (6087:5): [True: 0, False: 4.82k]
  ------------------
 6088|     70|	yytext[0] = (char) c;
 6089|     70|	yytext[1] = '\0';
 6090|     70|	yylval = install(yytext);
  ------------------
  |  | 2019|     70|# define yylval			Rf_yylval
  ------------------
              	yylval = install(yytext);
  ------------------
  |  |  934|     70|#define install			Rf_install
  ------------------
 6091|     70|	return c;
 6092|  1.06k|    case '\n':
  ------------------
  |  Branch (6092:5): [True: 1.06k, False: 3.76k]
  ------------------
 6093|  1.67k|    case ',':
  ------------------
  |  Branch (6093:5): [True: 606, False: 4.21k]
  ------------------
 6094|  1.75k|    case ';':
  ------------------
  |  Branch (6094:5): [True: 86, False: 4.73k]
  ------------------
 6095|  1.75k|	yytext[0] = (char) c;
 6096|  1.75k|	yytext[1] = '\0';
 6097|  1.75k|	return c;
 6098|      0|    default:
  ------------------
  |  Branch (6098:5): [True: 0, False: 4.82k]
  ------------------
 6099|      0|	clen = 1;
 6100|      0|	if (mbcslocale) {
  ------------------
  |  Branch (6100:6): [True: 0, False: 0]
  ------------------
 6101|       |	    // FIXME potentially need R_wchar_t with UTF-8 Windows.
 6102|      0|	    clen = mbcs_get_next(c, &wc);
 6103|      0|	    if (clen == -1)
  ------------------
  |  Branch (6103:10): [True: 0, False: 0]
  ------------------
 6104|      0|		return END_OF_INPUT; /* EOF whilst reading MBCS char */
  ------------------
  |  |  586|      0|#define END_OF_INPUT 258
  ------------------
 6105|      0|	}
 6106|      0|	DECLARE_YYTEXT_BUFP(yyp);
  ------------------
  |  | 2908|      0|#define DECLARE_YYTEXT_BUFP(bp) char *bp = yytext ;
  ------------------
 6107|      0|	YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|      0|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      0|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      0|    *(bp)++ = ((char)c);			\
  |  | 2915|      0|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 6108|      0|	for(i = 1; i < clen ; i++)
  ------------------
  |  Branch (6108:13): [True: 0, False: 0]
  ------------------
 6109|      0|	    YYTEXT_PUSH(xxgetc(), yyp);
  ------------------
  |  | 2909|      0|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      0|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      0|    *(bp)++ = ((char)c);			\
  |  | 2915|      0|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 6110|      0|	YYTEXT_PUSH('\0', yyp);
  ------------------
  |  | 2909|      0|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      0|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      0|    *(bp)++ = ((char)c);			\
  |  | 2915|      0|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 6111|      0|	return (clen == 1) ? c : ERROR;
  ------------------
  |  |  587|      0|#define ERROR 259
  ------------------
  |  Branch (6111:9): [True: 0, False: 0]
  ------------------
 6112|  4.82k|    }
 6113|  4.82k|}
gram.c:SkipSpace:
 4811|  7.85k|{
 4812|  7.85k|    int c;
 4813|       |
 4814|       |#if defined(USE_RI18N_FNS) // includes Win32
 4815|       |    static wctype_t blankwct = 0;
 4816|       |    if (!blankwct)
 4817|       |	blankwct = Ri18n_wctype("blank");
 4818|       |#endif
 4819|       |
 4820|       |#ifdef Win32
 4821|       |    if(!mbcslocale) { /* 0xa0 is NBSP in all 8-bit Windows locales */
 4822|       |	while ((c = xxgetc()) == ' ' || c == '\t' || c == '\f' ||
 4823|       |	       (unsigned int) c == 0xa0) {};
 4824|       |	return c;
 4825|       |    } else {
 4826|       |	int i, clen;
 4827|       |	wchar_t wc;
 4828|       |	while (1) {
 4829|       |	    c = xxgetc();
 4830|       |	    if (c == ' ' || c == '\t' || c == '\f') continue;
 4831|       |	    if (c == '\n' || c == R_EOF) break;
 4832|       |	    if ((unsigned int) c < 0x80) break;
 4833|       |	    clen = mbcs_get_next(c, &wc);  /* always 2 */
 4834|       |	    if (clen == -1) { /* EOF whilst reading MBCS char */
 4835|       |		xxungetc(c);
 4836|       |		c = R_EOF;
 4837|       |		break;
 4838|       |	    }
 4839|       |	    if(! Ri18n_iswctype(wc, blankwct) ) break;
 4840|       |	    for(i = 1; i < clen; i++) c = xxgetc();
 4841|       |	}
 4842|       |	return c;
 4843|       |    }
 4844|       |#endif
 4845|  7.85k|#if defined(__STDC_ISO_10646__)
 4846|  7.85k|    if(mbcslocale) { /* wctype functions need Unicode wchar_t */
  ------------------
  |  Branch (4846:8): [True: 0, False: 7.85k]
  ------------------
 4847|      0|	int i, clen;
 4848|      0|	wchar_t wc;
 4849|      0|	while (1) {
  ------------------
  |  Branch (4849:9): [True: 0, Folded]
  ------------------
 4850|      0|	    c = xxgetc();
 4851|      0|	    if (c == ' ' || c == '\t' || c == '\f') continue;
  ------------------
  |  Branch (4851:10): [True: 0, False: 0]
  |  Branch (4851:22): [True: 0, False: 0]
  |  Branch (4851:35): [True: 0, False: 0]
  ------------------
 4852|      0|	    if (c == '\n' || c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (4852:10): [True: 0, False: 0]
  |  Branch (4852:23): [True: 0, False: 0]
  ------------------
 4853|      0|	    if ((unsigned int) c < 0x80) break;
  ------------------
  |  Branch (4853:10): [True: 0, False: 0]
  ------------------
 4854|      0|	    clen = mbcs_get_next(c, &wc);
 4855|      0|	    if (clen == -1) { /* EOF whilst reading MBCS char */
  ------------------
  |  Branch (4855:10): [True: 0, False: 0]
  ------------------
 4856|      0|		xxungetc(c);
 4857|      0|		c = R_EOF;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
 4858|      0|		break;
 4859|      0|	    }
 4860|       |#if defined(USE_RI18N_FNS)
 4861|       |	    if(! Ri18n_iswctype(wc, blankwct) ) break;
 4862|       |#else
 4863|      0|	    if(! iswblank(wc) ) break;
  ------------------
  |  Branch (4863:9): [True: 0, False: 0]
  ------------------
 4864|      0|#endif
 4865|      0|	    for(i = 1; i < clen; i++) c = xxgetc();
  ------------------
  |  Branch (4865:17): [True: 0, False: 0]
  ------------------
 4866|      0|	}
 4867|      0|    } else
 4868|  7.85k|#endif
 4869|       |	// does not support non-ASCII spaces, unlike Windows
 4870|  13.0k|	while ((c = xxgetc()) == ' ' || c == '\t' || c == '\f') {};
  ------------------
  |  Branch (4870:9): [True: 5.16k, False: 7.85k]
  |  Branch (4870:34): [True: 2, False: 7.85k]
  |  Branch (4870:47): [True: 0, False: 7.85k]
  ------------------
 4871|  7.85k|    return c;
 4872|  7.85k|}
gram.c:xxungetc:
 2967|  3.73k|{
 2968|       |    /* this assumes that c was the result of xxgetc; if not, some edits will be needed */
 2969|  3.73k|    ParseState.xxlineno = prevlines[prevpos];
 2970|  3.73k|    ParseState.xxbyteno = prevbytes[prevpos];
 2971|  3.73k|    ParseState.xxcolno  = prevcols[prevpos];
 2972|  3.73k|    ParseState.xxparseno = prevparse[prevpos];
 2973|       |    
 2974|  3.73k|    prevpos = (prevpos + PUSHBACK_BUFSIZE - 1) % PUSHBACK_BUFSIZE;
  ------------------
  |  | 2917|  3.73k|#define PUSHBACK_BUFSIZE 16
  ------------------
                  prevpos = (prevpos + PUSHBACK_BUFSIZE - 1) % PUSHBACK_BUFSIZE;
  ------------------
  |  | 2917|  3.73k|#define PUSHBACK_BUFSIZE 16
  ------------------
 2975|       |
 2976|  3.73k|    R_ParseContextLine = ParseState.xxlineno;
 2977|       |
 2978|  3.73k|    xxcharcount--;
 2979|  3.73k|    R_ParseContext[R_ParseContextLast] = '\0';
 2980|       |    /* precaution as to how % is implemented for < 0 numbers */
 2981|  3.73k|    R_ParseContextLast = (R_ParseContextLast + PARSE_CONTEXT_SIZE -1) % PARSE_CONTEXT_SIZE;
  ------------------
  |  |  112|  3.73k|#define PARSE_CONTEXT_SIZE 256	    /* Recent parse context kept in a circular buffer */
  ------------------
                  R_ParseContextLast = (R_ParseContextLast + PARSE_CONTEXT_SIZE -1) % PARSE_CONTEXT_SIZE;
  ------------------
  |  |  112|  3.73k|#define PARSE_CONTEXT_SIZE 256	    /* Recent parse context kept in a circular buffer */
  ------------------
 2982|  3.73k|    if(npush >= PUSHBACK_BUFSIZE) return EOF;
  ------------------
  |  | 2917|  3.73k|#define PUSHBACK_BUFSIZE 16
  ------------------
  |  Branch (2982:8): [True: 0, False: 3.73k]
  ------------------
 2983|  3.73k|    pushback[npush++] = c;
 2984|  3.73k|    return c;
 2985|  3.73k|}
gram.c:SkipComment:
 4881|    380|{
 4882|    380|    int c='#', i;
 4883|       |    
 4884|       |    /* locations before the # character was read */
 4885|    380|    int _first_column = ParseState.xxcolno ;
 4886|    380|    int _first_parsed = ParseState.xxparseno ;
 4887|    380|    int type = COMMENT ;
  ------------------
  |  |  618|    380|#define COMMENT 290
  ------------------
 4888|       |
 4889|    380|    bool maybeLine = (ParseState.xxcolno == 1);
 4890|    380|    bool doSave;
 4891|       |
 4892|    380|    DECLARE_YYTEXT_BUFP(yyp);
  ------------------
  |  | 2908|    380|#define DECLARE_YYTEXT_BUFP(bp) char *bp = yytext ;
  ------------------
 4893|       |    
 4894|    380|    if (maybeLine) {
  ------------------
  |  Branch (4894:9): [True: 304, False: 76]
  ------------------
 4895|    304|    	char lineDirective[] = "#line";
 4896|    304|    	YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|    304|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|    304|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 304]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|    304|    *(bp)++ = ((char)c);			\
  |  | 2915|    304|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 304]
  |  |  ------------------
  ------------------
 4897|    304|    	for (i=1; i<5; i++) {
  ------------------
  |  Branch (4897:16): [True: 304, False: 0]
  ------------------
 4898|    304|    	    c = xxgetc();
 4899|    304|  	    if (c != (int)(lineDirective[i])) {
  ------------------
  |  Branch (4899:12): [True: 304, False: 0]
  ------------------
 4900|    304|  	    	maybeLine = false;
 4901|    304|  	    	break;
 4902|    304|  	    }
 4903|      0|            YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|      0|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      0|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      0|    *(bp)++ = ((char)c);			\
  |  | 2915|      0|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 4904|      0|  	}
 4905|    304|  	if (maybeLine)     
  ------------------
  |  Branch (4905:8): [True: 0, False: 304]
  ------------------
 4906|      0|	    c = processLineDirective(&type);
 4907|    304|    }
 4908|       |    // we want to track down the character
 4909|       |    // __before__ the new line character
 4910|    380|    int _last_column  = ParseState.xxcolno ;
 4911|    380|    int _last_parsed  = ParseState.xxparseno ;
 4912|       |    
 4913|    380|    if (c == '\n') {
  ------------------
  |  Branch (4913:9): [True: 56, False: 324]
  ------------------
 4914|     56|        _last_column = prevcols[prevpos];
 4915|     56|        _last_parsed = prevparse[prevpos];
 4916|     56|    }
 4917|       |    
 4918|    380|    doSave = !maybeLine;
 4919|       |    
 4920|  16.1k|    while (c != '\n' && c != R_EOF) {
  ------------------
  |  | 1531|  15.7k|#define R_EOF	-1
  ------------------
  |  Branch (4920:12): [True: 15.7k, False: 380]
  |  Branch (4920:25): [True: 15.7k, False: 0]
  ------------------
 4921|       |        // Comments can be any length; we only record the ones that fit in yytext.
 4922|  15.7k|        if (doSave) {
  ------------------
  |  Branch (4922:13): [True: 15.7k, False: 0]
  ------------------
 4923|  15.7k|            YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|  15.7k|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|  15.7k|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 15.7k]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|  15.7k|    *(bp)++ = ((char)c);			\
  |  | 2915|  15.7k|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 15.7k]
  |  |  ------------------
  ------------------
 4924|  15.7k|            doSave = (yyp - yytext) < sizeof(yytext) - 2;
 4925|  15.7k|        }
 4926|  15.7k| 	_last_column = ParseState.xxcolno ;
 4927|  15.7k|	_last_parsed = ParseState.xxparseno ;
 4928|  15.7k|	c = xxgetc();
 4929|  15.7k|    }
 4930|    380|    if (c == R_EOF) EndOfFile = 2;
  ------------------
  |  | 1531|    380|#define R_EOF	-1
  ------------------
  |  Branch (4930:9): [True: 0, False: 380]
  ------------------
 4931|    380|    incrementId( ) ;
 4932|    380|    YYTEXT_PUSH('\0', yyp);
  ------------------
  |  | 2909|    380|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|    380|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 380]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|    380|    *(bp)++ = ((char)c);			\
  |  | 2915|    380|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 380]
  |  |  ------------------
  ------------------
 4933|    380|    record_( _first_parsed, _first_column, _last_parsed, _last_column,
 4934|    380|	     type, identifier, doSave ? yytext : 0 ) ;
  ------------------
  |  Branch (4934:25): [True: 380, False: 0]
  ------------------
 4935|    380|    return c;
 4936|    380|}
gram.c:typeofnext:
 4498|    132|{
 4499|    132|    int k, c;
 4500|       |
 4501|    132|    c = xxgetc();
 4502|    132|    if (isdigit(c)) k = 1; else k = 2;
  ------------------
  |  Branch (4502:9): [True: 0, False: 132]
  ------------------
 4503|    132|    xxungetc(c);
 4504|    132|    return k;
 4505|    132|}
gram.c:NumericValue:
 4939|    194|{
 4940|    194|    int seendot = (c == '.');
 4941|    194|    int seenexp = 0;
 4942|    194|    int last = c;
 4943|    194|    int nd = 0;
 4944|    194|    int asNumeric = 0;
 4945|    194|    int count = 1; /* The number of characters seen */
 4946|       |
 4947|    194|    DECLARE_YYTEXT_BUFP(yyp);
  ------------------
  |  | 2908|    194|#define DECLARE_YYTEXT_BUFP(bp) char *bp = yytext ;
  ------------------
 4948|    194|    YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|    194|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|    194|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 194]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|    194|    *(bp)++ = ((char)c);			\
  |  | 2915|    194|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 194]
  |  |  ------------------
  ------------------
 4949|       |    /* We don't care about other than ASCII digits */
 4950|    328|    while (isdigit(c = xxgetc()) || c == '.' || c == 'e' || c == 'E'
  ------------------
  |  Branch (4950:12): [True: 120, False: 208]
  |  Branch (4950:37): [True: 10, False: 198]
  |  Branch (4950:49): [True: 4, False: 194]
  |  Branch (4950:61): [True: 0, False: 194]
  ------------------
 4951|    194|	   || c == 'x' || c == 'X' || c == 'L')
  ------------------
  |  Branch (4951:8): [True: 0, False: 194]
  |  Branch (4951:20): [True: 0, False: 194]
  |  Branch (4951:32): [True: 60, False: 134]
  ------------------
 4952|    194|    {
 4953|    194|	count++;
 4954|    194|	if (c == 'L') /* must be at the end.  Won't allow 1Le3 (at present). */
  ------------------
  |  Branch (4954:6): [True: 60, False: 134]
  ------------------
 4955|     60|	{   YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|     60|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|     60|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 60]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|     60|    *(bp)++ = ((char)c);			\
  |  | 2915|     60|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 60]
  |  |  ------------------
  ------------------
 4956|     60|	    break;
 4957|     60|	}
 4958|       |	
 4959|    134|	if (c == 'x' || c == 'X') {
  ------------------
  |  Branch (4959:6): [True: 0, False: 134]
  |  Branch (4959:18): [True: 0, False: 134]
  ------------------
 4960|      0|	    if (count > 2 || last != '0') break;  /* 0x must be first */
  ------------------
  |  Branch (4960:10): [True: 0, False: 0]
  |  Branch (4960:23): [True: 0, False: 0]
  ------------------
 4961|      0|	    YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|      0|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      0|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      0|    *(bp)++ = ((char)c);			\
  |  | 2915|      0|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 4962|      0|	    while(isdigit(c = xxgetc()) || ('a' <= c && c <= 'f') ||
  ------------------
  |  Branch (4962:12): [True: 0, False: 0]
  |  Branch (4962:38): [True: 0, False: 0]
  |  Branch (4962:50): [True: 0, False: 0]
  ------------------
 4963|      0|		  ('A' <= c && c <= 'F') || c == '.') {
  ------------------
  |  Branch (4963:6): [True: 0, False: 0]
  |  Branch (4963:18): [True: 0, False: 0]
  |  Branch (4963:31): [True: 0, False: 0]
  ------------------
 4964|      0|		if (c == '.') {
  ------------------
  |  Branch (4964:7): [True: 0, False: 0]
  ------------------
 4965|      0|		    if (seendot) return ERROR;
  ------------------
  |  |  587|      0|#define ERROR 259
  ------------------
  |  Branch (4965:11): [True: 0, False: 0]
  ------------------
 4966|      0|		    seendot = 1;
 4967|      0|		}
 4968|      0|		YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|      0|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      0|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      0|    *(bp)++ = ((char)c);			\
  |  | 2915|      0|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 4969|      0|		nd++;
 4970|      0|	    }
 4971|      0|	    if (nd == 0) return ERROR;
  ------------------
  |  |  587|      0|#define ERROR 259
  ------------------
  |  Branch (4971:10): [True: 0, False: 0]
  ------------------
 4972|      0|	    if (c == 'p' || c == 'P') {
  ------------------
  |  Branch (4972:10): [True: 0, False: 0]
  |  Branch (4972:22): [True: 0, False: 0]
  ------------------
 4973|      0|	        seenexp = 1;
 4974|      0|		YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|      0|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      0|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      0|    *(bp)++ = ((char)c);			\
  |  | 2915|      0|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 4975|      0|		c = xxgetc();
 4976|      0|		if (!isdigit(c) && c != '+' && c != '-') return ERROR;
  ------------------
  |  |  587|      0|#define ERROR 259
  ------------------
  |  Branch (4976:7): [True: 0, False: 0]
  |  Branch (4976:22): [True: 0, False: 0]
  |  Branch (4976:34): [True: 0, False: 0]
  ------------------
 4977|      0|		if (c == '+' || c == '-') {
  ------------------
  |  Branch (4977:7): [True: 0, False: 0]
  |  Branch (4977:19): [True: 0, False: 0]
  ------------------
 4978|      0|		    YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|      0|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      0|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      0|    *(bp)++ = ((char)c);			\
  |  | 2915|      0|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 4979|      0|		    c = xxgetc();
 4980|      0|		}
 4981|      0|		for(nd = 0; isdigit(c); c = xxgetc(), nd++)
  ------------------
  |  Branch (4981:15): [True: 0, False: 0]
  ------------------
 4982|      0|		    YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|      0|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      0|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      0|    *(bp)++ = ((char)c);			\
  |  | 2915|      0|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 4983|      0|		if (nd == 0) return ERROR;
  ------------------
  |  |  587|      0|#define ERROR 259
  ------------------
  |  Branch (4983:7): [True: 0, False: 0]
  ------------------
 4984|      0|	    }
 4985|       |// ?NumericComstants says exponent is optional (as does C99)
 4986|       |//            if (seendot && !seenexp) return ERROR;
 4987|      0|	    if (c == 'L') /* for getParseData */
  ------------------
  |  Branch (4987:10): [True: 0, False: 0]
  ------------------
 4988|      0|	    {
 4989|       |		// seenexp will be checked later
 4990|      0|		YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|      0|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      0|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      0|    *(bp)++ = ((char)c);			\
  |  | 2915|      0|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 4991|      0|		break;
 4992|      0|	    }
 4993|      0|	    break;
 4994|      0|	}
 4995|    134|	if (c == 'E' || c == 'e') {
  ------------------
  |  Branch (4995:6): [True: 0, False: 134]
  |  Branch (4995:18): [True: 4, False: 130]
  ------------------
 4996|      4|	    if (seenexp)
  ------------------
  |  Branch (4996:10): [True: 0, False: 4]
  ------------------
 4997|      0|		break;
 4998|      4|	    seenexp = 1;
 4999|      4|	    seendot = seendot == 1 ? seendot : 2;
  ------------------
  |  Branch (4999:16): [True: 0, False: 4]
  ------------------
 5000|      4|	    YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|      4|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      4|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 4]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      4|    *(bp)++ = ((char)c);			\
  |  | 2915|      4|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 4]
  |  |  ------------------
  ------------------
 5001|      4|	    c = xxgetc();
 5002|      4|	    if (!isdigit(c) && c != '+' && c != '-') return ERROR;
  ------------------
  |  |  587|      0|#define ERROR 259
  ------------------
  |  Branch (5002:10): [True: 0, False: 4]
  |  Branch (5002:25): [True: 0, False: 0]
  |  Branch (5002:37): [True: 0, False: 0]
  ------------------
 5003|      4|	    if (c == '+' || c == '-') {
  ------------------
  |  Branch (5003:10): [True: 0, False: 4]
  |  Branch (5003:22): [True: 0, False: 4]
  ------------------
 5004|      0|		YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|      0|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      0|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      0|    *(bp)++ = ((char)c);			\
  |  | 2915|      0|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5005|      0|		c = xxgetc();
 5006|      0|		if (!isdigit(c)) return ERROR;
  ------------------
  |  |  587|      0|#define ERROR 259
  ------------------
  |  Branch (5006:7): [True: 0, False: 0]
  ------------------
 5007|      0|	    }
 5008|      4|	}
 5009|    134|	if (c == '.') {
  ------------------
  |  Branch (5009:6): [True: 10, False: 124]
  ------------------
 5010|     10|	    if (seendot)
  ------------------
  |  Branch (5010:10): [True: 0, False: 10]
  ------------------
 5011|      0|		break;
 5012|     10|	    seendot = 1;
 5013|     10|	}
 5014|    134|	YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|    134|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|    134|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 134]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|    134|    *(bp)++ = ((char)c);			\
  |  | 2915|    134|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 134]
  |  |  ------------------
  ------------------
 5015|    134|	last = c;
 5016|    134|    }
 5017|       |    
 5018|    194|    if(c == 'i')
  ------------------
  |  Branch (5018:8): [True: 0, False: 194]
  ------------------
 5019|      0|	YYTEXT_PUSH(c, yyp); /* for getParseData */
  ------------------
  |  | 2909|      0|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      0|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      0|    *(bp)++ = ((char)c);			\
  |  | 2915|      0|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5020|       |	
 5021|    194|    YYTEXT_PUSH('\0', yyp);    
  ------------------
  |  | 2909|    194|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|    194|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 194]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|    194|    *(bp)++ = ((char)c);			\
  |  | 2915|    194|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 194]
  |  |  ------------------
  ------------------
 5022|       |    /* Make certain that things are okay. */
 5023|    194|    if(c == 'L') {
  ------------------
  |  Branch (5023:8): [True: 60, False: 134]
  ------------------
 5024|     60|	double a = R_atof(yytext);
 5025|       |	/* We are asked to create an integer via the L, so we check that the
 5026|       |	   double and int values are the same. If not, this is a problem and we
 5027|       |	   will not lose information and so use the numeric value.
 5028|       |	   The range test comes first, as (int) a is undefined outside it.
 5029|       |	*/
 5030|     60|	if(a < INT_MIN || a > INT_MAX || a != (int) a) {
  ------------------
  |  Branch (5030:5): [True: 0, False: 60]
  |  Branch (5030:20): [True: 0, False: 60]
  |  Branch (5030:35): [True: 0, False: 60]
  ------------------
 5031|      0|	    if(GenerateCode) {
  ------------------
  |  Branch (5031:9): [True: 0, False: 0]
  ------------------
 5032|      0|		if(seendot == 1 && seenexp == 0)
  ------------------
  |  Branch (5032:6): [True: 0, False: 0]
  |  Branch (5032:22): [True: 0, False: 0]
  ------------------
 5033|      0|		    warning(_("integer literal %s contains decimal; using numeric value"), yytext);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		    warning(_("integer literal %s contains decimal; using numeric value"), yytext);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5034|      0|		else {
 5035|       |		    /* hide the L for the warning message */
 5036|      0|		    warning(_("non-integer value %s qualified with L; using numeric value"), yytext);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		    warning(_("non-integer value %s qualified with L; using numeric value"), yytext);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5037|      0|		}
 5038|      0|	    }
 5039|      0|	    asNumeric = 1;
 5040|      0|	    seenexp = 1;
 5041|      0|	}
 5042|     60|    }
 5043|       |
 5044|    194|    if(c == 'i') {
  ------------------
  |  Branch (5044:8): [True: 0, False: 194]
  ------------------
 5045|      0|	yylval = GenerateCode ? mkComplex(yytext) : R_NilValue;
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
  |  Branch (5045:11): [True: 0, False: 0]
  ------------------
 5046|    194|    } else if(c == 'L' && asNumeric == 0) {
  ------------------
  |  Branch (5046:15): [True: 60, False: 134]
  |  Branch (5046:27): [True: 60, False: 0]
  ------------------
 5047|     60|	if(GenerateCode && seendot == 1 && seenexp == 0)
  ------------------
  |  Branch (5047:5): [True: 60, False: 0]
  |  Branch (5047:21): [True: 0, False: 60]
  |  Branch (5047:37): [True: 0, False: 0]
  ------------------
 5048|      0|	    warning(_("integer literal %s contains unnecessary decimal point"), yytext);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("integer literal %s contains unnecessary decimal point"), yytext);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5049|     60|	yylval = GenerateCode ? mkInt(yytext) : R_NilValue;
  ------------------
  |  | 2019|     60|# define yylval			Rf_yylval
  ------------------
  |  Branch (5049:11): [True: 60, False: 0]
  ------------------
 5050|       |#if 0  /* do this to make 123 integer not double */
 5051|       |    } else if(!(seendot || seenexp)) {
 5052|       |	if(c != 'L') xxungetc(c);
 5053|       |	if (GenerateCode) {
 5054|       |	    double a = R_atof(yytext);
 5055|       |	    int b = (int) a;
 5056|       |	    yylval = (a != (double) b) ? mkFloat(yytext) : mkInt(yytext);
 5057|       |	} else yylval = R_NilValue;
 5058|       |#endif
 5059|    134|    } else {
 5060|    134|	if(c != 'L')
  ------------------
  |  Branch (5060:5): [True: 134, False: 0]
  ------------------
 5061|    134|	    xxungetc(c);
 5062|    134|	yylval = GenerateCode ? mkFloat(yytext) : R_NilValue;
  ------------------
  |  | 2019|    134|# define yylval			Rf_yylval
  ------------------
  |  Branch (5062:11): [True: 134, False: 0]
  ------------------
 5063|    134|    }
 5064|       |
 5065|    194|    PRESERVE_SV(yylval);
  ------------------
  |  |  350|    194|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    194|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 5066|    194|    return NUM_CONST;
  ------------------
  |  |  589|    194|#define NUM_CONST 261
  ------------------
 5067|    194|}
gram.c:mkInt:
 4627|     60|{
 4628|     60|    double f = R_atof(s);  /* or R_strtol? */
 4629|     60|    return ScalarInteger((int) f);
  ------------------
  |  | 1022|     60|#define ScalarInteger		Rf_ScalarInteger
  ------------------
 4630|     60|}
gram.c:mkFloat:
 4622|    134|{
 4623|    134|    return ScalarReal(R_atof(s));
  ------------------
  |  | 1024|    134|#define ScalarReal		Rf_ScalarReal
  ------------------
 4624|    134|}
gram.c:nextchar:
 4508|  1.38k|{
 4509|  1.38k|    int c = xxgetc();
 4510|  1.38k|    if (c == expect)
  ------------------
  |  Branch (4510:9): [True: 366, False: 1.01k]
  ------------------
 4511|    366|	return 1;
 4512|  1.01k|    else
 4513|  1.01k|	xxungetc(c);
 4514|  1.01k|    return 0;
 4515|  1.38k|}
gram.c:mkString2:
 3485|    284|{
 3486|    284|    SEXP t;
 3487|    284|    cetype_t enc = CE_NATIVE;
 3488|       |
 3489|    284|    if(known_to_be_latin1) enc = CE_LATIN1;
  ------------------
  |  Branch (3489:8): [True: 0, False: 284]
  ------------------
 3490|    284|    else if(!escaped && known_to_be_utf8) enc = CE_UTF8;
  ------------------
  |  Branch (3490:13): [True: 284, False: 0]
  |  Branch (3490:25): [True: 0, False: 284]
  ------------------
 3491|       |
 3492|    284|    PROTECT(t = allocVector(STRSXP, 1));
  ------------------
  |  |  357|    284|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3493|    284|    SET_STRING_ELT(t, 0, mkCharLenCE(s, (int) len, enc));
  ------------------
  |  | 1001|    284|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
 3494|    284|    UNPROTECT(1); /* t */
  ------------------
  |  |  358|    284|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3495|    284|    return t;
 3496|    284|}
gram.c:StringValue:
 5234|    288|{
 5235|    288|    int quote = c;
 5236|    288|    char currtext[1010], *ct = currtext;
 5237|    288|    char st0[MAXELTSIZE];
 5238|    288|    unsigned int nstext = MAXELTSIZE;
  ------------------
  |  |   85|    288|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
 5239|    288|    char *stext = st0, *bp = st0;
 5240|    288|    PROTECT_INDEX sti;
 5241|    288|    int wcnt = 0;
 5242|    288|    ucs_t wcs[10001];
 5243|    288|    bool oct_or_hex = false, use_wcs = false, currtext_truncated = false;
 5244|       |
 5245|    288|    PROTECT_WITH_INDEX(R_NilValue, &sti);
  ------------------
  |  |  366|    288|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
 5246|    288|    CTEXT_PUSH(c);
  ------------------
  |  | 5212|    288|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|    288|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 288]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|    288|	*ct++ = ((char) c);                                            \
  |  | 5221|    288|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 288]
  |  |  ------------------
  ------------------
 5247|  2.81k|    while ((c = xxgetc()) != R_EOF && c != quote) {
  ------------------
  |  | 1531|  5.62k|#define R_EOF	-1
  ------------------
  |  Branch (5247:12): [True: 2.81k, False: 0]
  |  Branch (5247:39): [True: 2.52k, False: 288]
  ------------------
 5248|  2.52k|	CTEXT_PUSH(c);
  ------------------
  |  | 5212|  2.52k|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|  2.52k|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 2.52k]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|  2.52k|	*ct++ = ((char) c);                                            \
  |  | 5221|  2.52k|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 2.52k]
  |  |  ------------------
  ------------------
 5249|  2.52k|	if (c == '\n') {
  ------------------
  |  Branch (5249:6): [True: 0, False: 2.52k]
  ------------------
 5250|      0|	    xxungetc(c); CTEXT_POP();
  ------------------
  |  | 5222|      0|#define CTEXT_POP() ct--
  ------------------
 5251|       |	    /* Fix suggested by Mark Bravington to allow multiline strings
 5252|       |	     * by pretending we've seen a backslash. Was:
 5253|       |	     * return ERROR;
 5254|       |	     */
 5255|      0|	    c = '\\';
 5256|      0|	}
 5257|  2.52k|	if (c == '\\') {
  ------------------
  |  Branch (5257:6): [True: 32, False: 2.49k]
  ------------------
 5258|     32|	    c = xxgetc();
 5259|     32|	    if (c == R_EOF) break;
  ------------------
  |  | 1531|     32|#define R_EOF	-1
  ------------------
  |  Branch (5259:10): [True: 0, False: 32]
  ------------------
 5260|     32|	    CTEXT_PUSH(c);
  ------------------
  |  | 5212|     32|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|     32|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 32]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|     32|	*ct++ = ((char) c);                                            \
  |  | 5221|     32|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 32]
  |  |  ------------------
  ------------------
 5261|     32|	    if ('0' <= c && c <= '7') {
  ------------------
  |  Branch (5261:10): [True: 32, False: 0]
  |  Branch (5261:22): [True: 0, False: 32]
  ------------------
 5262|      0|		int octal = c - '0';
 5263|      0|		c = xxgetc();
 5264|      0|		if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5264:7): [True: 0, False: 0]
  ------------------
 5265|      0|		if ('0' <= c && c <= '7') {
  ------------------
  |  Branch (5265:7): [True: 0, False: 0]
  |  Branch (5265:19): [True: 0, False: 0]
  ------------------
 5266|      0|		    CTEXT_PUSH(c);
  ------------------
  |  | 5212|      0|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|      0|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|      0|	*ct++ = ((char) c);                                            \
  |  | 5221|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5267|      0|		    octal = 8 * octal + c - '0';
 5268|      0|		    c = xxgetc();
 5269|      0|		    if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5269:11): [True: 0, False: 0]
  ------------------
 5270|      0|		    if ('0' <= c && c <= '7') {
  ------------------
  |  Branch (5270:11): [True: 0, False: 0]
  |  Branch (5270:23): [True: 0, False: 0]
  ------------------
 5271|      0|			CTEXT_PUSH(c);
  ------------------
  |  | 5212|      0|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|      0|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|      0|	*ct++ = ((char) c);                                            \
  |  | 5221|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5272|      0|			octal = 8 * octal + c - '0';
 5273|      0|		    } else {
 5274|      0|			xxungetc(c);
 5275|      0|		    }
 5276|      0|		} else {
 5277|      0|		    xxungetc(c);
 5278|      0|		}
 5279|      0|		if (!octal)
  ------------------
  |  Branch (5279:7): [True: 0, False: 0]
  ------------------
 5280|      0|		    raiseLexError("nulNotAllowed", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 5281|      0|                        _("nul character not allowed (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5282|      0|		if(octal > 0xff)
  ------------------
  |  Branch (5282:6): [True: 0, False: 0]
  ------------------
 5283|      0|		    raiseLexError("invalidOctal", INT_VALUE, &octal,
  ------------------
  |  |  313|      0|#define INT_VALUE 2
  ------------------
 5284|      0|                        _("\\%o exceeds maximum allowed octal value \\377 (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5285|      0|		c = octal;
 5286|      0|		oct_or_hex = true;
 5287|      0|	    }
 5288|     32|	    else if(c == 'x') {
  ------------------
  |  Branch (5288:14): [True: 0, False: 32]
  ------------------
 5289|      0|		int val = 0; int i, ext;
 5290|      0|		for(i = 0; i < 2; i++) {
  ------------------
  |  Branch (5290:14): [True: 0, False: 0]
  ------------------
 5291|      0|		    c = xxgetc();
 5292|      0|		    if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5292:11): [True: 0, False: 0]
  ------------------
 5293|      0|		    CTEXT_PUSH(c);
  ------------------
  |  | 5212|      0|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|      0|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|      0|	*ct++ = ((char) c);                                            \
  |  | 5221|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5294|      0|		    if(c >= '0' && c <= '9') ext = c - '0';
  ------------------
  |  Branch (5294:10): [True: 0, False: 0]
  |  Branch (5294:22): [True: 0, False: 0]
  ------------------
 5295|      0|		    else if (c >= 'A' && c <= 'F') ext = c - 'A' + 10;
  ------------------
  |  Branch (5295:16): [True: 0, False: 0]
  |  Branch (5295:28): [True: 0, False: 0]
  ------------------
 5296|      0|		    else if (c >= 'a' && c <= 'f') ext = c - 'a' + 10;
  ------------------
  |  Branch (5296:16): [True: 0, False: 0]
  |  Branch (5296:28): [True: 0, False: 0]
  ------------------
 5297|      0|		    else {
 5298|      0|			xxungetc(c);
 5299|      0|			CTEXT_POP();
  ------------------
  |  | 5222|      0|#define CTEXT_POP() ct--
  ------------------
 5300|      0|			if (i == 0) { /* was just \x */
  ------------------
  |  Branch (5300:8): [True: 0, False: 0]
  ------------------
 5301|      0|			    *ct = '\0';
 5302|      0|			    raiseLexError("badHex", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 5303|      0|			        _("'\\x' used without hex digits in character string (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5304|      0|			}
 5305|      0|			break;
 5306|      0|		    }
 5307|      0|		    val = 16*val + ext;
 5308|      0|		}
 5309|      0|		if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5309:7): [True: 0, False: 0]
  ------------------
 5310|      0|		if (!val)
  ------------------
  |  Branch (5310:7): [True: 0, False: 0]
  ------------------
 5311|      0|		    raiseLexError("nulNotAllowed", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 5312|      0|                        _("nul character not allowed (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5313|      0|		c = val;
 5314|      0|		oct_or_hex = true;
 5315|      0|	    }
 5316|     32|	    else if(c == 'u') {
  ------------------
  |  Branch (5316:14): [True: 0, False: 32]
  ------------------
 5317|      0|		unsigned int val = 0; int i, ext; 
 5318|      0|		bool delim = false;
 5319|       |
 5320|      0|		if(forSymbol) 
  ------------------
  |  Branch (5320:6): [True: 0, False: 0]
  ------------------
 5321|      0|		    raiseLexError("unicodeInBackticks", NO_VALUE, NULL, 
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 5322|      0|		        _("\\uxxxx sequences not supported inside backticks (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5323|      0|		c = xxgetc();
 5324|      0|		if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5324:7): [True: 0, False: 0]
  ------------------
 5325|      0|		if (c == '{') {
  ------------------
  |  Branch (5325:7): [True: 0, False: 0]
  ------------------
 5326|      0|		    delim = true;
 5327|      0|		    CTEXT_PUSH(c);
  ------------------
  |  | 5212|      0|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|      0|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|      0|	*ct++ = ((char) c);                                            \
  |  | 5221|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5328|      0|		} else xxungetc(c);
 5329|      0|		for(i = 0; i < 4; i++) {
  ------------------
  |  Branch (5329:14): [True: 0, False: 0]
  ------------------
 5330|      0|		    c = xxgetc();
 5331|      0|		    if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5331:11): [True: 0, False: 0]
  ------------------
 5332|      0|		    CTEXT_PUSH(c);
  ------------------
  |  | 5212|      0|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|      0|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|      0|	*ct++ = ((char) c);                                            \
  |  | 5221|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5333|      0|		    if(c >= '0' && c <= '9') ext = c - '0';
  ------------------
  |  Branch (5333:10): [True: 0, False: 0]
  |  Branch (5333:22): [True: 0, False: 0]
  ------------------
 5334|      0|		    else if (c >= 'A' && c <= 'F') ext = c - 'A' + 10;
  ------------------
  |  Branch (5334:16): [True: 0, False: 0]
  |  Branch (5334:28): [True: 0, False: 0]
  ------------------
 5335|      0|		    else if (c >= 'a' && c <= 'f') ext = c - 'a' + 10;
  ------------------
  |  Branch (5335:16): [True: 0, False: 0]
  |  Branch (5335:28): [True: 0, False: 0]
  ------------------
 5336|      0|		    else {
 5337|      0|			xxungetc(c);
 5338|      0|			CTEXT_POP();
  ------------------
  |  | 5222|      0|#define CTEXT_POP() ct--
  ------------------
 5339|      0|			if (i == 0) { /* was just \u */
  ------------------
  |  Branch (5339:8): [True: 0, False: 0]
  ------------------
 5340|      0|			    *ct = '\0';
 5341|      0|			    raiseLexError("badUnicodeHex", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 5342|      0|			        _("'\\u' used without hex digits in character string (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5343|      0|			}
 5344|      0|			break;
 5345|      0|		    }
 5346|      0|		    val = 16*val + ext;
 5347|      0|		}
 5348|      0|		if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5348:7): [True: 0, False: 0]
  ------------------
 5349|      0|		if(delim) {
  ------------------
  |  Branch (5349:6): [True: 0, False: 0]
  ------------------
 5350|      0|		    c = xxgetc();
 5351|      0|		    if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5351:11): [True: 0, False: 0]
  ------------------
 5352|      0|		    if (c != '}')
  ------------------
  |  Branch (5352:11): [True: 0, False: 0]
  ------------------
 5353|      0|			raiseLexError("invalidUnicode", NO_VALUE, NULL, 
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 5354|      0|			    _("invalid \\u{xxxx} sequence (line %d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5355|      0|		    else CTEXT_PUSH(c);
  ------------------
  |  | 5212|      0|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|      0|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|      0|	*ct++ = ((char) c);                                            \
  |  | 5221|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5356|      0|		}
 5357|      0|		if (!val)
  ------------------
  |  Branch (5357:7): [True: 0, False: 0]
  ------------------
 5358|      0|		    raiseLexError("nulNotAllowed", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 5359|      0|                        _("nul character not allowed (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5360|      0|		WTEXT_PUSH(val); /* this assumes wchar_t is Unicode */
  ------------------
  |  | 5155|      0|#define WTEXT_PUSH(c) do { if(wcnt < 10000) wcs[wcnt++] = c; } while(0)
  |  |  ------------------
  |  |  |  Branch (5155:31): [True: 0, False: 0]
  |  |  |  Branch (5155:70): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5361|      0|		use_wcs = true;
 5362|      0|		continue;
 5363|      0|	    }
 5364|     32|	    else if(c == 'U') {
  ------------------
  |  Branch (5364:14): [True: 0, False: 32]
  ------------------
 5365|      0|		unsigned int val = 0; int i, ext;
 5366|      0|		bool delim = false;
 5367|      0|		if(forSymbol) 
  ------------------
  |  Branch (5367:6): [True: 0, False: 0]
  ------------------
 5368|      0|		    raiseLexError("unicodeInBackticks", NO_VALUE, NULL, 
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 5369|      0|		        _("\\Uxxxxxxxx sequences not supported inside backticks (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5370|      0|		c = xxgetc();
 5371|      0|		if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5371:7): [True: 0, False: 0]
  ------------------
 5372|      0| 		if (c == '{') {
  ------------------
  |  Branch (5372:8): [True: 0, False: 0]
  ------------------
 5373|      0|		    delim = true;
 5374|      0|		    CTEXT_PUSH(c);
  ------------------
  |  | 5212|      0|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|      0|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|      0|	*ct++ = ((char) c);                                            \
  |  | 5221|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5375|      0|		} else xxungetc(c);
 5376|      0|		for(i = 0; i < 8; i++) {
  ------------------
  |  Branch (5376:14): [True: 0, False: 0]
  ------------------
 5377|      0|		    c = xxgetc();
 5378|      0|		    if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5378:11): [True: 0, False: 0]
  ------------------
 5379|      0|		    CTEXT_PUSH(c);
  ------------------
  |  | 5212|      0|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|      0|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|      0|	*ct++ = ((char) c);                                            \
  |  | 5221|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5380|      0|		    if(c >= '0' && c <= '9') ext = c - '0';
  ------------------
  |  Branch (5380:10): [True: 0, False: 0]
  |  Branch (5380:22): [True: 0, False: 0]
  ------------------
 5381|      0|		    else if (c >= 'A' && c <= 'F') ext = c - 'A' + 10;
  ------------------
  |  Branch (5381:16): [True: 0, False: 0]
  |  Branch (5381:28): [True: 0, False: 0]
  ------------------
 5382|      0|		    else if (c >= 'a' && c <= 'f') ext = c - 'a' + 10;
  ------------------
  |  Branch (5382:16): [True: 0, False: 0]
  |  Branch (5382:28): [True: 0, False: 0]
  ------------------
 5383|      0|		    else {
 5384|      0|			xxungetc(c);
 5385|      0|			CTEXT_POP();
  ------------------
  |  | 5222|      0|#define CTEXT_POP() ct--
  ------------------
 5386|      0|			if (i == 0) { /* was just \U */
  ------------------
  |  Branch (5386:8): [True: 0, False: 0]
  ------------------
 5387|      0|			    *ct = '\0';
 5388|      0|			    raiseLexError("badUnicodeHex", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 5389|      0|			        _("'\\U' used without hex digits in character string (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5390|      0|			}
 5391|      0|			break;
 5392|      0|		    }
 5393|      0|		    val = 16*val + ext;
 5394|      0|		}
 5395|      0|		if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5395:7): [True: 0, False: 0]
  ------------------
 5396|      0|		if(delim) {
  ------------------
  |  Branch (5396:6): [True: 0, False: 0]
  ------------------
 5397|      0|		    c = xxgetc();
 5398|      0|		    if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5398:11): [True: 0, False: 0]
  ------------------
 5399|      0|		    if (c != '}')
  ------------------
  |  Branch (5399:11): [True: 0, False: 0]
  ------------------
 5400|      0|			raiseLexError("invalidUnicode", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 5401|      0|			    _("invalid \\U{xxxxxxxx} sequence (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5402|      0|		    else CTEXT_PUSH(c);
  ------------------
  |  | 5212|      0|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|      0|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|      0|	*ct++ = ((char) c);                                            \
  |  | 5221|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5403|      0|		}
 5404|      0|		if (!val)
  ------------------
  |  Branch (5404:7): [True: 0, False: 0]
  ------------------
 5405|      0|		    raiseLexError("nulNotAllowed", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 5406|      0|                        _("nul character not allowed (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5407|      0|		if (val > 0x10FFFF) {
  ------------------
  |  Branch (5407:7): [True: 0, False: 0]
  ------------------
 5408|      0|		    if(delim)
  ------------------
  |  Branch (5408:10): [True: 0, False: 0]
  ------------------
 5409|      0|			raiseLexError("invalidUnicode", INT_VALUE, &val,
  ------------------
  |  |  313|      0|#define INT_VALUE 2
  ------------------
 5410|      0|			    _("invalid \\U{xxxxxxxx} value %6x (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5411|      0|		    else
 5412|      0|			raiseLexError("invalidUnicode", INT_VALUE, &val,
  ------------------
  |  |  313|      0|#define INT_VALUE 2
  ------------------
 5413|      0|			    _("invalid \\Uxxxxxxxx value %6x (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5414|      0|		}
 5415|       |#ifdef Win32
 5416|       |		if (0x010000 <= val && val <= 0x10FFFF) {   /* Need surrogate pair in Windows */
 5417|       |		    val = val - 0x010000;
 5418|       |		    WTEXT_PUSH( 0xD800 | (val >> 10) );
 5419|       |		    val = 0xDC00 | (val & 0x03FF);
 5420|       |		}
 5421|       |#endif
 5422|      0|		WTEXT_PUSH(val);
  ------------------
  |  | 5155|      0|#define WTEXT_PUSH(c) do { if(wcnt < 10000) wcs[wcnt++] = c; } while(0)
  |  |  ------------------
  |  |  |  Branch (5155:31): [True: 0, False: 0]
  |  |  |  Branch (5155:70): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5423|      0|		use_wcs = true;
 5424|      0|		continue;
 5425|      0|	    }
 5426|     32|	    else {
 5427|     32|		switch (c) {
 5428|      0|		case 'a':
  ------------------
  |  Branch (5428:3): [True: 0, False: 32]
  ------------------
 5429|      0|		    c = '\a';
 5430|      0|		    break;
 5431|      0|		case 'b':
  ------------------
  |  Branch (5431:3): [True: 0, False: 32]
  ------------------
 5432|      0|		    c = '\b';
 5433|      0|		    break;
 5434|      0|		case 'f':
  ------------------
  |  Branch (5434:3): [True: 0, False: 32]
  ------------------
 5435|      0|		    c = '\f';
 5436|      0|		    break;
 5437|     30|		case 'n':
  ------------------
  |  Branch (5437:3): [True: 30, False: 2]
  ------------------
 5438|     30|		    c = '\n';
 5439|     30|		    break;
 5440|      0|		case 'r':
  ------------------
  |  Branch (5440:3): [True: 0, False: 32]
  ------------------
 5441|      0|		    c = '\r';
 5442|      0|		    break;
 5443|      0|		case 't':
  ------------------
  |  Branch (5443:3): [True: 0, False: 32]
  ------------------
 5444|      0|		    c = '\t';
 5445|      0|		    break;
 5446|      0|		case 'v':
  ------------------
  |  Branch (5446:3): [True: 0, False: 32]
  ------------------
 5447|      0|		    c = '\v';
 5448|      0|		    break;
 5449|      2|		case '\\':
  ------------------
  |  Branch (5449:3): [True: 2, False: 30]
  ------------------
 5450|      2|		case '"':
  ------------------
  |  Branch (5450:3): [True: 0, False: 32]
  ------------------
 5451|      2|		case '\'':
  ------------------
  |  Branch (5451:3): [True: 0, False: 32]
  ------------------
 5452|      2|		case '`':
  ------------------
  |  Branch (5452:3): [True: 0, False: 32]
  ------------------
 5453|      2|		case ' ':
  ------------------
  |  Branch (5453:3): [True: 0, False: 32]
  ------------------
 5454|      2|		case '\n':
  ------------------
  |  Branch (5454:3): [True: 0, False: 32]
  ------------------
 5455|      2|		    break;
 5456|      0|		default: {
  ------------------
  |  Branch (5456:3): [True: 0, False: 32]
  ------------------
 5457|      0|		    char ch[2];
 5458|      0|		    ch[0] = (char) c;
 5459|      0|		    ch[1] = '\0';
 5460|      0|		    raiseLexError("unrecognizedEscape", STRING_VALUE, ch,
  ------------------
  |  |  312|      0|#define STRING_VALUE 1
  ------------------
 5461|      0|		        _("'\\%s' is an unrecognized escape in character string (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5462|      0|		  }
 5463|     32|		}
 5464|     32|	    }
 5465|  2.49k|	} else if(mbcslocale) {
  ------------------
  |  Branch (5465:12): [True: 0, False: 2.49k]
  ------------------
 5466|      0|	    ucs_t wc;
 5467|      0|	    int clen = mbcs_get_next2(c, &wc);
  ------------------
  |  | 5102|      0|# define mbcs_get_next2 mbcs_get_next
  ------------------
 5468|      0|	    if (clen == -1) { /* EOF whilst reading MBCS char */
  ------------------
  |  Branch (5468:10): [True: 0, False: 0]
  ------------------
 5469|      0|		xxungetc(c);
 5470|      0|		c = R_EOF;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
 5471|      0|		break;
 5472|      0|	    }
 5473|      0|	    BIDI_CHECK(wc);
  ------------------
  |  | 5225|      0|#define BIDI_CHECK(wc) do {                                           \
  |  | 5226|      0|	if((wc) >= 0x202A && (wc) <= 0x2069 &&                        \
  |  |  ------------------
  |  |  |  Branch (5226:5): [True: 0, False: 0]
  |  |  |  Branch (5226:23): [True: 0, False: 0]
  |  |  ------------------
  |  | 5227|      0|	  !((wc) > 0x202E && (wc) < 0x2066))                          \
  |  |  ------------------
  |  |  |  Branch (5227:6): [True: 0, False: 0]
  |  |  |  Branch (5227:23): [True: 0, False: 0]
  |  |  ------------------
  |  | 5228|      0|	    raiseLexError("bidiNotAllowed", UCS_VALUE, &wc,           \
  |  |  ------------------
  |  |  |  |  316|      0|#define UCS_VALUE 5
  |  |  ------------------
  |  | 5229|      0|	        _("bidi formatting not allowed, use escapes instead (\\u%04x) (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 5230|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (5230:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5474|      0|	    WTEXT_PUSH(wc);
  ------------------
  |  | 5155|      0|#define WTEXT_PUSH(c) do { if(wcnt < 10000) wcs[wcnt++] = c; } while(0)
  |  |  ------------------
  |  |  |  Branch (5155:31): [True: 0, False: 0]
  |  |  |  Branch (5155:70): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5475|      0|	    ParseState.xxbyteno += clen-1;
 5476|       |	    
 5477|      0|	    for(int i = 0; i < clen - 1; i++){
  ------------------
  |  Branch (5477:21): [True: 0, False: 0]
  ------------------
 5478|      0|		STEXT_PUSH(c);
  ------------------
  |  | 5075|      0|#define STEXT_PUSH(c) do {                  \
  |  | 5076|      0|	size_t nc = bp - stext;             \
  |  | 5077|      0|	if (nc >= nstext - 1) {             \
  |  |  ------------------
  |  |  |  Branch (5077:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5078|      0|	    char *old = stext;              \
  |  | 5079|      0|	    SEXP st1;		            \
  |  | 5080|      0|	    nstext *= 2;                    \
  |  | 5081|      0|	    PROTECT(st1 = allocVector(RAWSXP, nstext)); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  | 5082|      0|	    stext = (char *)RAW(st1);       \
  |  | 5083|      0|	    memmove(stext, old, nc);        \
  |  | 5084|      0|	    REPROTECT(st1, sti);	    \
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  | 5085|      0|	    UNPROTECT(1); /* st1 */         \
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  | 5086|      0|	    bp = stext+nc; }		    \
  |  | 5087|      0|	*bp++ = ((char) c);		    \
  |  | 5088|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (5088:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5479|      0|		c = xxgetc();
 5480|      0|		if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5480:7): [True: 0, False: 0]
  ------------------
 5481|      0|		CTEXT_PUSH(c);
  ------------------
  |  | 5212|      0|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|      0|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|      0|	*ct++ = ((char) c);                                            \
  |  | 5221|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5482|      0|		if (c == '\n') {
  ------------------
  |  Branch (5482:7): [True: 0, False: 0]
  ------------------
 5483|      0|		    xxungetc(c); CTEXT_POP();
  ------------------
  |  | 5222|      0|#define CTEXT_POP() ct--
  ------------------
 5484|      0|		    c = '\\';
 5485|      0|		}
 5486|      0|	    }
 5487|      0|	    if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5487:10): [True: 0, False: 0]
  ------------------
 5488|      0|	    STEXT_PUSH(c);
  ------------------
  |  | 5075|      0|#define STEXT_PUSH(c) do {                  \
  |  | 5076|      0|	size_t nc = bp - stext;             \
  |  | 5077|      0|	if (nc >= nstext - 1) {             \
  |  |  ------------------
  |  |  |  Branch (5077:6): [True: 0, False: 0]
  |  |  ------------------
  |  | 5078|      0|	    char *old = stext;              \
  |  | 5079|      0|	    SEXP st1;		            \
  |  | 5080|      0|	    nstext *= 2;                    \
  |  | 5081|      0|	    PROTECT(st1 = allocVector(RAWSXP, nstext)); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  | 5082|      0|	    stext = (char *)RAW(st1);       \
  |  | 5083|      0|	    memmove(stext, old, nc);        \
  |  | 5084|      0|	    REPROTECT(st1, sti);	    \
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  | 5085|      0|	    UNPROTECT(1); /* st1 */         \
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  | 5086|      0|	    bp = stext+nc; }		    \
  |  | 5087|      0|	*bp++ = ((char) c);		    \
  |  | 5088|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (5088:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5489|      0|	    continue;
 5490|      0|	}
 5491|  2.52k|	STEXT_PUSH(c);
  ------------------
  |  | 5075|  2.52k|#define STEXT_PUSH(c) do {                  \
  |  | 5076|  2.52k|	size_t nc = bp - stext;             \
  |  | 5077|  2.52k|	if (nc >= nstext - 1) {             \
  |  |  ------------------
  |  |  |  Branch (5077:6): [True: 0, False: 2.52k]
  |  |  ------------------
  |  | 5078|      0|	    char *old = stext;              \
  |  | 5079|      0|	    SEXP st1;		            \
  |  | 5080|      0|	    nstext *= 2;                    \
  |  | 5081|      0|	    PROTECT(st1 = allocVector(RAWSXP, nstext)); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  | 5082|      0|	    stext = (char *)RAW(st1);       \
  |  | 5083|      0|	    memmove(stext, old, nc);        \
  |  | 5084|      0|	    REPROTECT(st1, sti);	    \
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  | 5085|      0|	    UNPROTECT(1); /* st1 */         \
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  | 5086|      0|	    bp = stext+nc; }		    \
  |  | 5087|  2.52k|	*bp++ = ((char) c);		    \
  |  | 5088|  2.52k|} while(0)
  |  |  ------------------
  |  |  |  Branch (5088:9): [Folded, False: 2.52k]
  |  |  ------------------
  ------------------
 5492|  2.52k|	if ((unsigned int) c < 0x80) WTEXT_PUSH(c);
  ------------------
  |  | 5155|  2.52k|#define WTEXT_PUSH(c) do { if(wcnt < 10000) wcs[wcnt++] = c; } while(0)
  |  |  ------------------
  |  |  |  Branch (5155:31): [True: 2.52k, False: 0]
  |  |  |  Branch (5155:70): [Folded, False: 2.52k]
  |  |  ------------------
  ------------------
  |  Branch (5492:6): [True: 2.52k, False: 0]
  ------------------
 5493|      0|	else { 
 5494|       |	    /* have an 8-bit char in the current encoding */
 5495|       |	    /* FIXME: `wc` values will be wrong when native encoding differs
 5496|       |	       from that indicated by `known_to_be*` */
 5497|      0|	    int res = 0;
 5498|       |#ifdef WC_NOT_UNICODE
 5499|       |	    ucs_t wc;
 5500|       |	    char s[2] = " ";
 5501|       |	    s[0] = (char) c;
 5502|       |	    res = (int) mbtoucs(&wc, s, 2);
 5503|       |#else
 5504|      0|	    wchar_t wc;
 5505|      0|	    char s[2] = " ";
 5506|      0|	    s[0] = (char) c;
 5507|       |	    /* This is not necessarily correct for stateful SBCS */
 5508|      0|	    mbstate_t mb_st;
 5509|      0|	    mbs_init(&mb_st);
  ------------------
  |  | 2454|      0|#define mbs_init(x) memset(x, 0, sizeof(mbstate_t))
  ------------------
 5510|      0|	    res = (int) mbrtowc(&wc, s, 2, &mb_st);
 5511|      0|#endif
 5512|      0|	    if(res < 0) wc = 0xFFFD; /* placeholder for invalid encoding */
  ------------------
  |  Branch (5512:9): [True: 0, False: 0]
  ------------------
 5513|      0|	    WTEXT_PUSH(wc);
  ------------------
  |  | 5155|      0|#define WTEXT_PUSH(c) do { if(wcnt < 10000) wcs[wcnt++] = c; } while(0)
  |  |  ------------------
  |  |  |  Branch (5155:31): [True: 0, False: 0]
  |  |  |  Branch (5155:70): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5514|      0|	}
 5515|  2.52k|    }
 5516|    288|    STEXT_PUSH('\0');
  ------------------
  |  | 5075|    288|#define STEXT_PUSH(c) do {                  \
  |  | 5076|    288|	size_t nc = bp - stext;             \
  |  | 5077|    288|	if (nc >= nstext - 1) {             \
  |  |  ------------------
  |  |  |  Branch (5077:6): [True: 0, False: 288]
  |  |  ------------------
  |  | 5078|      0|	    char *old = stext;              \
  |  | 5079|      0|	    SEXP st1;		            \
  |  | 5080|      0|	    nstext *= 2;                    \
  |  | 5081|      0|	    PROTECT(st1 = allocVector(RAWSXP, nstext)); \
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  | 5082|      0|	    stext = (char *)RAW(st1);       \
  |  | 5083|      0|	    memmove(stext, old, nc);        \
  |  | 5084|      0|	    REPROTECT(st1, sti);	    \
  |  |  ------------------
  |  |  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  |  |  ------------------
  |  | 5085|      0|	    UNPROTECT(1); /* st1 */         \
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  | 5086|      0|	    bp = stext+nc; }		    \
  |  | 5087|    288|	*bp++ = ((char) c);		    \
  |  | 5088|    288|} while(0)
  |  |  ------------------
  |  |  |  Branch (5088:9): [Folded, False: 288]
  |  |  ------------------
  ------------------
 5517|    288|    WTEXT_PUSH(0);
  ------------------
  |  | 5155|    288|#define WTEXT_PUSH(c) do { if(wcnt < 10000) wcs[wcnt++] = c; } while(0)
  |  |  ------------------
  |  |  |  Branch (5155:31): [True: 288, False: 0]
  |  |  |  Branch (5155:70): [Folded, False: 288]
  |  |  ------------------
  ------------------
 5518|    288|    yytext[0] = '\0';
 5519|    288|    if (c == R_EOF) {
  ------------------
  |  | 1531|    288|#define R_EOF	-1
  ------------------
  |  Branch (5519:9): [True: 0, False: 288]
  ------------------
 5520|      0|	PRESERVE_SV(yylval = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 5521|      0|	UNPROTECT(1); /* release stext */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 5522|      0|    	return INCOMPLETE_STRING;
  ------------------
  |  |  593|      0|#define INCOMPLETE_STRING 265
  ------------------
 5523|    288|    } else {
 5524|    288|    	CTEXT_PUSH(c);
  ------------------
  |  | 5212|    288|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|    288|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 288]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|    288|	*ct++ = ((char) c);                                            \
  |  | 5221|    288|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 288]
  |  |  ------------------
  ------------------
 5525|    288|    	CTEXT_PUSH('\0');
  ------------------
  |  | 5212|    288|#define CTEXT_PUSH(c) do {                                             \
  |  | 5213|    288|	if (ct - currtext >= 1000) {                                   \
  |  |  ------------------
  |  |  |  Branch (5213:6): [True: 0, False: 288]
  |  |  ------------------
  |  | 5214|      0|	    int skip = skipBytesByChar(currtext, 100 + 4);             \
  |  | 5215|      0|	    memmove(currtext, "... ", 4);                              \
  |  | 5216|      0|	    memmove(currtext + 4, currtext + skip, 1000 - skip + 1);   \
  |  | 5217|      0|	    ct -= skip - 4;                                            \
  |  | 5218|      0|	    currtext_truncated = true;                                 \
  |  | 5219|      0|	}                                                              \
  |  | 5220|    288|	*ct++ = ((char) c);                                            \
  |  | 5221|    288|} while(0)
  |  |  ------------------
  |  |  |  Branch (5221:9): [Folded, False: 288]
  |  |  ------------------
  ------------------
 5526|    288|    }
 5527|    288|    if (!currtext_truncated)
  ------------------
  |  Branch (5527:9): [True: 288, False: 0]
  ------------------
 5528|    288|    	strcpy(yytext, currtext);
 5529|      0|    else if (forSymbol || !use_wcs) {
  ------------------
  |  Branch (5529:14): [True: 0, False: 0]
  |  Branch (5529:27): [True: 0, False: 0]
  ------------------
 5530|      0|        size_t total = strlen(stext);
 5531|      0|        snprintf(yytext, MAXELTSIZE, "[%u chars quoted with '%c']", (unsigned int)total, quote);
  ------------------
  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
 5532|      0|    } else 
 5533|      0|        snprintf(yytext, MAXELTSIZE, "[%d wide chars quoted with '%c']", wcnt, quote);
  ------------------
  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
 5534|    288|    if(forSymbol) {
  ------------------
  |  Branch (5534:8): [True: 4, False: 284]
  ------------------
 5535|      4|	PRESERVE_SV(yylval = install(stext));
  ------------------
  |  |  350|      4|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      4|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 5536|      4|	UNPROTECT(1); /* release stext */
  ------------------
  |  |  358|      4|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 5537|      4|	return SYMBOL;
  ------------------
  |  |  591|      4|#define SYMBOL 263
  ------------------
 5538|    284|    } else {
 5539|    284|	if(use_wcs) {
  ------------------
  |  Branch (5539:5): [True: 0, False: 284]
  ------------------
 5540|      0|	    if(oct_or_hex)
  ------------------
  |  Branch (5540:9): [True: 0, False: 0]
  ------------------
 5541|      0|		raiseLexError("mixedEscapes", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 5542|      0|		    _("mixing Unicode and octal/hex escapes in a string is not allowed (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5543|      0|	    if(wcnt < 10000)
  ------------------
  |  Branch (5543:9): [True: 0, False: 0]
  ------------------
 5544|      0|		PRESERVE_SV(yylval = mkStringUTF8(wcs, wcnt)); /* include terminator */
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 5545|      0|	    else
 5546|      0|		raiseLexError("UnicodeTooLong", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 5547|      0|		    _("string containing Unicode escapes not in this locale\n"
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 5548|      0|		      "is too long (max 10000 chars) (%s:%d:%d)"));
 5549|      0|	} else
 5550|    284|	    PRESERVE_SV(yylval = mkString2(stext,  bp - stext - 1, oct_or_hex));
  ------------------
  |  |  350|    284|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|    284|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 5551|    284|	UNPROTECT(1); /* release stext */
  ------------------
  |  |  358|    284|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 5552|    284|	return STR_CONST;
  ------------------
  |  |  588|    284|#define STR_CONST 260
  ------------------
 5553|    284|    }
 5554|    288|}
gram.c:SpecialValue:
 5696|     50|{
 5697|     50|    DECLARE_YYTEXT_BUFP(yyp);
  ------------------
  |  | 2908|     50|#define DECLARE_YYTEXT_BUFP(bp) char *bp = yytext ;
  ------------------
 5698|     50|    YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|     50|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|     50|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 50]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|     50|    *(bp)++ = ((char)c);			\
  |  | 2915|     50|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 50]
  |  |  ------------------
  ------------------
 5699|     56|    while ((c = xxgetc()) != R_EOF && c != '%') {
  ------------------
  |  | 1531|    112|#define R_EOF	-1
  ------------------
  |  Branch (5699:12): [True: 56, False: 0]
  |  Branch (5699:39): [True: 6, False: 50]
  ------------------
 5700|      6|	if (c == '\n') {
  ------------------
  |  Branch (5700:6): [True: 0, False: 6]
  ------------------
 5701|      0|	    xxungetc(c);
 5702|      0|	    return ERROR;
  ------------------
  |  |  587|      0|#define ERROR 259
  ------------------
 5703|      0|	}
 5704|      6|	YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|      6|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      6|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 6]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      6|    *(bp)++ = ((char)c);			\
  |  | 2915|      6|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 6]
  |  |  ------------------
  ------------------
 5705|      6|    }
 5706|     50|    if (c == '%')
  ------------------
  |  Branch (5706:9): [True: 50, False: 0]
  ------------------
 5707|     50|	YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|     50|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|     50|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 50]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|     50|    *(bp)++ = ((char)c);			\
  |  | 2915|     50|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 50]
  |  |  ------------------
  ------------------
 5708|     50|    YYTEXT_PUSH('\0', yyp);
  ------------------
  |  | 2909|     50|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|     50|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 50]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|     50|    *(bp)++ = ((char)c);			\
  |  | 2915|     50|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 50]
  |  |  ------------------
  ------------------
 5709|     50|    yylval = install(yytext);
  ------------------
  |  | 2019|     50|# define yylval			Rf_yylval
  ------------------
                  yylval = install(yytext);
  ------------------
  |  |  934|     50|#define install			Rf_install
  ------------------
 5710|     50|    return SPECIAL;
  ------------------
  |  |  634|     50|#define SPECIAL 306
  ------------------
 5711|     50|}
gram.c:SymbolValue:
 5764|  2.44k|{
 5765|  2.44k|    int kw;
 5766|  2.44k|    DECLARE_YYTEXT_BUFP(yyp);
  ------------------
  |  | 2908|  2.44k|#define DECLARE_YYTEXT_BUFP(bp) char *bp = yytext ;
  ------------------
 5767|  2.44k|    if(mbcslocale) {
  ------------------
  |  Branch (5767:8): [True: 0, False: 2.44k]
  ------------------
 5768|       |	// FIXME potentially need R_wchar_t with UTF-8 Windows.
 5769|      0|	wchar_t wc; int i, clen;
 5770|      0|	clen = mbcs_get_next(c, &wc);
 5771|      0|	while(clen != -1) {
  ------------------
  |  Branch (5771:8): [True: 0, False: 0]
  ------------------
 5772|       |	    /* at this point we have seen one char, so push its bytes
 5773|       |	       and get one more */
 5774|      0|	    for(i = 0; i < clen; i++) {
  ------------------
  |  Branch (5774:17): [True: 0, False: 0]
  ------------------
 5775|      0|		YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|      0|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|      0|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|      0|    *(bp)++ = ((char)c);			\
  |  | 2915|      0|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
 5776|      0|		c = xxgetc();
 5777|      0|	    }
 5778|      0|	    if(c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (5778:9): [True: 0, False: 0]
  ------------------
 5779|      0|	    if(c == '.' || c == '_') {
  ------------------
  |  Branch (5779:9): [True: 0, False: 0]
  |  Branch (5779:21): [True: 0, False: 0]
  ------------------
 5780|      0|		clen = 1;
 5781|      0|		continue;
 5782|      0|	    }
 5783|      0|	    clen = mbcs_get_next(c, &wc);
 5784|      0|	    if (clen == -1) break; /* EOF whilst reading MBCS char */
  ------------------
  |  Branch (5784:10): [True: 0, False: 0]
  ------------------
 5785|      0|	    if(!iswalnum(wc)) break;
  ------------------
  |  Branch (5785:9): [True: 0, False: 0]
  ------------------
 5786|      0|	}
 5787|      0|    } else
 5788|  14.0k|	do {
 5789|  14.0k|	    YYTEXT_PUSH(c, yyp);
  ------------------
  |  | 2909|  14.0k|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|  14.0k|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 14.0k]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|  14.0k|    *(bp)++ = ((char)c);			\
  |  | 2915|  14.0k|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 14.0k]
  |  |  ------------------
  ------------------
 5790|  14.0k|	} while ((c = xxgetc()) != R_EOF &&
  ------------------
  |  | 1531|  28.0k|#define R_EOF	-1
  ------------------
  |  Branch (5790:11): [True: 14.0k, False: 0]
  ------------------
 5791|  14.0k|		 (isalnum(c) || c == '.' || c == '_'));
  ------------------
  |  Branch (5791:5): [True: 11.2k, False: 2.79k]
  |  Branch (5791:19): [True: 296, False: 2.49k]
  |  Branch (5791:31): [True: 48, False: 2.44k]
  ------------------
 5792|  2.44k|    xxungetc(c);
 5793|  2.44k|    YYTEXT_PUSH('\0', yyp);
  ------------------
  |  | 2909|  2.44k|#define YYTEXT_PUSH(c, bp) do { \
  |  | 2910|  2.44k|    if ((bp) - yytext >= sizeof(yytext) - 1){ \
  |  |  ------------------
  |  |  |  Branch (2910:9): [True: 0, False: 2.44k]
  |  |  ------------------
  |  | 2911|      0|		raiseLexError("bufferOverflow", NO_VALUE, NULL, \
  |  |  ------------------
  |  |  |  |  311|      0|#define NO_VALUE 0
  |  |  ------------------
  |  | 2912|      0|		    _("input buffer overflow (%s:%d:%d)")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2913|      0|	} \
  |  | 2914|  2.44k|    *(bp)++ = ((char)c);			\
  |  | 2915|  2.44k|} while(0) ;
  |  |  ------------------
  |  |  |  Branch (2915:9): [Folded, False: 2.44k]
  |  |  ------------------
  ------------------
 5794|  2.44k|    if ((kw = KeywordLookup(yytext))) 
  ------------------
  |  Branch (5794:9): [True: 322, False: 2.12k]
  ------------------
 5795|    322|	return kw;
 5796|       |    
 5797|  2.12k|    PRESERVE_SV(yylval = install(yytext));
  ------------------
  |  |  350|  2.12k|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|  2.12k|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 5798|  2.12k|    return SYMBOL;
  ------------------
  |  |  591|  2.12k|#define SYMBOL 263
  ------------------
 5799|  2.44k|}
gram.c:KeywordLookup:
 4551|  2.44k|{
 4552|  2.44k|    int i;
 4553|  47.6k|    for (i = 0; keywords[i].name; i++) {
  ------------------
  |  Branch (4553:17): [True: 45.5k, False: 2.12k]
  ------------------
 4554|  45.5k|	if (strcmp(keywords[i].name, s) == 0) {
  ------------------
  |  Branch (4554:6): [True: 322, False: 45.2k]
  ------------------
 4555|    322|	    switch (keywords[i].token) {
  ------------------
  |  Branch (4555:14): [True: 322, False: 0]
  ------------------
 4556|     22|	    case NULL_CONST:
  ------------------
  |  |  590|     22|#define NULL_CONST 262
  ------------------
  |  Branch (4556:6): [True: 22, False: 300]
  ------------------
 4557|     22|		PRESERVE_SV(yylval = R_NilValue);
  ------------------
  |  |  350|     22|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     22|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 4558|     22|		break;
 4559|    106|	    case NUM_CONST:
  ------------------
  |  |  589|    106|#define NUM_CONST 261
  ------------------
  |  Branch (4559:6): [True: 106, False: 216]
  ------------------
 4560|    106|		if(GenerateCode) {
  ------------------
  |  Branch (4560:6): [True: 106, False: 0]
  ------------------
 4561|    106|		    switch(i) {
  ------------------
  |  Branch (4561:14): [True: 106, False: 0]
  ------------------
 4562|     14|		    case 1:
  ------------------
  |  Branch (4562:7): [True: 14, False: 92]
  ------------------
 4563|     14|			PRESERVE_SV(yylval = mkNA());
  ------------------
  |  |  350|     14|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     14|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 4564|     14|			break;
 4565|     62|		    case 2:
  ------------------
  |  Branch (4565:7): [True: 62, False: 44]
  ------------------
 4566|     62|			PRESERVE_SV(yylval = mkTrue());
  ------------------
  |  |  350|     62|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     62|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 4567|     62|			break;
 4568|     28|		    case 3:
  ------------------
  |  Branch (4568:7): [True: 28, False: 78]
  ------------------
 4569|     28|			PRESERVE_SV(yylval = mkFalse());
  ------------------
  |  |  350|     28|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|     28|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 4570|     28|			break;
 4571|      0|		    case 4:
  ------------------
  |  Branch (4571:7): [True: 0, False: 106]
  ------------------
 4572|      0|			PRESERVE_SV(yylval = allocVector(REALSXP, 1));
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 4573|      0|			REAL(yylval)[0] = R_PosInf;
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 4574|      0|			break;
 4575|      0|		    case 5:
  ------------------
  |  Branch (4575:7): [True: 0, False: 106]
  ------------------
 4576|      0|			PRESERVE_SV(yylval = allocVector(REALSXP, 1));
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 4577|      0|			REAL(yylval)[0] = R_NaN;
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
 4578|      0|			break;
 4579|      0|		    case 6:
  ------------------
  |  Branch (4579:7): [True: 0, False: 106]
  ------------------
 4580|      0|			PRESERVE_SV(yylval = allocVector(INTSXP, 1));
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 4581|      0|			INTEGER(yylval)[0] = NA_INTEGER;
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
              			INTEGER(yylval)[0] = NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
 4582|      0|			break;
 4583|      0|		    case 7:
  ------------------
  |  Branch (4583:7): [True: 0, False: 106]
  ------------------
 4584|      0|			PRESERVE_SV(yylval = allocVector(REALSXP, 1));
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 4585|      0|			REAL(yylval)[0] = NA_REAL;
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
              			REAL(yylval)[0] = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
 4586|      0|			break;
 4587|      2|		    case 8:
  ------------------
  |  Branch (4587:7): [True: 2, False: 104]
  ------------------
 4588|      2|			PRESERVE_SV(yylval = allocVector(STRSXP, 1));
  ------------------
  |  |  350|      2|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      2|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 4589|      2|			SET_STRING_ELT(yylval, 0, NA_STRING);
  ------------------
  |  | 2019|      2|# define yylval			Rf_yylval
  ------------------
              			SET_STRING_ELT(yylval, 0, NA_STRING);
  ------------------
  |  |  433|      2|#define NA_STRING	R_NaString
  ------------------
 4590|      2|			break;
 4591|      0|		    case 9:
  ------------------
  |  Branch (4591:7): [True: 0, False: 106]
  ------------------
 4592|      0|			PRESERVE_SV(yylval = allocVector(CPLXSXP, 1));
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 4593|      0|			COMPLEX(yylval)[0].r = COMPLEX(yylval)[0].i = NA_REAL;
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
              			COMPLEX(yylval)[0].r = COMPLEX(yylval)[0].i = NA_REAL;
  ------------------
  |  | 2019|      0|# define yylval			Rf_yylval
  ------------------
              			COMPLEX(yylval)[0].r = COMPLEX(yylval)[0].i = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
 4594|      0|			break;
 4595|    106|		    }
 4596|    106|		} else
 4597|      0|		    PRESERVE_SV(yylval = R_NilValue);
  ------------------
  |  |  350|      0|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      0|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 4598|    106|		break;
 4599|    106|	    case FUNCTION:
  ------------------
  |  |  592|     84|#define FUNCTION 264
  ------------------
  |  Branch (4599:6): [True: 84, False: 238]
  ------------------
 4600|     86|	    case WHILE:
  ------------------
  |  |  602|     86|#define WHILE 274
  ------------------
  |  Branch (4600:6): [True: 2, False: 320]
  ------------------
 4601|     86|	    case REPEAT:
  ------------------
  |  |  605|     86|#define REPEAT 277
  ------------------
  |  Branch (4601:6): [True: 0, False: 322]
  ------------------
 4602|     94|	    case FOR:
  ------------------
  |  |  598|     94|#define FOR 270
  ------------------
  |  Branch (4602:6): [True: 8, False: 314]
  ------------------
 4603|    162|	    case IF:
  ------------------
  |  |  600|    162|#define IF 272
  ------------------
  |  Branch (4603:6): [True: 68, False: 254]
  ------------------
 4604|    162|	    case NEXT:
  ------------------
  |  |  603|    162|#define NEXT 275
  ------------------
  |  Branch (4604:6): [True: 0, False: 322]
  ------------------
 4605|    162|	    case BREAK:
  ------------------
  |  |  604|    162|#define BREAK 276
  ------------------
  |  Branch (4605:6): [True: 0, False: 322]
  ------------------
 4606|    162|		yylval = install(s);
  ------------------
  |  | 2019|    162|# define yylval			Rf_yylval
  ------------------
              		yylval = install(s);
  ------------------
  |  |  934|    162|#define install			Rf_install
  ------------------
 4607|    162|		break;
 4608|      8|	    case IN:
  ------------------
  |  |  599|      8|#define IN 271
  ------------------
  |  Branch (4608:6): [True: 8, False: 314]
  ------------------
 4609|     24|	    case ELSE:
  ------------------
  |  |  601|     24|#define ELSE 273
  ------------------
  |  Branch (4609:6): [True: 16, False: 306]
  ------------------
 4610|     24|		break;
 4611|      8|	    case SYMBOL:
  ------------------
  |  |  591|      8|#define SYMBOL 263
  ------------------
  |  Branch (4611:6): [True: 8, False: 314]
  ------------------
 4612|      8|		PRESERVE_SV(yylval = install(s));
  ------------------
  |  |  350|      8|#define PRESERVE_SV(x) R_PreserveInMSet((x), PS_SVS)
  |  |  ------------------
  |  |  |  |  308|      8|#define PS_SVS              VECTOR_ELT(ParseState.sexps, 6)
  |  |  ------------------
  ------------------
 4613|      8|		break;
 4614|    322|	    }
 4615|    322|	    return keywords[i].token;
 4616|    322|	}
 4617|  45.5k|    }
 4618|  2.12k|    return 0;
 4619|  2.44k|}
gram.c:mkNA:
 4644|     14|{
 4645|     14|    SEXP t = allocVector(LGLSXP, 1);
  ------------------
  |  |  875|     14|#define allocVector		Rf_allocVector
  ------------------
                  SEXP t = allocVector(LGLSXP, 1);
  ------------------
  |  |  121|     14|#define LGLSXP	    10	  /* logical vectors */
  ------------------
 4646|     14|    LOGICAL(t)[0] = NA_LOGICAL;
  ------------------
  |  |   55|     14|#define NA_LOGICAL	R_NaInt
  ------------------
 4647|     14|    return t;
 4648|     14|}
gram.c:install_and_save:
 5857|  1.76k|{
 5858|  1.76k|    strcpy(yytext, text);
 5859|  1.76k|    return install(text);
  ------------------
  |  |  934|  1.76k|#define install			Rf_install
  ------------------
 5860|  1.76k|}
gram.c:xxgetc:
 2928|  47.9k|{
 2929|  47.9k|    int c;
 2930|       |
 2931|  47.9k|    if(npush) c = pushback[--npush]; else  c = ptr_getc();
  ------------------
  |  Branch (2931:8): [True: 3.73k, False: 44.1k]
  ------------------
 2932|       |
 2933|  47.9k|    prevpos = (prevpos + 1) % PUSHBACK_BUFSIZE;
  ------------------
  |  | 2917|  47.9k|#define PUSHBACK_BUFSIZE 16
  ------------------
 2934|  47.9k|    prevbytes[prevpos] = ParseState.xxbyteno;
 2935|  47.9k|    prevlines[prevpos] = ParseState.xxlineno;  
 2936|  47.9k|    prevparse[prevpos] = ParseState.xxparseno;
 2937|  47.9k|    prevcols[prevpos] = ParseState.xxcolno;
 2938|       |    	
 2939|  47.9k|    if (c == EOF) {
  ------------------
  |  Branch (2939:9): [True: 48, False: 47.8k]
  ------------------
 2940|     48|	EndOfFile = 1;
 2941|     48|	return R_EOF;
  ------------------
  |  | 1531|     48|#define R_EOF	-1
  ------------------
 2942|     48|    }
 2943|  47.8k|    R_ParseContextLast = (R_ParseContextLast + 1) % PARSE_CONTEXT_SIZE;
  ------------------
  |  |  112|  47.8k|#define PARSE_CONTEXT_SIZE 256	    /* Recent parse context kept in a circular buffer */
  ------------------
 2944|  47.8k|    R_ParseContext[R_ParseContextLast] = (char) c;
 2945|       |
 2946|  47.8k|    if (c == '\n') {
  ------------------
  |  Branch (2946:9): [True: 1.12k, False: 46.7k]
  ------------------
 2947|  1.12k|	ParseState.xxlineno += 1;
 2948|  1.12k|	ParseState.xxcolno = 0;
 2949|  1.12k|    	ParseState.xxbyteno = 0;
 2950|  1.12k|    	ParseState.xxparseno += 1;
 2951|  46.7k|    } else {
 2952|       |        /* We only advance the column for the 1st byte in UTF-8, so handle later bytes specially */
 2953|  46.7k|	if (!known_to_be_utf8 || (unsigned char)c < 0x80 || 0xC0 <= (unsigned char)c)
  ------------------
  |  Branch (2953:6): [True: 46.7k, False: 0]
  |  Branch (2953:27): [True: 0, False: 0]
  |  Branch (2953:54): [True: 0, False: 0]
  ------------------
 2954|  46.7k|            ParseState.xxcolno++;
 2955|  46.7k|    	ParseState.xxbyteno++;
 2956|  46.7k|    }
 2957|       |
 2958|  47.8k|    if (c == '\t') ParseState.xxcolno = ((ParseState.xxcolno + 7) & ~7);
  ------------------
  |  Branch (2958:9): [True: 2, False: 47.8k]
  ------------------
 2959|       |    
 2960|  47.8k|    R_ParseContextLine = ParseState.xxlineno;    
 2961|       |
 2962|  47.8k|    xxcharcount++;
 2963|  47.8k|    return c;
 2964|  47.9k|}
gram.c:ifpop:
 4490|    740|{
 4491|    740|    if (*contextp=='i')
  ------------------
  |  Branch (4491:9): [True: 58, False: 682]
  ------------------
 4492|     58|	*contextp-- = 0;
 4493|    740|}
gram.c:setlastloc:
 6128|  7.63k|{
 6129|  7.63k|    yylloc.last_line = ParseState.xxlineno;
 6130|  7.63k|    yylloc.last_column = ParseState.xxcolno;
 6131|  7.63k|    yylloc.last_byte = ParseState.xxbyteno;
 6132|  7.63k|    yylloc.last_parsed = ParseState.xxparseno;
 6133|  7.63k|}
gram.c:IfPush:
 4476|     68|{
 4477|     68|    if (*contextp==LBRACE ||
  ------------------
  |  |  237|    136|#define LBRACE	'{'
  ------------------
  |  Branch (4477:9): [True: 54, False: 14]
  ------------------
 4478|     14|	*contextp=='['    ||
  ------------------
  |  Branch (4478:2): [True: 0, False: 14]
  ------------------
 4479|     14|	*contextp=='('    ||
  ------------------
  |  Branch (4479:2): [True: 0, False: 14]
  ------------------
 4480|     58|	*contextp == 'i') {
  ------------------
  |  Branch (4480:2): [True: 4, False: 10]
  ------------------
 4481|     58|	if(contextp - contextstack >= CONTEXTSTACK_SIZE - 1)
  ------------------
  |  | 3893|     58|#define CONTEXTSTACK_SIZE 50
  ------------------
  |  Branch (4481:5): [True: 0, False: 58]
  ------------------
 4482|      0|	    raiseLexError("contextstackOverflow", NO_VALUE, NULL,
  ------------------
  |  |  311|      0|#define NO_VALUE 0
  ------------------
 4483|      0|	        _("contextstack overflow (%s:%d:%d)"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4484|     58|	*++contextp = 'i';
 4485|     58|    }
 4486|       |
 4487|     68|}
gram.c:modif_token:
 6476|  1.36k|static void modif_token( yyltype* loc, int tok ){
 6477|       |	
 6478|  1.36k|	int id = loc->id ;
 6479|       |	
 6480|  1.36k|	if (!ParseState.keepSrcRefs || !ParseState.keepParseData
  ------------------
  |  Branch (6480:6): [True: 1.36k, False: 0]
  |  Branch (6480:33): [True: 0, False: 0]
  ------------------
 6481|  1.36k|	    || id < 0 || id > ID_COUNT) return;
  ------------------
  |  |  156|      0|#define ID_COUNT    ((length( PS_IDS ) / 2) - 1)
  |  |  ------------------
  |  |  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  ------------------
  ------------------
  |  Branch (6481:9): [True: 0, False: 0]
  |  Branch (6481:19): [True: 0, False: 0]
  ------------------
 6482|       |	    
 6483|      0|	if( tok == SYMBOL_FUNCTION_CALL ){
  ------------------
  |  |  624|      0|#define SYMBOL_FUNCTION_CALL 296
  ------------------
  |  Branch (6483:6): [True: 0, False: 0]
  ------------------
 6484|       |		// looking for first child of id
 6485|      0|		int j = ID_ID( id ) ;
  ------------------
  |  |  173|      0|#define ID_ID( i )      INTEGER(PS_IDS)[ 2*(i) ]
  |  |  ------------------
  |  |  |  |  307|      0|#define PS_IDS              VECTOR_ELT(ParseState.sexps, 5)
  |  |  ------------------
  ------------------
 6486|      0|		int parent = id ;
 6487|       |		
 6488|      0|		if (j < 0 || j > ID_COUNT)
  ------------------
  |  |  156|      0|#define ID_COUNT    ((length( PS_IDS ) / 2) - 1)
  |  |  ------------------
  |  |  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  ------------------
  ------------------
  |  Branch (6488:7): [True: 0, False: 0]
  |  Branch (6488:16): [True: 0, False: 0]
  ------------------
 6489|      0|	            return;
 6490|       |	            
 6491|      0|		while( ID_PARENT( _ID(j) ) != parent ){
  ------------------
  |  |  174|      0|#define ID_PARENT( i )  INTEGER(PS_IDS)[ 2*(i) + 1 ]
  |  |  ------------------
  |  |  |  |  307|      0|#define PS_IDS              VECTOR_ELT(ParseState.sexps, 5)
  |  |  ------------------
  ------------------
  |  Branch (6491:10): [True: 0, False: 0]
  ------------------
 6492|      0|		    j-- ; 
 6493|      0|		    if (j < 0)
  ------------------
  |  Branch (6493:11): [True: 0, False: 0]
  ------------------
 6494|      0|	        	return;
 6495|      0|		}
 6496|       |			
 6497|      0|		if( _TOKEN(j) == SYMBOL ){
  ------------------
  |  |  169|      0|#define _TOKEN( i )        INTEGER( PS_DATA )[ DATA_ROWS*(i) + 5 ]
  |  |  ------------------
  |  |  |  |  305|      0|#define PS_DATA             ParseState.data
  |  |  ------------------
  |  |               #define _TOKEN( i )        INTEGER( PS_DATA )[ DATA_ROWS*(i) + 5 ]
  |  |  ------------------
  |  |  |  |  162|      0|#define DATA_ROWS 8
  |  |  ------------------
  ------------------
              		if( _TOKEN(j) == SYMBOL ){
  ------------------
  |  |  591|      0|#define SYMBOL 263
  ------------------
  |  Branch (6497:7): [True: 0, False: 0]
  ------------------
 6498|      0|		    _TOKEN(j) = SYMBOL_FUNCTION_CALL ;
  ------------------
  |  |  169|      0|#define _TOKEN( i )        INTEGER( PS_DATA )[ DATA_ROWS*(i) + 5 ]
  |  |  ------------------
  |  |  |  |  305|      0|#define PS_DATA             ParseState.data
  |  |  ------------------
  |  |               #define _TOKEN( i )        INTEGER( PS_DATA )[ DATA_ROWS*(i) + 5 ]
  |  |  ------------------
  |  |  |  |  162|      0|#define DATA_ROWS 8
  |  |  ------------------
  ------------------
              		    _TOKEN(j) = SYMBOL_FUNCTION_CALL ;
  ------------------
  |  |  624|      0|#define SYMBOL_FUNCTION_CALL 296
  ------------------
 6499|      0|		}
 6500|       |		
 6501|      0|	} else{
 6502|      0|		_TOKEN( ID_ID(id) ) = tok ;
  ------------------
  |  |  169|      0|#define _TOKEN( i )        INTEGER( PS_DATA )[ DATA_ROWS*(i) + 5 ]
  |  |  ------------------
  |  |  |  |  305|      0|#define PS_DATA             ParseState.data
  |  |  ------------------
  |  |               #define _TOKEN( i )        INTEGER( PS_DATA )[ DATA_ROWS*(i) + 5 ]
  |  |  ------------------
  |  |  |  |  162|      0|#define DATA_ROWS 8
  |  |  ------------------
  ------------------
 6503|      0|	}
 6504|       |	
 6505|      0|}

do_strsplit:
  646|  1.92k|{
  647|  1.92k|    SEXP args0 = args, ans, tok, x;
  648|  1.92k|    R_xlen_t i, itok, len, tlen;
  649|  1.92k|    size_t j, ntok;
  650|  1.92k|    bool fixed_opt, perl_opt, useBytes;
  651|  1.92k|    char *pt = NULL; wchar_t *wpt = NULL;
  652|  1.92k|    const char *buf, *split = "", *bufp;
  653|  1.92k|    const unsigned char *tables = NULL;
  654|  1.92k|    bool use_UTF8 = false;
  655|  1.92k|    const void *vmax, *vmax2;
  656|  1.92k|    int nwarn = 0;
  657|  1.92k|    bool haveBytesInput;
  658|       |
  659|  1.92k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.92k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  660|  1.92k|    x = CAR(args); args = CDR(args);
  661|  1.92k|    tok = CAR(args); args = CDR(args);
  662|  1.92k|    fixed_opt = asBool2(CAR(args), call); args = CDR(args);
  ------------------
  |  | 1860|  1.92k|# define asBool2	       	Rf_asBool2
  ------------------
  663|  1.92k|    perl_opt = asBool2(CAR(args), call); args = CDR(args);
  ------------------
  |  | 1860|  1.92k|# define asBool2	       	Rf_asBool2
  ------------------
  664|  1.92k|    useBytes = asBool2(CAR(args), call);
  ------------------
  |  | 1860|  1.92k|# define asBool2	       	Rf_asBool2
  ------------------
  665|  1.92k|    if (fixed_opt && perl_opt) {
  ------------------
  |  Branch (665:9): [True: 1.87k, False: 46]
  |  Branch (665:22): [True: 0, False: 1.87k]
  ------------------
  666|      0|	warning(_("argument '%s' will be ignored"), "perl = TRUE");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("argument '%s' will be ignored"), "perl = TRUE");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  667|      0|	perl_opt = 0;
  668|      0|    }
  669|       |
  670|  1.92k|    if (!isString(x) || !isString(tok)) error(_("non-character argument"));
  ------------------
  |  |  966|  1.92k|#define isString		Rf_isString
  ------------------
                  if (!isString(x) || !isString(tok)) error(_("non-character argument"));
  ------------------
  |  |  966|  1.92k|#define isString		Rf_isString
  ------------------
                  if (!isString(x) || !isString(tok)) error(_("non-character argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (!isString(x) || !isString(tok)) error(_("non-character argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (670:9): [True: 0, False: 1.92k]
  |  Branch (670:25): [True: 0, False: 1.92k]
  ------------------
  671|       |
  672|       |
  673|  1.92k|    len = XLENGTH(x);
  674|  1.92k|    tlen = XLENGTH(tok);
  675|       |
  676|       |    /* treat split = NULL as split = "" */
  677|  1.92k|    if (!tlen) { tlen = 1; SETCADR(args0, tok = mkString("")); }
  ------------------
  |  | 1003|      0|#define mkString		Rf_mkString
  ------------------
  |  Branch (677:9): [True: 0, False: 1.92k]
  ------------------
  678|  1.92k|    PROTECT(tok);
  ------------------
  |  |  357|  1.92k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  679|       |
  680|  1.92k|    haveBytesInput = have_bytes(tok, tlen) || have_bytes(x, len);
  ------------------
  |  Branch (680:22): [True: 0, False: 1.92k]
  |  Branch (680:47): [True: 0, False: 1.92k]
  ------------------
  681|  1.92k|    if (!useBytes)
  ------------------
  |  Branch (681:9): [True: 1.92k, False: 0]
  ------------------
  682|  1.92k|	useBytes = only_ascii(tok, tlen) && only_ascii(x, len);
  ------------------
  |  Branch (682:13): [True: 1.92k, False: 0]
  |  Branch (682:38): [True: 1.63k, False: 287]
  ------------------
  683|  1.92k|    if (!useBytes) 
  ------------------
  |  Branch (683:9): [True: 287, False: 1.63k]
  ------------------
  684|    287|	useBytes = haveBytesInput;
  685|  1.92k|    if (!useBytes) {
  ------------------
  |  Branch (685:9): [True: 287, False: 1.63k]
  ------------------
  686|       |	// use_UTF8 means use wchar_t* for the TRE engine
  687|    287|	if (!fixed_opt && mbcslocale) use_UTF8 = true;
  ------------------
  |  Branch (687:6): [True: 0, False: 287]
  |  Branch (687:20): [True: 0, False: 0]
  ------------------
  688|    287|	if (!use_UTF8)
  ------------------
  |  Branch (688:6): [True: 287, False: 0]
  ------------------
  689|    287|	    use_UTF8 = have_utf8(tok, tlen) || have_utf8(x, len);
  ------------------
  |  Branch (689:17): [True: 0, False: 287]
  |  Branch (689:41): [True: 0, False: 287]
  ------------------
  690|    287|	if (!use_UTF8 && !latin1locale)
  ------------------
  |  Branch (690:6): [True: 287, False: 0]
  |  Branch (690:19): [True: 287, False: 0]
  ------------------
  691|    287|	    use_UTF8 = have_latin1(tok, tlen) || have_latin1(x, len);
  ------------------
  |  Branch (691:17): [True: 0, False: 287]
  |  Branch (691:43): [True: 0, False: 287]
  ------------------
  692|    287|    }
  693|       |
  694|       |    /* group by token for efficiency with PCRE/TRE versions */
  695|  1.92k|    PROTECT(ans = allocVector(VECSXP, len));
  ------------------
  |  |  357|  1.92k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  696|  1.92k|    vmax = vmaxget();
  697|  3.84k|    for (itok = 0; itok < tlen; itok++) {
  ------------------
  |  Branch (697:20): [True: 1.92k, False: 1.92k]
  ------------------
  698|  1.92k|	SEXP this = STRING_ELT(tok, itok);
  699|       |
  700|  1.92k|	if (this == NA_STRING) { /* NA token doesn't split */
  ------------------
  |  |  433|  1.92k|#define NA_STRING	R_NaString
  ------------------
  |  Branch (700:6): [True: 0, False: 1.92k]
  ------------------
  701|      0|	    for (i = itok; i < len; i += tlen)
  ------------------
  |  Branch (701:21): [True: 0, False: 0]
  ------------------
  702|      0|		SET_VECTOR_ELT(ans, i,
  703|      0|		               ScalarString(markBytesOld(STRING_ELT(x, i),
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
  704|      0|		                                         useBytes,
  705|      0|		                                         haveBytesInput)));
  706|      0|	    continue;
  707|  1.92k|	} else if (!CHAR(this)[0]) { /* empty */
  ------------------
  |  |  203|  1.92k|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (707:13): [True: 0, False: 1.92k]
  ------------------
  708|      0|	    vmax2 = vmaxget();
  709|      0|	    for (i = itok; i < len; i += tlen) {
  ------------------
  |  Branch (709:21): [True: 0, False: 0]
  ------------------
  710|      0|		SEXP t;
  711|      0|		if (STRING_ELT(x, i) == NA_STRING) {
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (711:7): [True: 0, False: 0]
  ------------------
  712|      0|		    SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              		    SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  713|      0|		    continue;
  714|      0|		}
  715|      0|		if (useBytes)
  ------------------
  |  Branch (715:7): [True: 0, False: 0]
  ------------------
  716|      0|		    buf = CHAR(STRING_ELT(x, i));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  717|      0|		else if (use_UTF8) {
  ------------------
  |  Branch (717:12): [True: 0, False: 0]
  ------------------
  718|      0|		    buf = trCharUTF82(STRING_ELT(x, i));
  ------------------
  |  | 2001|      0|# define trCharUTF82      	Rf_trCharUTF82
  ------------------
  719|      0|		    if (!buf || !utf8Valid(buf)) {
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
  |  Branch (719:11): [True: 0, False: 0]
  |  Branch (719:19): [True: 0, False: 0]
  ------------------
  720|      0|			if(nwarn++ < NWARN)
  ------------------
  |  |   62|      0|#define NWARN 5
  ------------------
  |  Branch (720:7): [True: 0, False: 0]
  ------------------
  721|      0|			    warning(_("input string %lld is invalid UTF-8"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			    warning(_("input string %lld is invalid UTF-8"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  722|      0|			            (long long)i+1);
  723|      0|			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  724|      0|			continue;
  725|      0|		    }
  726|      0|		} else {
  727|      0|		    buf = translateCharFP2(STRING_ELT(x, i));
  ------------------
  |  | 1999|      0|# define translateCharFP2	Rf_translateCharFP2
  ------------------
  728|      0|		    if (!buf || (mbcslocale && !mbcsValid(buf))) {
  ------------------
  |  | 1952|      0|# define mbcsValid		Rf_mbcsValid
  ------------------
  |  Branch (728:11): [True: 0, False: 0]
  |  Branch (728:20): [True: 0, False: 0]
  |  Branch (728:34): [True: 0, False: 0]
  ------------------
  729|      0|			if(nwarn++ < NWARN)
  ------------------
  |  |   62|      0|#define NWARN 5
  ------------------
  |  Branch (729:7): [True: 0, False: 0]
  ------------------
  730|      0|			    warning(_("input string %lld is invalid in this locale"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			    warning(_("input string %lld is invalid in this locale"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  731|      0|			            (long long)i+1);
  732|      0|			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  733|      0|			continue;
  734|      0|		    }
  735|      0|		}
  736|      0|		if (!useBytes && (use_UTF8 || mbcslocale) &&
  ------------------
  |  Branch (736:7): [True: 0, False: 0]
  |  Branch (736:21): [True: 0, False: 0]
  |  Branch (736:33): [True: 0, False: 0]
  ------------------
  737|      0|		    !IS_ASCII(STRING_ELT(x, i))) {
  ------------------
  |  Branch (737:7): [True: 0, False: 0]
  ------------------
  738|       |
  739|       |		    /* split into individual characters (not bytes) */
  740|      0|		    char bf[20 /* > R_MB_CUR_MAX */];
  741|      0|		    const char *p = buf;
  742|      0|		    size_t used;
  743|      0|		    mbstate_t mb_st;
  744|      0|		    ssize_t nt;  /* need to check error on size_t */
  745|       |
  746|      0|		    if (use_UTF8) {
  ------------------
  |  Branch (746:11): [True: 0, False: 0]
  ------------------
  747|      0|			for (ntok = 0; *p; p += used, ntok++)
  ------------------
  |  Branch (747:19): [True: 0, False: 0]
  ------------------
  748|      0|			    used = utf8clen(*p);
  ------------------
  |  | 2008|      0|# define utf8clen		Rf_utf8clen
  ------------------
  749|      0|			p = buf;
  750|      0|			PROTECT(t = allocVector(STRSXP, ntok));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  751|      0|			for (j = 0; j < ntok; j++, p += used) {
  ------------------
  |  Branch (751:16): [True: 0, False: 0]
  ------------------
  752|      0|			    used = utf8clen(*p);
  ------------------
  |  | 2008|      0|# define utf8clen		Rf_utf8clen
  ------------------
  753|      0|			    memcpy(bf, p, used); bf[used] = '\0';
  754|      0|			    SET_STRING_ELT(t, j, mkCharCE(bf, CE_UTF8));
  ------------------
  |  |  999|      0|#define mkCharCE		Rf_mkCharCE
  ------------------
  755|      0|			}
  756|      0|		    } else if ((nt = mbstowcs(NULL, buf, 0)) < 0) {
  ------------------
  |  Branch (756:18): [True: 0, False: 0]
  ------------------
  757|      0|			PROTECT(t = ScalarString(NA_STRING));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  758|      0|		    } else {
  759|      0|			ntok = nt;
  760|      0|			mbs_init(&mb_st);
  ------------------
  |  | 2454|      0|#define mbs_init(x) memset(x, 0, sizeof(mbstate_t))
  ------------------
  761|      0|			PROTECT(t = allocVector(STRSXP, ntok));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  762|      0|			for (j = 0; j < ntok; j++, p += used) {
  ------------------
  |  Branch (762:16): [True: 0, False: 0]
  ------------------
  763|       |			    /* This is valid as we have already checked */
  764|      0|			    used = mbrtowc(NULL, p, R_MB_CUR_MAX, &mb_st);
  765|      0|			    memcpy(bf, p, used); bf[used] = '\0';
  766|      0|			    SET_STRING_ELT(t, j, markKnown(bf, STRING_ELT(x, i)));
  ------------------
  |  | 1942|      0|# define markKnown		Rf_markKnown
  ------------------
  767|      0|			}
  768|      0|		    }
  769|      0|		} else {
  770|       |		    /* useBytes or ASCII or
  771|       |		       single-byte locale and not marked as UTF-8 */
  772|      0|		    char bf[2];
  773|      0|		    ntok = strlen(buf);
  774|      0|		    PROTECT(t = allocVector(STRSXP, ntok));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  775|      0|		    bf[1] = '\0';
  776|      0|		    if(useBytes) {
  ------------------
  |  Branch (776:10): [True: 0, False: 0]
  ------------------
  777|      0|			for (j = 0; j < ntok; j++) {
  ------------------
  |  Branch (777:16): [True: 0, False: 0]
  ------------------
  778|      0|			    bf[0] = buf[j];
  779|      0|			    SET_STRING_ELT(t, j, mkBytesNew(bf, haveBytesInput));
  780|      0|			}
  781|      0|		    } else {
  782|      0|			for (j = 0; j < ntok; j++) {
  ------------------
  |  Branch (782:16): [True: 0, False: 0]
  ------------------
  783|      0|			    bf[0] = buf[j];
  784|      0|			    SET_STRING_ELT(t, j, markKnown(bf, STRING_ELT(x, i)));
  ------------------
  |  | 1942|      0|# define markKnown		Rf_markKnown
  ------------------
  785|      0|			}
  786|      0|		    }
  787|      0|		}
  788|      0|		SET_VECTOR_ELT(ans, i, t);
  789|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  790|      0|		vmaxset(vmax2);
  791|      0|	    }
  792|  1.92k|	} else if (fixed_opt) {
  ------------------
  |  Branch (792:13): [True: 1.87k, False: 46]
  ------------------
  793|  1.87k|	    const char *laststart, *ebuf;
  794|  1.87k|	    if (useBytes)
  ------------------
  |  Branch (794:10): [True: 1.58k, False: 287]
  ------------------
  795|  1.58k|		split = CHAR(STRING_ELT(tok, itok));
  ------------------
  |  |  203|  1.58k|#define CHAR(x) R_CHAR(x)
  ------------------
  796|    287|	    else if (use_UTF8) { // includes Latin-1 support
  ------------------
  |  Branch (796:15): [True: 0, False: 287]
  ------------------
  797|      0|		split = trCharUTF82(STRING_ELT(tok, itok));
  ------------------
  |  | 2001|      0|# define trCharUTF82      	Rf_trCharUTF82
  ------------------
  798|      0|		if (!split || !utf8Valid(split))
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
  |  Branch (798:7): [True: 0, False: 0]
  |  Branch (798:17): [True: 0, False: 0]
  ------------------
  799|      0|		    error(_("'split' string %lld is invalid UTF-8"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("'split' string %lld is invalid UTF-8"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  800|      0|		          (long long)itok+1);
  801|    287|	    } else {
  802|    287|		split = translateCharFP2(STRING_ELT(tok, itok));
  ------------------
  |  | 1999|    287|# define translateCharFP2	Rf_translateCharFP2
  ------------------
  803|    287|		if (!split || (mbcslocale && !mbcsValid(split)))
  ------------------
  |  | 1952|      0|# define mbcsValid		Rf_mbcsValid
  ------------------
  |  Branch (803:7): [True: 0, False: 287]
  |  Branch (803:18): [True: 0, False: 287]
  |  Branch (803:32): [True: 0, False: 0]
  ------------------
  804|      0|		    error(_("'split' string %lld is invalid in this locale"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("'split' string %lld is invalid in this locale"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  805|      0|			  (long long)itok+1);
  806|    287|	    }
  807|  1.87k|	    int slen = (int) strlen(split);
  808|       |
  809|  1.87k|	    vmax2 = vmaxget();
  810|  3.74k|	    for (i = itok; i < len; i += tlen) {
  ------------------
  |  Branch (810:21): [True: 1.87k, False: 1.87k]
  ------------------
  811|  1.87k|		SEXP t;
  812|  1.87k|		if (STRING_ELT(x, i) == NA_STRING) {
  ------------------
  |  |  433|  1.87k|#define NA_STRING	R_NaString
  ------------------
  |  Branch (812:7): [True: 0, False: 1.87k]
  ------------------
  813|      0|		    SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              		    SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  814|      0|		    continue;
  815|      0|		}
  816|       |
  817|  1.87k|		if (useBytes)
  ------------------
  |  Branch (817:7): [True: 1.58k, False: 287]
  ------------------
  818|  1.58k|		    buf = CHAR(STRING_ELT(x, i));
  ------------------
  |  |  203|  1.58k|#define CHAR(x) R_CHAR(x)
  ------------------
  819|    287|		else if (use_UTF8) {
  ------------------
  |  Branch (819:12): [True: 0, False: 287]
  ------------------
  820|      0|		    buf = trCharUTF82(STRING_ELT(x, i));
  ------------------
  |  | 2001|      0|# define trCharUTF82      	Rf_trCharUTF82
  ------------------
  821|      0|		    if (!buf || !utf8Valid(buf)) {
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
  |  Branch (821:11): [True: 0, False: 0]
  |  Branch (821:19): [True: 0, False: 0]
  ------------------
  822|      0|			if(nwarn++ < NWARN)
  ------------------
  |  |   62|      0|#define NWARN 5
  ------------------
  |  Branch (822:7): [True: 0, False: 0]
  ------------------
  823|      0|			    warning(_("input string %lld is invalid UTF-8"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			    warning(_("input string %lld is invalid UTF-8"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  824|      0|			            (long long)i+1);
  825|      0|			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  826|      0|			continue;
  827|      0|		    }
  828|    287|		} else {
  829|    287|		    buf = translateCharFP2(STRING_ELT(x, i));
  ------------------
  |  | 1999|    287|# define translateCharFP2	Rf_translateCharFP2
  ------------------
  830|    287|		    if (!buf || (mbcslocale && !mbcsValid(buf))) {
  ------------------
  |  | 1952|      0|# define mbcsValid		Rf_mbcsValid
  ------------------
  |  Branch (830:11): [True: 0, False: 287]
  |  Branch (830:20): [True: 0, False: 287]
  |  Branch (830:34): [True: 0, False: 0]
  ------------------
  831|      0|			if(nwarn++ < NWARN)
  ------------------
  |  |   62|      0|#define NWARN 5
  ------------------
  |  Branch (831:7): [True: 0, False: 0]
  ------------------
  832|      0|			    warning(_("input string %lld is invalid in this locale"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			    warning(_("input string %lld is invalid in this locale"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  833|      0|			            (long long)i+1);
  834|      0|			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  835|      0|			continue;
  836|      0|		    }
  837|    287|		}
  838|       |		/* find out how many splits there will be */
  839|  1.87k|		size_t ntok = 0;
  840|       |		/* This is UTF-8 safe since it compares whole strings */
  841|  1.87k|		laststart = buf;
  842|  1.87k|		ebuf = buf + strlen(buf);
  843|  2.68M|		for (bufp = buf; bufp < ebuf; bufp++) {
  ------------------
  |  Branch (843:20): [True: 2.68M, False: 1.87k]
  ------------------
  844|  2.68M|		    if ((slen == 1 && *bufp != *split) ||
  ------------------
  |  Branch (844:12): [True: 2.68M, False: 0]
  |  Branch (844:25): [True: 2.06M, False: 615k]
  ------------------
  845|  2.06M|			(slen > 1 && strncmp(bufp, split, slen))) continue;
  ------------------
  |  Branch (845:5): [True: 0, False: 615k]
  |  Branch (845:17): [True: 0, False: 0]
  ------------------
  846|   615k|		    ntok++;
  847|   615k|		    bufp += MAX(slen - 1, 0);
  ------------------
  |  |  140|   615k|# define MAX(a, b) ((a) > (b) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (140:21): [True: 0, False: 615k]
  |  |  ------------------
  ------------------
  848|   615k|		    laststart = bufp+1;
  849|   615k|		}
  850|  1.87k|		bufp = laststart;
  851|  1.87k|		SET_VECTOR_ELT(ans, i,
  852|  1.87k|			       t = allocVector(STRSXP, ntok + (*bufp ? 1 : 0)));
  ------------------
  |  |  875|  1.87k|#define allocVector		Rf_allocVector
  ------------------
              			       t = allocVector(STRSXP, ntok + (*bufp ? 1 : 0)));
  ------------------
  |  |  126|  1.87k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (852:43): [True: 1.57k, False: 300]
  ------------------
  853|       |		/* and fill with the splits */
  854|  1.87k|		laststart = bufp = buf;
  855|  1.87k|		pt = R_Realloc(pt, strlen(buf)+1, char);
  ------------------
  |  |   56|  1.87k|#define R_Realloc(p,n,t) (t *) R_chk_realloc( (void *)(p), (R_SIZE_T)((n) * sizeof(t)) )
  ------------------
  856|   617k|		for (size_t j = 0; j < ntok; j++) {
  ------------------
  |  Branch (856:22): [True: 615k, False: 1.87k]
  ------------------
  857|       |		    /* This is UTF-8 safe since it compares whole
  858|       |		       strings, but <MBCS-FIXME> it would be more
  859|       |		       efficient to skip along by chars.
  860|       |		    */
  861|  2.60M|		    for (; bufp < ebuf; bufp++) {
  ------------------
  |  Branch (861:14): [True: 2.60M, False: 0]
  ------------------
  862|  2.60M|			if ((slen == 1 && *bufp != *split) ||
  ------------------
  |  Branch (862:9): [True: 2.60M, False: 0]
  |  Branch (862:22): [True: 1.99M, False: 615k]
  ------------------
  863|  1.99M|			    (slen > 1 && strncmp(bufp, split, slen))) continue;
  ------------------
  |  Branch (863:9): [True: 0, False: 615k]
  |  Branch (863:21): [True: 0, False: 0]
  ------------------
  864|   615k|			if (slen) {
  ------------------
  |  Branch (864:8): [True: 615k, False: 0]
  ------------------
  865|   615k|			    if (bufp > laststart)
  ------------------
  |  Branch (865:12): [True: 509k, False: 106k]
  ------------------
  866|   509k|				memcpy(pt, laststart, bufp - laststart);
  867|   615k|			    pt[bufp - laststart] = '\0';
  868|   615k|			} else {
  869|      0|			    pt[0] = *bufp; pt[1] ='\0';
  870|      0|			}
  871|   615k|			bufp += MAX(slen-1, 0);
  ------------------
  |  |  140|   615k|# define MAX(a, b) ((a) > (b) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (140:21): [True: 0, False: 615k]
  |  |  ------------------
  ------------------
  872|   615k|			laststart = bufp+1;
  873|   615k|			if (useBytes)
  ------------------
  |  Branch (873:8): [True: 309k, False: 306k]
  ------------------
  874|   309k|			    SET_STRING_ELT(t, j, mkBytesNew(pt, haveBytesInput));
  875|   306k|			else if (use_UTF8)
  ------------------
  |  Branch (875:13): [True: 0, False: 306k]
  ------------------
  876|      0|			    SET_STRING_ELT(t, j, mkCharCE(pt, CE_UTF8));
  ------------------
  |  |  999|      0|#define mkCharCE		Rf_mkCharCE
  ------------------
  877|   306k|			else
  878|   306k|			    SET_STRING_ELT(t, j, markKnown(pt, STRING_ELT(x, i)));
  ------------------
  |  | 1942|   306k|# define markKnown		Rf_markKnown
  ------------------
  879|   615k|			break;
  880|  2.60M|		    }
  881|   615k|		    bufp = laststart;
  882|   615k|		}
  883|  1.87k|		if (*bufp) {
  ------------------
  |  Branch (883:7): [True: 1.57k, False: 300]
  ------------------
  884|  1.57k|		    if (useBytes)
  ------------------
  |  Branch (884:11): [True: 1.35k, False: 217]
  ------------------
  885|  1.35k|			SET_STRING_ELT(t, ntok, mkBytesNew(bufp, haveBytesInput));
  886|    217|		    else if (use_UTF8)
  ------------------
  |  Branch (886:16): [True: 0, False: 217]
  ------------------
  887|      0|			SET_STRING_ELT(t, ntok, mkCharCE(bufp, CE_UTF8));
  ------------------
  |  |  999|      0|#define mkCharCE		Rf_mkCharCE
  ------------------
  888|    217|		    else
  889|    217|			SET_STRING_ELT(t, ntok, markKnown(bufp, STRING_ELT(x, i)));
  ------------------
  |  | 1942|    217|# define markKnown		Rf_markKnown
  ------------------
  890|  1.57k|		}
  891|  1.87k|		vmaxset(vmax2);
  892|  1.87k|	    }
  893|  1.87k|	} else if (perl_opt) {
  ------------------
  |  Branch (893:13): [True: 0, False: 46]
  ------------------
  894|      0|	    if (useBytes)
  ------------------
  |  Branch (894:10): [True: 0, False: 0]
  ------------------
  895|      0|		split = CHAR(STRING_ELT(tok, itok));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  896|      0|	    else if (use_UTF8) {
  ------------------
  |  Branch (896:15): [True: 0, False: 0]
  ------------------
  897|      0|		split = trCharUTF82(STRING_ELT(tok, itok));
  ------------------
  |  | 2001|      0|# define trCharUTF82      	Rf_trCharUTF82
  ------------------
  898|      0|		if (!split || !utf8Valid(split))
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
  |  Branch (898:7): [True: 0, False: 0]
  |  Branch (898:17): [True: 0, False: 0]
  ------------------
  899|      0|		    error(_("'split' string %lld is invalid UTF-8"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("'split' string %lld is invalid UTF-8"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  900|      0|		          (long long)itok+1);
  901|      0|	    } else {
  902|      0|		split = translateCharFP2(STRING_ELT(tok, itok));
  ------------------
  |  | 1999|      0|# define translateCharFP2	Rf_translateCharFP2
  ------------------
  903|      0|		if (!split || (mbcslocale && !mbcsValid(split)))
  ------------------
  |  | 1952|      0|# define mbcsValid		Rf_mbcsValid
  ------------------
  |  Branch (903:7): [True: 0, False: 0]
  |  Branch (903:18): [True: 0, False: 0]
  |  Branch (903:32): [True: 0, False: 0]
  ------------------
  904|      0|		    error(_("'split' string %lld is invalid in this locale"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("'split' string %lld is invalid in this locale"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  905|      0|		          (long long)itok+1);
  906|      0|	    }
  907|      0|#ifdef HAVE_PCRE2
  908|      0|	    pcre2_code *re = NULL;
  909|      0|	    pcre2_match_context *mcontext = NULL;
  910|      0|	    PCRE2_SIZE *ovector = NULL;
  911|      0|	    uint32_t ovecsize = 10;
  912|      0|	    R_pcre2_prepare(split, x, use_UTF8, false, &tables, &re, &mcontext);
  913|      0|	    pcre2_match_data *mdata = pcre2_match_data_create(ovecsize, NULL);
  914|      0|	    uint32_t eflag = 0;
  915|      0|	    if (use_UTF8) eflag |= PCRE2_NO_UTF_CHECK;
  ------------------
  |  Branch (915:10): [True: 0, False: 0]
  ------------------
  916|       |#else
  917|       |	    pcre *re_pcre = NULL;
  918|       |	    pcre_extra *re_pe = NULL;
  919|       |	    int ovecsize = 30;
  920|       |	    int ovector[ovecsize];
  921|       |
  922|       |	    R_pcre_prepare(split, x, use_UTF8, false, true, &tables, &re_pcre,
  923|       |	                 &re_pe);
  924|       |#endif
  925|      0|	    regex_cleanup_info ci;
  926|      0|	    RCNTXT cntxt;
  927|      0|#ifdef HAVE_PCRE2
  928|      0|	    regex_cleanup_begin(&ci, &cntxt, call, false, true, NULL, tables,
  929|      0|				re, mdata, mcontext);
  930|       |#else
  931|       |	    regex_cleanup_begin(&ci, &cntxt, call, false, true, NULL, tables,
  932|       |				re_pcre, re_pe, NULL);
  933|       |#endif
  934|      0|	    vmax2 = vmaxget();
  935|      0|	    for (i = itok; i < len; i += tlen) {
  ------------------
  |  Branch (935:21): [True: 0, False: 0]
  ------------------
  936|      0|		SEXP t;
  937|      0|		if (STRING_ELT(x, i) == NA_STRING) {
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (937:7): [True: 0, False: 0]
  ------------------
  938|      0|		    SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              		    SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  939|      0|		    continue;
  940|      0|		}
  941|       |
  942|      0|		if (useBytes)
  ------------------
  |  Branch (942:7): [True: 0, False: 0]
  ------------------
  943|      0|		    buf = CHAR(STRING_ELT(x, i));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  944|      0|		else if (use_UTF8) {
  ------------------
  |  Branch (944:12): [True: 0, False: 0]
  ------------------
  945|      0|		    buf = trCharUTF82(STRING_ELT(x, i));
  ------------------
  |  | 2001|      0|# define trCharUTF82      	Rf_trCharUTF82
  ------------------
  946|      0|		    if (!buf || !utf8Valid(buf)) {
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
  |  Branch (946:11): [True: 0, False: 0]
  |  Branch (946:19): [True: 0, False: 0]
  ------------------
  947|      0|			if(nwarn++ < NWARN)
  ------------------
  |  |   62|      0|#define NWARN 5
  ------------------
  |  Branch (947:7): [True: 0, False: 0]
  ------------------
  948|      0|			    warning(_("input string %lld is invalid UTF-8"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			    warning(_("input string %lld is invalid UTF-8"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  949|      0|			            (long long)i+1);
  950|      0|			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  951|      0|			continue;
  952|      0|		    }
  953|      0|		} else {
  954|      0|		    buf = translateCharFP2(STRING_ELT(x, i));
  ------------------
  |  | 1999|      0|# define translateCharFP2	Rf_translateCharFP2
  ------------------
  955|      0|		    if (!buf || (mbcslocale && !mbcsValid(buf))) {
  ------------------
  |  | 1952|      0|# define mbcsValid		Rf_mbcsValid
  ------------------
  |  Branch (955:11): [True: 0, False: 0]
  |  Branch (955:20): [True: 0, False: 0]
  |  Branch (955:34): [True: 0, False: 0]
  ------------------
  956|      0|			if(nwarn++ < NWARN)
  ------------------
  |  |   62|      0|#define NWARN 5
  ------------------
  |  Branch (956:7): [True: 0, False: 0]
  ------------------
  957|      0|			    warning(_("input string %lld is invalid in this locale"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			    warning(_("input string %lld is invalid in this locale"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  958|      0|			            (long long)i+1);
  959|      0|			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  960|      0|			continue;
  961|      0|		    }
  962|      0|		}
  963|       |		/* find out how many splits there will be */
  964|      0|		ntok = 0;
  965|      0|		bufp = buf;
  966|      0|		if (*bufp) {
  ------------------
  |  Branch (966:7): [True: 0, False: 0]
  ------------------
  967|      0|		    int rc;
  968|      0|#ifdef HAVE_PCRE2
  969|      0|		    while((rc = pcre2_match(re, (PCRE2_SPTR) bufp,
  ------------------
  |  Branch (969:13): [True: 0, False: 0]
  ------------------
  970|      0|		                            PCRE2_ZERO_TERMINATED,
  971|      0|					    0, eflag, mdata, mcontext)) >= 0) {
  972|      0|			ovector = pcre2_get_ovector_pointer(mdata);
  973|       |#else
  974|       |		    while((rc = pcre_exec(re_pcre, re_pe, bufp,
  975|       |					  (int) strlen(bufp),
  976|       |					  0, 0, ovector, ovecsize)) >= 0) {
  977|       |#endif
  978|       |			/* Empty matches get the next char, so move by one. */
  979|      0|			if (ovector[1] > 0)
  ------------------
  |  Branch (979:8): [True: 0, False: 0]
  ------------------
  980|      0|			    bufp += ovector[1];
  981|      0|			else if (*bufp)
  ------------------
  |  Branch (981:13): [True: 0, False: 0]
  ------------------
  982|       |			    /* Only use_UTF8 input has been validated as UTF-8;
  983|       |			       utf8clen() on an arbitrary byte claims up to 6 and
  984|       |			       would run past the terminator. */
  985|      0|			    bufp += use_UTF8 ? utf8clen(*bufp) : 1;
  ------------------
  |  | 2008|      0|# define utf8clen		Rf_utf8clen
  ------------------
  |  Branch (985:16): [True: 0, False: 0]
  ------------------
  986|      0|			ntok++;
  987|      0|			if (*bufp == '\0')
  ------------------
  |  Branch (987:8): [True: 0, False: 0]
  ------------------
  988|      0|			    break;
  989|      0|		    }
  990|      0|		    R_pcre_exec_error(rc, i);
  991|      0|		}
  992|      0|		SET_VECTOR_ELT(ans, i,
  993|      0|			       t = allocVector(STRSXP, ntok + (*bufp ? 1 : 0)));
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              			       t = allocVector(STRSXP, ntok + (*bufp ? 1 : 0)));
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (993:43): [True: 0, False: 0]
  ------------------
  994|       |		/* and fill with the splits */
  995|      0|		bufp = buf;
  996|      0|		pt = R_Realloc(pt, strlen(buf)+1, char);
  ------------------
  |  |   56|      0|#define R_Realloc(p,n,t) (t *) R_chk_realloc( (void *)(p), (R_SIZE_T)((n) * sizeof(t)) )
  ------------------
  997|      0|		for (j = 0; j < ntok; j++) {
  ------------------
  |  Branch (997:15): [True: 0, False: 0]
  ------------------
  998|      0|#ifdef HAVE_PCRE2
  999|      0|		    int rc = pcre2_match(re, (PCRE2_SPTR) bufp,
 1000|      0|				       PCRE2_ZERO_TERMINATED,
 1001|      0|		                       0, eflag, mdata, mcontext);
 1002|       |#else
 1003|       |		    int rc = pcre_exec(re_pcre, re_pe, bufp,
 1004|       |				       (int) strlen(bufp), 0, 0,
 1005|       |				       ovector, ovecsize);
 1006|       |#endif
 1007|      0|		    R_pcre_exec_error(rc, i);
 1008|      0|		    if (ovector[1] > 0) {
  ------------------
  |  Branch (1008:11): [True: 0, False: 0]
  ------------------
 1009|       |			/* Match was non-empty. */
 1010|      0|			if (ovector[0] > 0)
  ------------------
  |  Branch (1010:8): [True: 0, False: 0]
  ------------------
 1011|      0|			    strncpy(pt, bufp, ovector[0]);
 1012|      0|			pt[ovector[0]] = '\0';
 1013|      0|			bufp += ovector[1];
 1014|      0|		    } else {
 1015|       |			/* Match was empty. */
 1016|      0|			int clen = use_UTF8 ? utf8clen(*bufp) : 1;
  ------------------
  |  | 2008|      0|# define utf8clen		Rf_utf8clen
  ------------------
  |  Branch (1016:15): [True: 0, False: 0]
  ------------------
 1017|      0|			strncpy(pt, bufp, clen);
 1018|      0|			pt[clen] = '\0';
 1019|      0|			bufp += clen;
 1020|      0|		    }
 1021|      0|		    if (useBytes)
  ------------------
  |  Branch (1021:11): [True: 0, False: 0]
  ------------------
 1022|      0|			SET_STRING_ELT(t, j, mkBytesNew(pt, haveBytesInput));
 1023|      0|		    else if (use_UTF8)
  ------------------
  |  Branch (1023:16): [True: 0, False: 0]
  ------------------
 1024|      0|			SET_STRING_ELT(t, j, mkCharCE(pt, CE_UTF8));
  ------------------
  |  |  999|      0|#define mkCharCE		Rf_mkCharCE
  ------------------
 1025|      0|		    else
 1026|      0|			SET_STRING_ELT(t, j, markKnown(pt, STRING_ELT(x, i)));
  ------------------
  |  | 1942|      0|# define markKnown		Rf_markKnown
  ------------------
 1027|      0|		}
 1028|      0|		if (*bufp) {
  ------------------
  |  Branch (1028:7): [True: 0, False: 0]
  ------------------
 1029|      0|		    if (useBytes)
  ------------------
  |  Branch (1029:11): [True: 0, False: 0]
  ------------------
 1030|      0|			SET_STRING_ELT(t, ntok, mkBytesNew(bufp, haveBytesInput));
 1031|      0|		    else if (use_UTF8)
  ------------------
  |  Branch (1031:16): [True: 0, False: 0]
  ------------------
 1032|      0|			SET_STRING_ELT(t, ntok, mkCharCE(bufp, CE_UTF8));
  ------------------
  |  |  999|      0|#define mkCharCE		Rf_mkCharCE
  ------------------
 1033|      0|		    else
 1034|      0|			SET_STRING_ELT(t, ntok, markKnown(bufp, STRING_ELT(x, i)));
  ------------------
  |  | 1942|      0|# define markKnown		Rf_markKnown
  ------------------
 1035|      0|		}
 1036|      0|		vmaxset(vmax2);
 1037|      0|	    }
 1038|       |	    /* The character tables serve all tokens and are freed after the
 1039|       |	       loop; the context releases them only on an unwind. */
 1040|      0|	    ci.tables = NULL;
 1041|      0|	    regex_cleanup_end(&ci, &cntxt);
 1042|     46|	} else if (!useBytes && use_UTF8) { /* ERE in wchar_t */
  ------------------
  |  Branch (1042:13): [True: 0, False: 46]
  |  Branch (1042:26): [True: 0, False: 0]
  ------------------
 1043|      0|	    regex_t reg;
 1044|      0|	    regmatch_t regmatch[1];
 1045|      0|	    int rc;
 1046|      0|	    int cflags = REG_EXTENDED;
  ------------------
  |  |   98|      0|#define REG_EXTENDED	1
  ------------------
 1047|      0|	    const wchar_t *wbuf, *wbufp, *wsplit;
 1048|       |
 1049|       |	    /* Careful: need to distinguish empty (rm_eo == 0) from
 1050|       |	       non-empty (rm_eo > 0) matches.  In the former case, the
 1051|       |	       token extracted is the next character.  Otherwise, it is
 1052|       |	       everything before the start of the match, which may be
 1053|       |	       the empty string (not a ``token'' in the strict sense).
 1054|       |	    */
 1055|       |
 1056|      0|	    wsplit = wtransChar2(STRING_ELT(tok, itok));
  ------------------
  |  | 2017|      0|# define wtransChar2		Rf_wtransChar2
  ------------------
 1057|      0|	    if (!wsplit)
  ------------------
  |  Branch (1057:10): [True: 0, False: 0]
  ------------------
 1058|      0|		error(_("'split' string %lld is invalid"), (long long)itok+1);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("'split' string %lld is invalid"), (long long)itok+1);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1059|      0|	    if ((rc = tre_regwcomp(&reg, wsplit, cflags)))
  ------------------
  |  Branch (1059:10): [True: 0, False: 0]
  ------------------
 1060|      0|		reg_report(rc, &reg, translateChar(STRING_ELT(tok, itok)));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
 1061|      0|	    regex_cleanup_info ci;
 1062|      0|	    RCNTXT cntxt;
 1063|      0|	    regex_cleanup_begin(&ci, &cntxt, call, false, false, &reg, NULL,
 1064|      0|				NULL, NULL, NULL);
 1065|      0|	    bool ascii_split = IS_ASCII(STRING_ELT(tok, itok));
 1066|       |
 1067|      0|	    vmax2 = vmaxget();
 1068|      0|	    for (i = itok; i < len; i += tlen) {
  ------------------
  |  Branch (1068:21): [True: 0, False: 0]
  ------------------
 1069|      0|		SEXP t;
 1070|      0|		if (STRING_ELT(x, i) == NA_STRING) {
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1070:7): [True: 0, False: 0]
  ------------------
 1071|      0|		    SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              		    SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
 1072|      0|		    continue;
 1073|      0|		}
 1074|      0|		wbuf = wtransChar2(STRING_ELT(x, i));
  ------------------
  |  | 2017|      0|# define wtransChar2		Rf_wtransChar2
  ------------------
 1075|      0|		bool ascii_xi = IS_ASCII(STRING_ELT(x, i));
 1076|      0|		if (!wbuf) {
  ------------------
  |  Branch (1076:7): [True: 0, False: 0]
  ------------------
 1077|      0|		    if(nwarn++ < NWARN)
  ------------------
  |  |   62|      0|#define NWARN 5
  ------------------
  |  Branch (1077:10): [True: 0, False: 0]
  ------------------
 1078|      0|			warning(_("input string %lld is invalid"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			warning(_("input string %lld is invalid"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1079|      0|			        (long long)i+1);
 1080|      0|		    SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              		    SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
 1081|      0|		    continue;
 1082|      0|		}
 1083|       |
 1084|       |		/* find out how many splits there will be */
 1085|      0|		ntok = 0;
 1086|      0|		wbufp = wbuf;
 1087|      0|		if (*wbufp) {
  ------------------
  |  Branch (1087:7): [True: 0, False: 0]
  ------------------
 1088|      0|		    while(tre_regwexec(&reg, wbufp, 1, regmatch, 0) == 0) {
  ------------------
  |  Branch (1088:13): [True: 0, False: 0]
  ------------------
 1089|       |			/* Empty matches get the next char, so move by one. */
 1090|      0|			wbufp += MAX(regmatch[0].rm_eo, 1);
  ------------------
  |  |  140|      0|# define MAX(a, b) ((a) > (b) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (140:21): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1091|      0|			ntok++;
 1092|      0|			if (!*wbufp) break;
  ------------------
  |  Branch (1092:8): [True: 0, False: 0]
  ------------------
 1093|      0|		    }
 1094|      0|		}
 1095|      0|		SET_VECTOR_ELT(ans, i,
 1096|      0|			       t = allocVector(STRSXP, ntok + (*wbufp ? 1 : 0)));
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              			       t = allocVector(STRSXP, ntok + (*wbufp ? 1 : 0)));
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1096:43): [True: 0, False: 0]
  ------------------
 1097|       |		/* and fill with the splits */
 1098|      0|		wbufp = wbuf;
 1099|      0|		wpt = R_Realloc(wpt, wcslen(wbuf)+1, wchar_t);
  ------------------
  |  |   56|      0|#define R_Realloc(p,n,t) (t *) R_chk_realloc( (void *)(p), (R_SIZE_T)((n) * sizeof(t)) )
  ------------------
 1100|      0|		for (j = 0; j < ntok; j++) {
  ------------------
  |  Branch (1100:15): [True: 0, False: 0]
  ------------------
 1101|      0|		    tre_regwexec(&reg, wbufp, 1, regmatch, 0);
 1102|      0|		    if (regmatch[0].rm_eo > 0) {
  ------------------
  |  Branch (1102:11): [True: 0, False: 0]
  ------------------
 1103|       |			/* Match was non-empty. */
 1104|      0|			if (regmatch[0].rm_so > 0)
  ------------------
  |  Branch (1104:8): [True: 0, False: 0]
  ------------------
 1105|      0|			    wcsncpy(wpt, wbufp, regmatch[0].rm_so);
 1106|      0|			wpt[regmatch[0].rm_so] = 0;
 1107|      0|			wbufp += regmatch[0].rm_eo;
 1108|      0|		    } else {
 1109|       |			/* Match was empty. */
 1110|      0|			wpt[0] = *wbufp;
 1111|      0|			wpt[1] = 0;
 1112|      0|			wbufp++;
 1113|      0|		    }
 1114|      0|		    SET_STRING_ELT(t, j,
 1115|      0|				   mkCharWLenASCII(wpt, regmatch[0].rm_so,
 1116|      0|				                   ascii_split && ascii_xi));
  ------------------
  |  Branch (1116:24): [True: 0, False: 0]
  |  Branch (1116:39): [True: 0, False: 0]
  ------------------
 1117|      0|		}
 1118|      0|		if (*wbufp)
  ------------------
  |  Branch (1118:7): [True: 0, False: 0]
  ------------------
 1119|      0|		    SET_STRING_ELT(t, ntok,
 1120|      0|				   mkCharWLenASCII(wbufp, (int) wcslen(wbufp),
 1121|      0|				                   ascii_split && ascii_xi));
  ------------------
  |  Branch (1121:24): [True: 0, False: 0]
  |  Branch (1121:39): [True: 0, False: 0]
  ------------------
 1122|      0|		vmaxset(vmax2);
 1123|      0|	    }
 1124|      0|	    regex_cleanup_end(&ci, &cntxt);
 1125|     46|	} else { /* ERE in normal chars -- single byte */
 1126|       |	         /* previously used also with MBCS */
 1127|     46|	    regex_t reg;
 1128|     46|	    regmatch_t regmatch[1];
 1129|     46|	    int rc;
 1130|     46|	    int cflags = REG_EXTENDED;
  ------------------
  |  |   98|     46|#define REG_EXTENDED	1
  ------------------
 1131|       |
 1132|       |	    /* Careful: need to distinguish empty (rm_eo == 0) from
 1133|       |	       non-empty (rm_eo > 0) matches.  In the former case, the
 1134|       |	       token extracted is the next character.  Otherwise, it is
 1135|       |	       everything before the start of the match, which may be
 1136|       |	       the empty string (not a ``token'' in the strict sense).
 1137|       |	    */
 1138|       |	    /* never use_UTF8 */
 1139|     46|	    if (useBytes)
  ------------------
  |  Branch (1139:10): [True: 46, False: 0]
  ------------------
 1140|     46|		split = CHAR(STRING_ELT(tok, itok));
  ------------------
  |  |  203|     46|#define CHAR(x) R_CHAR(x)
  ------------------
 1141|      0|	    else {
 1142|      0|		split = translateCharFP2(STRING_ELT(tok, itok));
  ------------------
  |  | 1999|      0|# define translateCharFP2	Rf_translateCharFP2
  ------------------
 1143|      0|		if (!split || (mbcslocale && !mbcsValid(split)))
  ------------------
  |  | 1952|      0|# define mbcsValid		Rf_mbcsValid
  ------------------
  |  Branch (1143:7): [True: 0, False: 0]
  |  Branch (1143:18): [True: 0, False: 0]
  |  Branch (1143:32): [True: 0, False: 0]
  ------------------
 1144|      0|		    error(_("'split' string %lld is invalid in this locale"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("'split' string %lld is invalid in this locale"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1145|      0|		          (long long)itok+1);
 1146|      0|	    }
 1147|     46|	    if (useBytes)
  ------------------
  |  Branch (1147:10): [True: 46, False: 0]
  ------------------
 1148|     46|		rc = tre_regcompb(&reg, split, cflags);
 1149|      0|	    else
 1150|      0|		rc = tre_regcomp(&reg, split, cflags);
 1151|       |
 1152|     46|	    if(rc) reg_report(rc, &reg, split);
  ------------------
  |  Branch (1152:9): [True: 0, False: 46]
  ------------------
 1153|       |
 1154|     46|	    regex_cleanup_info ci;
 1155|     46|	    RCNTXT cntxt;
 1156|     46|	    regex_cleanup_begin(&ci, &cntxt, call, false, false, &reg, NULL,
 1157|     46|				NULL, NULL, NULL);
 1158|       |
 1159|     46|	    vmax2 = vmaxget();
 1160|     92|	    for (i = itok; i < len; i += tlen) {
  ------------------
  |  Branch (1160:21): [True: 46, False: 46]
  ------------------
 1161|     46|		SEXP t;
 1162|     46|		if (STRING_ELT(x, i) == NA_STRING) {
  ------------------
  |  |  433|     46|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1162:7): [True: 0, False: 46]
  ------------------
 1163|      0|		    SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              		    SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
 1164|      0|		    continue;
 1165|      0|		}
 1166|       |		/* never use_UTF8 */
 1167|     46|		if (useBytes)
  ------------------
  |  Branch (1167:7): [True: 46, False: 0]
  ------------------
 1168|     46|		    buf = CHAR(STRING_ELT(x, i));
  ------------------
  |  |  203|     46|#define CHAR(x) R_CHAR(x)
  ------------------
 1169|      0|		else {
 1170|      0|		    buf = translateCharFP2(STRING_ELT(x, i));
  ------------------
  |  | 1999|      0|# define translateCharFP2	Rf_translateCharFP2
  ------------------
 1171|      0|		    if (!buf || (mbcslocale && !mbcsValid(buf))) {
  ------------------
  |  | 1952|      0|# define mbcsValid		Rf_mbcsValid
  ------------------
  |  Branch (1171:11): [True: 0, False: 0]
  |  Branch (1171:20): [True: 0, False: 0]
  |  Branch (1171:34): [True: 0, False: 0]
  ------------------
 1172|      0|			if(nwarn++ < NWARN)
  ------------------
  |  |   62|      0|#define NWARN 5
  ------------------
  |  Branch (1172:7): [True: 0, False: 0]
  ------------------
 1173|      0|			    warning(_("input string %lld is invalid in this locale"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			    warning(_("input string %lld is invalid in this locale"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1174|      0|			            (long long)i+1);
 1175|      0|			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
              			SET_VECTOR_ELT(ans, i, ScalarString(NA_STRING));
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
 1176|      0|			continue;
 1177|      0|		    }
 1178|      0|		}
 1179|       |
 1180|       |		/* find out how many splits there will be */
 1181|     46|		ntok = 0;
 1182|     46|		bufp = buf;
 1183|     46|		if (*bufp) {
  ------------------
  |  Branch (1183:7): [True: 44, False: 2]
  ------------------
 1184|     44|		    if (useBytes) {
  ------------------
  |  Branch (1184:11): [True: 44, False: 0]
  ------------------
 1185|    122|			while(!(rc = tre_regexecb(&reg, bufp, 1, regmatch, 0))) {
  ------------------
  |  Branch (1185:10): [True: 78, False: 44]
  ------------------
 1186|       |			/* Empty matches get the next char, so move by one. */
 1187|     78|			bufp += MAX(regmatch[0].rm_eo, 1);
  ------------------
  |  |  140|     78|# define MAX(a, b) ((a) > (b) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (140:21): [True: 78, False: 0]
  |  |  ------------------
  ------------------
 1188|     78|			ntok++;
 1189|     78|			if (*bufp == '\0') break;
  ------------------
  |  Branch (1189:8): [True: 0, False: 78]
  ------------------
 1190|     78|		    }
 1191|     44|		    } else {
 1192|      0|			while(!(rc = tre_regexec(&reg, bufp, 1, regmatch, 0))) {
  ------------------
  |  Branch (1192:10): [True: 0, False: 0]
  ------------------
 1193|       |			    /* Empty matches get the next char, so move by one. */
 1194|       |                            /* Not necessarily correct with MBCS, but only used
 1195|       |			       with single bytes */
 1196|      0|			    bufp += MAX(regmatch[0].rm_eo, 1);
  ------------------
  |  |  140|      0|# define MAX(a, b) ((a) > (b) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (140:21): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1197|      0|			    ntok++;
 1198|      0|			    if (*bufp == '\0') break;
  ------------------
  |  Branch (1198:12): [True: 0, False: 0]
  ------------------
 1199|      0|			}
 1200|      0|		    }
 1201|       |		    // AFAICS the only possible error report is REG_ESPACE
 1202|     44|		    if (rc == REG_ESPACE)
  ------------------
  |  Branch (1202:11): [True: 0, False: 44]
  ------------------
 1203|      0|			warning("Out-of-memory error in regexp matching for element %d",
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
 1204|      0|				(int) i + 1);
 1205|     44|		}
 1206|     46|		SET_VECTOR_ELT(ans, i,
 1207|     46|			       t = allocVector(STRSXP, ntok + (*bufp ? 1 : 0)));
  ------------------
  |  |  875|     46|#define allocVector		Rf_allocVector
  ------------------
              			       t = allocVector(STRSXP, ntok + (*bufp ? 1 : 0)));
  ------------------
  |  |  126|     46|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1207:43): [True: 44, False: 2]
  ------------------
 1208|       |		/* and fill with the splits */
 1209|     46|		bufp = buf;
 1210|     46|		pt = R_Realloc(pt, strlen(buf)+1, char);
  ------------------
  |  |   56|     46|#define R_Realloc(p,n,t) (t *) R_chk_realloc( (void *)(p), (R_SIZE_T)((n) * sizeof(t)) )
  ------------------
 1211|    124|		for (j = 0; j < ntok; j++) {
  ------------------
  |  Branch (1211:15): [True: 78, False: 46]
  ------------------
 1212|     78|		    int rc;
 1213|     78|		    if(useBytes) rc = tre_regexecb(&reg, bufp, 1, regmatch, 0);
  ------------------
  |  Branch (1213:10): [True: 78, False: 0]
  ------------------
 1214|      0|		    else rc = tre_regexec(&reg, bufp, 1, regmatch, 0);
 1215|       |
 1216|       |		    // AFAICS the only possible error report is REG_ESPACE
 1217|     78|		    if (rc == REG_ESPACE)
  ------------------
  |  Branch (1217:11): [True: 0, False: 78]
  ------------------
 1218|      0|			warning("Out-of-memory error in regexp matching for element %d",
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
 1219|      0|				(int) i + 1);
 1220|     78|		    if (regmatch[0].rm_eo > 0) {
  ------------------
  |  Branch (1220:11): [True: 78, False: 0]
  ------------------
 1221|       |			/* Match was non-empty. */
 1222|     78|			if (regmatch[0].rm_so > 0)
  ------------------
  |  Branch (1222:8): [True: 78, False: 0]
  ------------------
 1223|     78|			    strncpy(pt, bufp, regmatch[0].rm_so);
 1224|     78|			pt[regmatch[0].rm_so] = '\0';
 1225|     78|			bufp += regmatch[0].rm_eo;
 1226|     78|		    } else {
 1227|       |			/* Match was empty. */
 1228|      0|			pt[0] = *bufp;
 1229|      0|			pt[1] = '\0';
 1230|       |			/* Not necessarily correct with MBCS, but only used
 1231|       |			   with single bytes */
 1232|      0|			bufp++;
 1233|      0|		    }
 1234|     78|		    if (useBytes)
  ------------------
  |  Branch (1234:11): [True: 78, False: 0]
  ------------------
 1235|     78|			SET_STRING_ELT(t, j, mkBytesNew(pt, haveBytesInput));
 1236|      0|		    else
 1237|      0|			SET_STRING_ELT(t, j, markKnown(pt, STRING_ELT(x, i)));
  ------------------
  |  | 1942|      0|# define markKnown		Rf_markKnown
  ------------------
 1238|     78|		}
 1239|     46|		if (*bufp) {
  ------------------
  |  Branch (1239:7): [True: 44, False: 2]
  ------------------
 1240|     44|		    if (useBytes)
  ------------------
  |  Branch (1240:11): [True: 44, False: 0]
  ------------------
 1241|     44|			SET_STRING_ELT(t, ntok, mkBytesNew(bufp, haveBytesInput));
 1242|      0|		    else
 1243|      0|			SET_STRING_ELT(t, ntok, markKnown(bufp, STRING_ELT(x, i)));
  ------------------
  |  | 1942|      0|# define markKnown		Rf_markKnown
  ------------------
 1244|     44|		}
 1245|     46|		vmaxset(vmax2);
 1246|     46|	    }
 1247|     46|	    regex_cleanup_end(&ci, &cntxt);
 1248|     46|	}
 1249|  1.92k|	vmaxset(vmax);
 1250|  1.92k|    }
 1251|       |
 1252|  1.92k|    if (getAttrib(x, R_NamesSymbol) != R_NilValue)
  ------------------
  |  |  924|  1.92k|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (1252:9): [True: 12, False: 1.90k]
  ------------------
 1253|     12|	namesgets(ans, getAttrib(x, R_NamesSymbol));
  ------------------
  |  | 1004|     12|#define namesgets		Rf_namesgets
  ------------------
              	namesgets(ans, getAttrib(x, R_NamesSymbol));
  ------------------
  |  |  924|     12|#define getAttrib		Rf_getAttrib
  ------------------
 1254|  1.92k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.92k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1255|  1.92k|    R_Free(pt); R_Free(wpt);
  ------------------
  |  |   57|  1.92k|#define R_Free(p)      (R_chk_free( (void *)(p) ), (p) = NULL)
  ------------------
                  R_Free(pt); R_Free(wpt);
  ------------------
  |  |   57|  1.92k|#define R_Free(p)      (R_chk_free( (void *)(p) ), (p) = NULL)
  ------------------
 1256|  1.92k|#ifdef HAVE_PCRE2
 1257|  1.92k|    if (tables) free((void *)tables);
  ------------------
  |  Branch (1257:9): [True: 0, False: 1.92k]
  ------------------
 1258|       |    /* new PCRE2 will have pcre2_maketables_free() */
 1259|       |#else
 1260|       |    if (tables) pcre_free((void *)tables);
 1261|       |#endif
 1262|  1.92k|    UNPROTECT(1); /* tok */
  ------------------
  |  |  358|  1.92k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1263|  1.92k|    return ans;
 1264|  1.92k|}
do_grep:
 1369|     74|{
 1370|     74|    SEXP pat, text, ind, ans;
 1371|     74|    regex_t reg;
 1372|     74|    R_xlen_t i, j, n;
 1373|     74|    int nmatches = 0, rc;
 1374|     74|    bool igcase_opt, value_opt, perl_opt, fixed_opt, useBytes, invert;
 1375|     74|    const char *spat = NULL;
 1376|     74|    const wchar_t *wpat = NULL;
 1377|     74|    const unsigned char *tables = NULL /* -Wall */;
 1378|     74|#ifdef HAVE_PCRE2
 1379|     74|    pcre2_code *re = NULL;
 1380|     74|    pcre2_match_context *mcontext = NULL;
 1381|     74|    uint32_t ovecsize = 1;
 1382|     74|    pcre2_match_data *mdata = NULL;
 1383|       |#else
 1384|       |    pcre *re_pcre = NULL /* -Wall */;
 1385|       |    pcre_extra *re_pe = NULL;
 1386|       |    int ovecsize = 3;
 1387|       |    int ov[ovecsize];
 1388|       |#endif
 1389|     74|    bool use_UTF8 = false, use_WC = false;
 1390|     74|    const void *vmax;
 1391|     74|    int nwarn = 0;
 1392|       |
 1393|     74|    checkArity(op, args);
  ------------------
  |  | 1788|     74|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1394|     74|    pat = CAR(args); args = CDR(args);
 1395|     74|    text = CAR(args); args = CDR(args);
 1396|     74|    igcase_opt = asBool2(CAR(args), call); args = CDR(args);
  ------------------
  |  | 1860|     74|# define asBool2	       	Rf_asBool2
  ------------------
 1397|     74|    value_opt = asBool2(CAR(args), call); args = CDR(args);
  ------------------
  |  | 1860|     74|# define asBool2	       	Rf_asBool2
  ------------------
 1398|     74|    perl_opt = asBool2(CAR(args), call); args = CDR(args);
  ------------------
  |  | 1860|     74|# define asBool2	       	Rf_asBool2
  ------------------
 1399|     74|    fixed_opt = asBool2(CAR(args), call); args = CDR(args);
  ------------------
  |  | 1860|     74|# define asBool2	       	Rf_asBool2
  ------------------
 1400|     74|    useBytes = asBool2(CAR(args), call); args = CDR(args);
  ------------------
  |  | 1860|     74|# define asBool2	       	Rf_asBool2
  ------------------
 1401|     74|    invert = asBool2(CAR(args), call);
  ------------------
  |  | 1860|     74|# define asBool2	       	Rf_asBool2
  ------------------
 1402|     74|    if (fixed_opt && igcase_opt)
  ------------------
  |  Branch (1402:9): [True: 6, False: 68]
  |  Branch (1402:22): [True: 0, False: 6]
  ------------------
 1403|      0|	warning(_("argument '%s' will be ignored"), "ignore.case = TRUE");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("argument '%s' will be ignored"), "ignore.case = TRUE");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1404|     74|    if (fixed_opt && perl_opt) {
  ------------------
  |  Branch (1404:9): [True: 6, False: 68]
  |  Branch (1404:22): [True: 0, False: 6]
  ------------------
 1405|      0|	warning(_("argument '%s' will be ignored"), "perl = TRUE");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("argument '%s' will be ignored"), "perl = TRUE");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1406|      0|	perl_opt = 0;
 1407|      0|    }
 1408|       |
 1409|     74|    if (!isString(pat) || LENGTH(pat) < 1)
  ------------------
  |  |  966|     74|#define isString		Rf_isString
  ------------------
  |  Branch (1409:9): [True: 0, False: 74]
  |  Branch (1409:27): [True: 0, False: 74]
  ------------------
 1410|      0|	error(_("invalid '%s' argument"), "pattern");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "pattern");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1411|     74|    if (LENGTH(pat) > 1)
  ------------------
  |  Branch (1411:9): [True: 0, False: 74]
  ------------------
 1412|      0|	warning(_("argument '%s' has length > 1 and only the first element will be used"), "pattern");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("argument '%s' has length > 1 and only the first element will be used"), "pattern");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1413|       |
 1414|     74|    if (!isString(text))
  ------------------
  |  |  966|     74|#define isString		Rf_isString
  ------------------
  |  Branch (1414:9): [True: 0, False: 74]
  ------------------
 1415|      0|	error(_("invalid '%s' argument"), "text");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "text");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1416|       |
 1417|     74|    n = XLENGTH(text);
 1418|     74|    if (STRING_ELT(pat, 0) == NA_STRING) {
  ------------------
  |  |  433|     74|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1418:9): [True: 0, False: 74]
  ------------------
 1419|      0|	if (value_opt) {
  ------------------
  |  Branch (1419:6): [True: 0, False: 0]
  ------------------
 1420|      0|	    SEXP nmold = PROTECT(getAttrib(text, R_NamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1421|      0|	    PROTECT(ans = allocVector(STRSXP, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1422|      0|	    for (i = 0; i < n; i++)  SET_STRING_ELT(ans, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1422:18): [True: 0, False: 0]
  ------------------
 1423|      0|	    if (!isNull(nmold))
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (1423:10): [True: 0, False: 0]
  ------------------
 1424|      0|		setAttrib(ans, R_NamesSymbol, duplicate(nmold));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              		setAttrib(ans, R_NamesSymbol, duplicate(nmold));
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 1425|      0|	    UNPROTECT(2); /* ans, nmold */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1426|      0|	} else if (PRIMVAL(op)) { // grepl case
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (1347:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1427|      0|	    ans = allocVector(LGLSXP, n);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	    ans = allocVector(LGLSXP, n);
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
 1428|      0|	    for (i = 0; i < n; i++)  LOGICAL(ans)[i] = NA_LOGICAL;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1428:18): [True: 0, False: 0]
  ------------------
 1429|      0|	} else {
 1430|      0|	    ans = allocVector(INTSXP, n);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	    ans = allocVector(INTSXP, n);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
 1431|      0|	    for (i = 0; i < n; i++)  INTEGER(ans)[i] = NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1431:18): [True: 0, False: 0]
  ------------------
 1432|      0|	}
 1433|      0|	return ans;
 1434|      0|    }
 1435|       |
 1436|     74|    if (!useBytes) 
  ------------------
  |  Branch (1436:9): [True: 74, False: 0]
  ------------------
 1437|     74|	useBytes = only_ascii(pat, 1) && only_ascii(text, n);
  ------------------
  |  Branch (1437:13): [True: 74, False: 0]
  |  Branch (1437:35): [True: 74, False: 0]
  ------------------
 1438|     74|    if (!useBytes) 
  ------------------
  |  Branch (1438:9): [True: 0, False: 74]
  ------------------
 1439|      0|	useBytes = have_bytes(pat, 1) || have_bytes(text, n);
  ------------------
  |  Branch (1439:13): [True: 0, False: 0]
  |  Branch (1439:35): [True: 0, False: 0]
  ------------------
 1440|     74|    if (!useBytes) {
  ------------------
  |  Branch (1440:9): [True: 0, False: 74]
  ------------------
 1441|       |	/* As from R 2.10.0 we use UTF-8 mode in PCRE in all MBCS locales */
 1442|       |	/* if we have non-ASCII text in a DBCS locale, we need to use wchar in TRE */
 1443|      0|	if (!fixed_opt && mbcslocale) use_UTF8 = true;
  ------------------
  |  Branch (1443:6): [True: 0, False: 0]
  |  Branch (1443:20): [True: 0, False: 0]
  ------------------
 1444|      0|	if (!use_UTF8)
  ------------------
  |  Branch (1444:6): [True: 0, False: 0]
  ------------------
 1445|      0|	    use_UTF8 = have_utf8(pat, 1) || have_utf8(text, n);
  ------------------
  |  Branch (1445:17): [True: 0, False: 0]
  |  Branch (1445:38): [True: 0, False: 0]
  ------------------
 1446|      0|	if (!use_UTF8 && !latin1locale)
  ------------------
  |  Branch (1446:6): [True: 0, False: 0]
  |  Branch (1446:19): [True: 0, False: 0]
  ------------------
 1447|      0|	    use_UTF8 = have_latin1(pat, 1) || have_latin1(text, n);
  ------------------
  |  Branch (1447:17): [True: 0, False: 0]
  |  Branch (1447:40): [True: 0, False: 0]
  ------------------
 1448|      0|    }
 1449|       |
 1450|     74|    if (!fixed_opt && !perl_opt) {
  ------------------
  |  Branch (1450:9): [True: 68, False: 6]
  |  Branch (1450:23): [True: 68, False: 0]
  ------------------
 1451|     68|	use_WC = use_UTF8; use_UTF8 = false;
 1452|     68|    }
 1453|     74|    if (useBytes)
  ------------------
  |  Branch (1453:9): [True: 74, False: 0]
  ------------------
 1454|     74|	spat = CHAR(STRING_ELT(pat, 0));
  ------------------
  |  |  203|     74|#define CHAR(x) R_CHAR(x)
  ------------------
 1455|      0|    else if (use_WC) {
  ------------------
  |  Branch (1455:14): [True: 0, False: 0]
  ------------------
 1456|      0|	wpat = wtransChar2(STRING_ELT(pat, 0));
  ------------------
  |  | 2017|      0|# define wtransChar2		Rf_wtransChar2
  ------------------
 1457|      0|	if (!wpat) error(_("regular expression is invalid"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if (!wpat) error(_("regular expression is invalid"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (1457:6): [True: 0, False: 0]
  ------------------
 1458|      0|    } else if (use_UTF8) {
  ------------------
  |  Branch (1458:16): [True: 0, False: 0]
  ------------------
 1459|      0|	spat = trCharUTF82(STRING_ELT(pat, 0));
  ------------------
  |  | 2001|      0|# define trCharUTF82      	Rf_trCharUTF82
  ------------------
 1460|      0|	if (!spat || !utf8Valid(spat)) error(_("regular expression is invalid UTF-8"));
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
              	if (!spat || !utf8Valid(spat)) error(_("regular expression is invalid UTF-8"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if (!spat || !utf8Valid(spat)) error(_("regular expression is invalid UTF-8"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (1460:6): [True: 0, False: 0]
  |  Branch (1460:15): [True: 0, False: 0]
  ------------------
 1461|      0|    } else {
 1462|      0|	spat = translateCharFP2(STRING_ELT(pat, 0));
  ------------------
  |  | 1999|      0|# define translateCharFP2	Rf_translateCharFP2
  ------------------
 1463|      0|	if (!spat || (mbcslocale && !mbcsValid(spat)))
  ------------------
  |  | 1952|      0|# define mbcsValid		Rf_mbcsValid
  ------------------
  |  Branch (1463:6): [True: 0, False: 0]
  |  Branch (1463:16): [True: 0, False: 0]
  |  Branch (1463:30): [True: 0, False: 0]
  ------------------
 1464|      0|	    error(_("regular expression is invalid in this locale"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("regular expression is invalid in this locale"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1465|      0|    }
 1466|       |
 1467|     74|    if (fixed_opt) ;
  ------------------
  |  Branch (1467:9): [True: 6, False: 68]
  ------------------
 1468|     68|    else if (perl_opt) {
  ------------------
  |  Branch (1468:14): [True: 0, False: 68]
  ------------------
 1469|      0|#ifdef HAVE_PCRE2
 1470|      0|	R_pcre2_prepare(spat, text, use_UTF8, igcase_opt, &tables, &re,
 1471|      0|	                &mcontext);
 1472|      0|	mdata = pcre2_match_data_create(ovecsize, NULL);
 1473|       |#else
 1474|       |	R_pcre_prepare(spat, text, use_UTF8, igcase_opt, false, &tables,
 1475|       |                     &re_pcre, &re_pe);
 1476|       |#endif
 1477|     68|    } else {
 1478|     68|	int cflags = REG_NOSUB | REG_EXTENDED;
  ------------------
  |  |  101|     68|#define REG_NOSUB	(REG_NEWLINE << 1)
  |  |  ------------------
  |  |  |  |  100|     68|#define REG_NEWLINE	(REG_ICASE << 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |   99|     68|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   98|     68|#define REG_EXTENDED	1
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
              	int cflags = REG_NOSUB | REG_EXTENDED;
  ------------------
  |  |   98|     68|#define REG_EXTENDED	1
  ------------------
 1479|     68|	if (igcase_opt) cflags |= REG_ICASE;
  ------------------
  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  ------------------
  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  ------------------
  ------------------
  |  Branch (1479:6): [True: 0, False: 68]
  ------------------
 1480|     68|	if (!use_WC)
  ------------------
  |  Branch (1480:6): [True: 68, False: 0]
  ------------------
 1481|     68|	    rc = tre_regcompb(&reg, spat, cflags);
 1482|      0|	else
 1483|      0|	    rc = tre_regwcomp(&reg, wpat, cflags);
 1484|     68|	if (rc) reg_report(rc, &reg, spat);
  ------------------
  |  Branch (1484:6): [True: 0, False: 68]
  ------------------
 1485|     68|    }
 1486|       |
 1487|     74|    regex_cleanup_info ci;
 1488|     74|    RCNTXT cntxt;
 1489|     74|#ifdef HAVE_PCRE2
 1490|     74|    regex_cleanup_begin(&ci, &cntxt, call, fixed_opt, perl_opt, &reg, tables,
 1491|     74|			re, mdata, mcontext);
 1492|       |#else
 1493|       |    regex_cleanup_begin(&ci, &cntxt, call, fixed_opt, perl_opt, &reg, tables,
 1494|       |			re_pcre, re_pe, NULL);
 1495|       |#endif
 1496|       |
 1497|     74|    PROTECT(ind = allocVector(LGLSXP, n));
  ------------------
  |  |  357|     74|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1498|     74|    vmax = vmaxget();
 1499|  4.66k|    for (i = 0 ; i < n ; i++) {
  ------------------
  |  Branch (1499:18): [True: 4.59k, False: 74]
  ------------------
 1500|       |//	if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
 1501|  4.59k|	LOGICAL(ind)[i] = 0;
 1502|  4.59k|	if (STRING_ELT(text, i) != NA_STRING) {
  ------------------
  |  |  433|  4.59k|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1502:6): [True: 4.59k, False: 0]
  ------------------
 1503|  4.59k|	    const char *s = NULL;
 1504|  4.59k|	    const wchar_t *ws = NULL;
 1505|  4.59k|	    if (useBytes)
  ------------------
  |  Branch (1505:10): [True: 4.59k, False: 0]
  ------------------
 1506|  4.59k|		s = CHAR(STRING_ELT(text, i));
  ------------------
  |  |  203|  4.59k|#define CHAR(x) R_CHAR(x)
  ------------------
 1507|      0|	    else if (use_WC) {
  ------------------
  |  Branch (1507:15): [True: 0, False: 0]
  ------------------
 1508|      0|		ws = wtransChar2(STRING_ELT(text, i));
  ------------------
  |  | 2017|      0|# define wtransChar2		Rf_wtransChar2
  ------------------
 1509|      0|		if (!ws) {
  ------------------
  |  Branch (1509:7): [True: 0, False: 0]
  ------------------
 1510|      0|		    if(nwarn++ < NWARN)
  ------------------
  |  |   62|      0|#define NWARN 5
  ------------------
  |  Branch (1510:10): [True: 0, False: 0]
  ------------------
 1511|      0|			warning(_("input string %lld is invalid"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			warning(_("input string %lld is invalid"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1512|      0|			        (long long)i+1);
 1513|      0|		    continue;
 1514|      0|		}
 1515|      0|	    } else if (use_UTF8) {
  ------------------
  |  Branch (1515:17): [True: 0, False: 0]
  ------------------
 1516|      0|		s = trCharUTF82(STRING_ELT(text, i));
  ------------------
  |  | 2001|      0|# define trCharUTF82      	Rf_trCharUTF82
  ------------------
 1517|      0|		if (!s || !utf8Valid(s)) {
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
  |  Branch (1517:7): [True: 0, False: 0]
  |  Branch (1517:13): [True: 0, False: 0]
  ------------------
 1518|      0|		    if(nwarn++ < NWARN)
  ------------------
  |  |   62|      0|#define NWARN 5
  ------------------
  |  Branch (1518:10): [True: 0, False: 0]
  ------------------
 1519|      0|			warning(_("input string %lld is invalid UTF-8"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			warning(_("input string %lld is invalid UTF-8"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1520|      0|			        (long long)i+1);
 1521|      0|		    continue;
 1522|      0|		}
 1523|      0|	    } else {
 1524|      0|		s = translateCharFP2(STRING_ELT(text, i));
  ------------------
  |  | 1999|      0|# define translateCharFP2	Rf_translateCharFP2
  ------------------
 1525|      0|		if (!s || (mbcslocale && !mbcsValid(s))) {
  ------------------
  |  | 1952|      0|# define mbcsValid		Rf_mbcsValid
  ------------------
  |  Branch (1525:7): [True: 0, False: 0]
  |  Branch (1525:14): [True: 0, False: 0]
  |  Branch (1525:28): [True: 0, False: 0]
  ------------------
 1526|      0|		    if(nwarn++ < NWARN)
  ------------------
  |  |   62|      0|#define NWARN 5
  ------------------
  |  Branch (1526:10): [True: 0, False: 0]
  ------------------
 1527|      0|			warning(_("input string %lld is invalid in this locale"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			warning(_("input string %lld is invalid in this locale"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1528|      0|			        (long long)i+1);
 1529|      0|		    continue;
 1530|      0|		}
 1531|      0|	    }
 1532|       |
 1533|  4.59k|	    if (fixed_opt)
  ------------------
  |  Branch (1533:10): [True: 6, False: 4.58k]
  ------------------
 1534|      6|		LOGICAL(ind)[i] = fgrep_one(spat, s, useBytes, use_UTF8, NULL) >= 0;
 1535|  4.58k|	    else if (perl_opt) {
  ------------------
  |  Branch (1535:15): [True: 0, False: 4.58k]
  ------------------
 1536|      0|#ifdef HAVE_PCRE2
 1537|      0|		uint32_t eflag = 0;
 1538|      0|		if (use_UTF8) eflag |= PCRE2_NO_UTF_CHECK;
  ------------------
  |  Branch (1538:7): [True: 0, False: 0]
  ------------------
 1539|       |
 1540|      0|		int rc = pcre2_match(re, (PCRE2_SPTR) s, PCRE2_ZERO_TERMINATED,
 1541|      0|		                     0, eflag, mdata, mcontext);
 1542|       |#else
 1543|       |		int rc =
 1544|       |		    pcre_exec(re_pcre, re_pe, s, (int) strlen(s), 0, 0, ov, 0);
 1545|       |#endif
 1546|      0|		if(rc >= 0) LOGICAL(ind)[i] = 1;
  ------------------
  |  Branch (1546:6): [True: 0, False: 0]
  ------------------
 1547|      0|		else {
 1548|      0|		    LOGICAL(ind)[i] = 0;
 1549|      0|		    R_pcre_exec_error(rc, i);
 1550|      0|		}
 1551|  4.58k|	    } else {
 1552|  4.58k|		if (!use_WC)
  ------------------
  |  Branch (1552:7): [True: 4.58k, False: 0]
  ------------------
 1553|  4.58k|		    rc = tre_regexecb(&reg, s, 0, NULL, 0);
 1554|      0|		else
 1555|      0|		    rc = tre_regwexec(&reg, ws, 0, NULL, 0);
 1556|  4.58k|		if (rc == 0) LOGICAL(ind)[i] = 1;
  ------------------
  |  Branch (1556:7): [True: 348, False: 4.23k]
  ------------------
 1557|       |		// AFAICS the only possible error report is REG_ESPACE
 1558|  4.58k|		if (rc == REG_ESPACE)
  ------------------
  |  Branch (1558:7): [True: 0, False: 4.58k]
  ------------------
 1559|      0|		    warning("Out-of-memory error in regexp matching for element %d",
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
 1560|      0|			    (int) i + 1);
 1561|  4.58k|	    }
 1562|  4.59k|	}
 1563|  4.59k|	vmaxset(vmax);
 1564|  4.59k|	if (invert ^ LOGICAL(ind)[i]) nmatches++;
  ------------------
  |  Branch (1564:6): [True: 348, False: 4.24k]
  ------------------
 1565|  4.59k|    }
 1566|       |
 1567|     74|    regex_cleanup_end(&ci, &cntxt);
 1568|       |
 1569|     74|    if (PRIMVAL(op)) {/* grepl case */
  ------------------
  |  | 1347|     74|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (1347:20): [True: 46, False: 28]
  |  |  ------------------
  ------------------
 1570|     46|	UNPROTECT(1); /* ind */
  ------------------
  |  |  358|     46|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1571|     46|	return ind;
 1572|     46|    }
 1573|       |
 1574|     28|    if (value_opt) {
  ------------------
  |  Branch (1574:9): [True: 8, False: 20]
  ------------------
 1575|      8|	SEXP nmold = PROTECT(getAttrib(text, R_NamesSymbol)), nm;
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1576|      8|	PROTECT(ans = allocVector(STRSXP, nmatches));
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1577|  4.53k|	for (i = 0, j = 0; i < n ; i++)
  ------------------
  |  Branch (1577:21): [True: 4.52k, False: 8]
  ------------------
 1578|  4.52k|	    if (invert ^ LOGICAL(ind)[i])
  ------------------
  |  Branch (1578:10): [True: 308, False: 4.21k]
  ------------------
 1579|    308|		SET_STRING_ELT(ans, j++, STRING_ELT(text, i));
 1580|       |	/* copy across names and subset */
 1581|      8|	if (!isNull(nmold)) {
  ------------------
  |  |  956|      8|#define isNull			Rf_isNull
  ------------------
  |  Branch (1581:6): [True: 0, False: 8]
  ------------------
 1582|      0|	    nm = allocVector(STRSXP, nmatches);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	    nm = allocVector(STRSXP, nmatches);
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
 1583|      0|	    for (i = 0, j = 0; i < n ; i++)
  ------------------
  |  Branch (1583:25): [True: 0, False: 0]
  ------------------
 1584|      0|		if (invert ^ LOGICAL(ind)[i])
  ------------------
  |  Branch (1584:7): [True: 0, False: 0]
  ------------------
 1585|      0|		    SET_STRING_ELT(nm, j++, STRING_ELT(nmold, i));
 1586|      0|	    setAttrib(ans, R_NamesSymbol, nm);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 1587|      0|	}
 1588|      8|	UNPROTECT(2); /* ans, nmold */
  ------------------
  |  |  358|      8|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1589|     20|    } else {
 1590|     20|#ifdef LONG_VECTOR_SUPPORT
 1591|     20|	if (n > INT_MAX) {
  ------------------
  |  Branch (1591:6): [True: 0, False: 20]
  ------------------
 1592|      0|	    ans = allocVector(REALSXP, nmatches);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	    ans = allocVector(REALSXP, nmatches);
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
 1593|      0|	    j = 0;
 1594|      0|	    for (i = 0 ; i < n ; i++)
  ------------------
  |  Branch (1594:19): [True: 0, False: 0]
  ------------------
 1595|      0|		if (invert ^ LOGICAL(ind)[i]) REAL(ans)[j++] = (double)(i + 1);
  ------------------
  |  Branch (1595:7): [True: 0, False: 0]
  ------------------
 1596|      0|	} else
 1597|     20|#endif
 1598|     20|	{
 1599|     20|	    ans = allocVector(INTSXP, nmatches);
  ------------------
  |  |  875|     20|#define allocVector		Rf_allocVector
  ------------------
              	    ans = allocVector(INTSXP, nmatches);
  ------------------
  |  |  123|     20|#define INTSXP	    13	  /* integer vectors */
  ------------------
 1600|     20|	    j = 0;
 1601|     40|	    for (i = 0 ; i < n ; i++)
  ------------------
  |  Branch (1601:19): [True: 20, False: 20]
  ------------------
 1602|     20|		if (invert ^ LOGICAL(ind)[i])
  ------------------
  |  Branch (1602:7): [True: 0, False: 20]
  ------------------
 1603|      0|		    INTEGER(ans)[j++] = (int) (i + 1);
 1604|     20|	}
 1605|     20|    }
 1606|     28|    UNPROTECT(1); /* ind */
  ------------------
  |  |  358|     28|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1607|     28|    return ans;
 1608|     74|}
do_gsub:
 2206|    100|{
 2207|    100|    SEXP pat, rep, text, ans;
 2208|    100|    regex_t reg;
 2209|    100|    regmatch_t regmatch[10];
 2210|    100|    R_xlen_t i, n;
 2211|    100|    int j, ns, nns, nmatch, offset, rc;
 2212|    100|    bool global, igcase_opt, perl_opt, fixed_opt, useBytes;
 2213|    100|    int eflags, last_end;
 2214|    100|    char *u, *cbuf;
 2215|    100|    const char *spat = NULL, *srep = NULL, *s = NULL;
 2216|    100|    size_t patlen = 0, replen = 0;
 2217|    100|    bool use_UTF8 = false, use_WC = false;
 2218|    100|    bool ascii_patrep = false;
 2219|    100|    const wchar_t *wpat = NULL, *wrep = NULL, *ws = NULL;
 2220|    100|    const unsigned char *tables = NULL;
 2221|    100|#ifdef HAVE_PCRE2
 2222|    100|    uint32_t ovecsize = 10;
 2223|    100|    pcre2_code *re = NULL;
 2224|    100|    pcre2_match_context *mcontext = NULL;
 2225|    100|    pcre2_match_data *mdata = NULL;
 2226|       |#else
 2227|       |    int ovecsize = 30;
 2228|       |    pcre *re_pcre = NULL;
 2229|       |    pcre_extra *re_pe  = NULL;
 2230|       |#endif
 2231|    100|    const void *vmax = vmaxget();
 2232|    100|    bool haveBytesInput;
 2233|       |
 2234|    100|    checkArity(op, args);
  ------------------
  |  | 1788|    100|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2235|       |
 2236|    100|    global = (bool) PRIMVAL(op);
  ------------------
  |  | 1347|    100|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
 2237|       |
 2238|    100|    pat = CAR(args); args = CDR(args);
 2239|    100|    rep = CAR(args); args = CDR(args);
 2240|    100|    text = CAR(args); args = CDR(args);
 2241|    100|    igcase_opt = asBool2(CAR(args), call); args = CDR(args);
  ------------------
  |  | 1860|    100|# define asBool2	       	Rf_asBool2
  ------------------
 2242|    100|    perl_opt = asBool2(CAR(args), call); args = CDR(args);
  ------------------
  |  | 1860|    100|# define asBool2	       	Rf_asBool2
  ------------------
 2243|    100|    fixed_opt = asBool2(CAR(args), call); args = CDR(args);
  ------------------
  |  | 1860|    100|# define asBool2	       	Rf_asBool2
  ------------------
 2244|    100|    useBytes = asBool2(CAR(args), call); args = CDR(args);
  ------------------
  |  | 1860|    100|# define asBool2	       	Rf_asBool2
  ------------------
 2245|    100|    if (fixed_opt && igcase_opt)
  ------------------
  |  Branch (2245:9): [True: 8, False: 92]
  |  Branch (2245:22): [True: 0, False: 8]
  ------------------
 2246|      0|	warning(_("argument '%s' will be ignored"), "ignore.case = TRUE");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("argument '%s' will be ignored"), "ignore.case = TRUE");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2247|    100|    if (fixed_opt && perl_opt) {
  ------------------
  |  Branch (2247:9): [True: 8, False: 92]
  |  Branch (2247:22): [True: 0, False: 8]
  ------------------
 2248|      0|	warning(_("argument '%s' will be ignored"), "perl = TRUE");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("argument '%s' will be ignored"), "perl = TRUE");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2249|      0|	perl_opt = 0;
 2250|      0|    }
 2251|       |
 2252|    100|    if (!isString(pat) || LENGTH(pat) < 1)
  ------------------
  |  |  966|    100|#define isString		Rf_isString
  ------------------
  |  Branch (2252:9): [True: 0, False: 100]
  |  Branch (2252:27): [True: 0, False: 100]
  ------------------
 2253|      0|	error(_("invalid '%s' argument"), "pattern");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "pattern");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2254|    100|    if (LENGTH(pat) > 1)
  ------------------
  |  Branch (2254:9): [True: 0, False: 100]
  ------------------
 2255|      0|	warning(_("argument '%s' has length > 1 and only the first element will be used"), "pattern");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("argument '%s' has length > 1 and only the first element will be used"), "pattern");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2256|    100|    if (!isString(rep) || LENGTH(rep) < 1)
  ------------------
  |  |  966|    100|#define isString		Rf_isString
  ------------------
  |  Branch (2256:9): [True: 0, False: 100]
  |  Branch (2256:27): [True: 0, False: 100]
  ------------------
 2257|      0|	error(_("invalid '%s' argument"), "replacement");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "replacement");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2258|    100|    if (LENGTH(rep) > 1)
  ------------------
  |  Branch (2258:9): [True: 0, False: 100]
  ------------------
 2259|      0|	warning(_("argument '%s' has length > 1 and only the first element will be used"), "replacement");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("argument '%s' has length > 1 and only the first element will be used"), "replacement");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2260|       |
 2261|    100|    if (!isString(text))
  ------------------
  |  |  966|    100|#define isString		Rf_isString
  ------------------
  |  Branch (2261:9): [True: 0, False: 100]
  ------------------
 2262|      0|	error(_("invalid '%s' argument"), "text");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "text");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2263|       |
 2264|    100|    n = XLENGTH(text);
 2265|       |    /* This contradicts the code below that has NA matching NA */
 2266|    100|    if (STRING_ELT(pat, 0) == NA_STRING) {
  ------------------
  |  |  433|    100|#define NA_STRING	R_NaString
  ------------------
  |  Branch (2266:9): [True: 0, False: 100]
  ------------------
 2267|      0|	PROTECT(ans = allocVector(STRSXP, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2268|      0|	for (i = 0; i < n; i++)  SET_STRING_ELT(ans, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (2268:14): [True: 0, False: 0]
  ------------------
 2269|       |
 2270|      0|	goto exit_gsub;
 2271|      0|    }
 2272|    100|    haveBytesInput = have_bytes(pat, 1) || have_bytes(rep, 1) ||
  ------------------
  |  Branch (2272:22): [True: 0, False: 100]
  |  Branch (2272:44): [True: 0, False: 100]
  ------------------
 2273|    100|                     have_bytes(text, n);
  ------------------
  |  Branch (2273:22): [True: 0, False: 100]
  ------------------
 2274|       |
 2275|    100|    if (!useBytes) 
  ------------------
  |  Branch (2275:9): [True: 100, False: 0]
  ------------------
 2276|    100|	useBytes = only_ascii(pat, 1) && only_ascii(rep, 1) && 
  ------------------
  |  Branch (2276:13): [True: 100, False: 0]
  |  Branch (2276:35): [True: 100, False: 0]
  ------------------
 2277|    100|	           only_ascii(text, n);
  ------------------
  |  Branch (2277:13): [True: 100, False: 0]
  ------------------
 2278|    100|    if (!useBytes) 
  ------------------
  |  Branch (2278:9): [True: 0, False: 100]
  ------------------
 2279|      0|	useBytes = haveBytesInput;
 2280|    100|    if (!useBytes) {
  ------------------
  |  Branch (2280:9): [True: 0, False: 100]
  ------------------
 2281|       |	/* if we have non-ASCII text in a DBCS locale, we need to use wchar in TRE */
 2282|      0|	if (!fixed_opt && mbcslocale) use_UTF8 = true;
  ------------------
  |  Branch (2282:6): [True: 0, False: 0]
  |  Branch (2282:20): [True: 0, False: 0]
  ------------------
 2283|      0|	if (!use_UTF8)
  ------------------
  |  Branch (2283:6): [True: 0, False: 0]
  ------------------
 2284|      0|	    use_UTF8 = have_utf8(pat, 1) || have_utf8(rep, 1) ||
  ------------------
  |  Branch (2284:17): [True: 0, False: 0]
  |  Branch (2284:38): [True: 0, False: 0]
  ------------------
 2285|      0|	               have_utf8(text, n);
  ------------------
  |  Branch (2285:17): [True: 0, False: 0]
  ------------------
 2286|      0|	if (!use_UTF8 && !latin1locale)
  ------------------
  |  Branch (2286:6): [True: 0, False: 0]
  |  Branch (2286:19): [True: 0, False: 0]
  ------------------
 2287|      0|	    use_UTF8 = have_latin1(pat, 1) || have_latin1(rep, 1) ||
  ------------------
  |  Branch (2287:17): [True: 0, False: 0]
  |  Branch (2287:40): [True: 0, False: 0]
  ------------------
 2288|      0|	               have_latin1(text, n);
  ------------------
  |  Branch (2288:17): [True: 0, False: 0]
  ------------------
 2289|      0|    }
 2290|       |
 2291|    100|    if (!fixed_opt && !perl_opt) {
  ------------------
  |  Branch (2291:9): [True: 92, False: 8]
  |  Branch (2291:23): [True: 92, False: 0]
  ------------------
 2292|     92|	use_WC = use_UTF8; use_UTF8 = false;
 2293|     92|    }
 2294|       |
 2295|    100|    if (useBytes) {
  ------------------
  |  Branch (2295:9): [True: 100, False: 0]
  ------------------
 2296|    100|	spat = CHAR(STRING_ELT(pat, 0));
  ------------------
  |  |  203|    100|#define CHAR(x) R_CHAR(x)
  ------------------
 2297|    100|	srep = CHAR(STRING_ELT(rep, 0));
  ------------------
  |  |  203|    100|#define CHAR(x) R_CHAR(x)
  ------------------
 2298|    100|    } else if (use_WC) {
  ------------------
  |  Branch (2298:16): [True: 0, False: 0]
  ------------------
 2299|      0|	wpat = wtransChar2(STRING_ELT(pat, 0));
  ------------------
  |  | 2017|      0|# define wtransChar2		Rf_wtransChar2
  ------------------
 2300|      0|	if (!wpat) error(_("'pattern' is invalid"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if (!wpat) error(_("'pattern' is invalid"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (2300:6): [True: 0, False: 0]
  ------------------
 2301|      0|	wrep = wtransChar2(STRING_ELT(rep, 0));
  ------------------
  |  | 2017|      0|# define wtransChar2		Rf_wtransChar2
  ------------------
 2302|      0|	if (!wrep) error(_("'replacement' is invalid"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if (!wrep) error(_("'replacement' is invalid"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (2302:6): [True: 0, False: 0]
  ------------------
 2303|      0|	ascii_patrep = (IS_ASCII(STRING_ELT(pat, 0)) &&
  ------------------
  |  Branch (2303:18): [True: 0, False: 0]
  ------------------
 2304|      0|	                IS_ASCII(STRING_ELT(rep, 0)));
  ------------------
  |  Branch (2304:18): [True: 0, False: 0]
  ------------------
 2305|      0|    } else if (use_UTF8) {
  ------------------
  |  Branch (2305:16): [True: 0, False: 0]
  ------------------
 2306|      0|	spat = trCharUTF82(STRING_ELT(pat, 0));
  ------------------
  |  | 2001|      0|# define trCharUTF82      	Rf_trCharUTF82
  ------------------
 2307|      0|	if (!spat || !utf8Valid(spat)) error(_("'pattern' is invalid UTF-8"));
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
              	if (!spat || !utf8Valid(spat)) error(_("'pattern' is invalid UTF-8"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if (!spat || !utf8Valid(spat)) error(_("'pattern' is invalid UTF-8"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (2307:6): [True: 0, False: 0]
  |  Branch (2307:15): [True: 0, False: 0]
  ------------------
 2308|      0|	srep = trCharUTF82(STRING_ELT(rep, 0));
  ------------------
  |  | 2001|      0|# define trCharUTF82      	Rf_trCharUTF82
  ------------------
 2309|      0|	if (!srep || !utf8Valid(srep)) error(_("'replacement' is invalid UTF-8"));
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
              	if (!srep || !utf8Valid(srep)) error(_("'replacement' is invalid UTF-8"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if (!srep || !utf8Valid(srep)) error(_("'replacement' is invalid UTF-8"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (2309:6): [True: 0, False: 0]
  |  Branch (2309:15): [True: 0, False: 0]
  ------------------
 2310|      0|    } else {
 2311|      0|	spat = translateCharFP2(STRING_ELT(pat, 0));
  ------------------
  |  | 1999|      0|# define translateCharFP2	Rf_translateCharFP2
  ------------------
 2312|      0|	if (!spat || (mbcslocale && !mbcsValid(spat)))
  ------------------
  |  | 1952|      0|# define mbcsValid		Rf_mbcsValid
  ------------------
  |  Branch (2312:6): [True: 0, False: 0]
  |  Branch (2312:16): [True: 0, False: 0]
  |  Branch (2312:30): [True: 0, False: 0]
  ------------------
 2313|      0|	    error(_("'pattern' is invalid in this locale"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("'pattern' is invalid in this locale"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2314|      0|	srep = translateCharFP2(STRING_ELT(rep, 0));
  ------------------
  |  | 1999|      0|# define translateCharFP2	Rf_translateCharFP2
  ------------------
 2315|      0|	if (!srep || (mbcslocale && !mbcsValid(srep)))
  ------------------
  |  | 1952|      0|# define mbcsValid		Rf_mbcsValid
  ------------------
  |  Branch (2315:6): [True: 0, False: 0]
  |  Branch (2315:16): [True: 0, False: 0]
  |  Branch (2315:30): [True: 0, False: 0]
  ------------------
 2316|      0|	    error(_("'replacement' is invalid in this locale"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("'replacement' is invalid in this locale"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2317|      0|    }
 2318|       |
 2319|    100|    if (fixed_opt) {
  ------------------
  |  Branch (2319:9): [True: 8, False: 92]
  ------------------
 2320|      8|	patlen = strlen(spat);
 2321|      8|	if (!patlen) error(_("zero-length pattern"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if (!patlen) error(_("zero-length pattern"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (2321:6): [True: 0, False: 8]
  ------------------
 2322|      8|	replen = strlen(srep);
 2323|     92|    } else if (perl_opt) {
  ------------------
  |  Branch (2323:16): [True: 0, False: 92]
  ------------------
 2324|      0|#ifdef HAVE_PCRE2
 2325|      0|	R_pcre2_prepare(spat, text, use_UTF8, igcase_opt, &tables, &re,
 2326|      0|	                &mcontext);
 2327|      0|	mdata = pcre2_match_data_create(ovecsize, NULL);
 2328|       |#else
 2329|       |	R_pcre_prepare(spat, text, use_UTF8, igcase_opt, false, &tables,
 2330|       |	             &re_pcre, &re_pe);
 2331|       |#endif
 2332|      0|	replen = strlen(srep);
 2333|     92|    } else {
 2334|     92|	int cflags = REG_EXTENDED;
  ------------------
  |  |   98|     92|#define REG_EXTENDED	1
  ------------------
 2335|     92|	if (igcase_opt) cflags |= REG_ICASE;
  ------------------
  |  |   99|      0|#define REG_ICASE	(REG_EXTENDED << 1)
  |  |  ------------------
  |  |  |  |   98|      0|#define REG_EXTENDED	1
  |  |  ------------------
  ------------------
  |  Branch (2335:6): [True: 0, False: 92]
  ------------------
 2336|     92|	if (!use_WC) {
  ------------------
  |  Branch (2336:6): [True: 92, False: 0]
  ------------------
 2337|     92|	    rc =  tre_regcompb(&reg, spat, cflags);
 2338|     92|	    if (rc) reg_report(rc, &reg, spat);
  ------------------
  |  Branch (2338:10): [True: 0, False: 92]
  ------------------
 2339|     92|	    replen = strlen(srep);
 2340|     92|	} else {
 2341|      0|	    rc  = tre_regwcomp(&reg, wpat, cflags);
 2342|      0|	    if (rc) reg_report(rc, &reg, translateChar(STRING_ELT(pat, 0)));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  |  Branch (2342:10): [True: 0, False: 0]
  ------------------
 2343|      0|	    replen = wcslen(wrep);
 2344|      0|	}
 2345|     92|    }
 2346|       |
 2347|    100|    regex_cleanup_info ci;
 2348|    100|    RCNTXT cntxt;
 2349|    100|#ifdef HAVE_PCRE2
 2350|    100|    regex_cleanup_begin(&ci, &cntxt, call, fixed_opt, perl_opt, &reg, tables,
 2351|    100|			re, mdata, mcontext);
 2352|       |#else
 2353|       |    regex_cleanup_begin(&ci, &cntxt, call, fixed_opt, perl_opt, &reg, tables,
 2354|       |			re_pcre, re_pe, NULL);
 2355|       |#endif
 2356|       |
 2357|    100|    PROTECT(ans = allocVector(STRSXP, n));
  ------------------
  |  |  357|    100|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2358|    100|    vmax = vmaxget();
 2359|    210|    for (i = 0 ; i < n ; i++) {
  ------------------
  |  Branch (2359:18): [True: 110, False: 100]
  ------------------
 2360|       |//	if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
 2361|       |	/* NA pattern was handled above */
 2362|    110|	if (STRING_ELT(text, i) == NA_STRING) {
  ------------------
  |  |  433|    110|#define NA_STRING	R_NaString
  ------------------
  |  Branch (2362:6): [True: 0, False: 110]
  ------------------
 2363|      0|	    SET_STRING_ELT(ans, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
 2364|      0|	    continue;
 2365|      0|	}
 2366|       |
 2367|    110|	if (useBytes)
  ------------------
  |  Branch (2367:6): [True: 110, False: 0]
  ------------------
 2368|    110|	    s = CHAR(STRING_ELT(text, i));
  ------------------
  |  |  203|    110|#define CHAR(x) R_CHAR(x)
  ------------------
 2369|      0|	else if (use_WC) {
  ------------------
  |  Branch (2369:11): [True: 0, False: 0]
  ------------------
 2370|      0|	    ws = wtransChar2(STRING_ELT(text, i));
  ------------------
  |  | 2017|      0|# define wtransChar2		Rf_wtransChar2
  ------------------
 2371|      0|	    if (!ws)
  ------------------
  |  Branch (2371:10): [True: 0, False: 0]
  ------------------
 2372|      0|		error(_("input string %lld is invalid"), (long long)i+1);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("input string %lld is invalid"), (long long)i+1);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2373|      0|	} else if (use_UTF8) {
  ------------------
  |  Branch (2373:13): [True: 0, False: 0]
  ------------------
 2374|      0|	    s = trCharUTF82(STRING_ELT(text, i));
  ------------------
  |  | 2001|      0|# define trCharUTF82      	Rf_trCharUTF82
  ------------------
 2375|      0|	    if (!s || !utf8Valid(s))
  ------------------
  |  | 2011|      0|# define utf8Valid		Rf_utf8Valid
  ------------------
  |  Branch (2375:10): [True: 0, False: 0]
  |  Branch (2375:16): [True: 0, False: 0]
  ------------------
 2376|      0|		error(_("input string %lld is invalid UTF-8"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("input string %lld is invalid UTF-8"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2377|      0|		     (long long)i+1);
 2378|      0|	} else {
 2379|      0|	    s = translateCharFP2(STRING_ELT(text, i));
  ------------------
  |  | 1999|      0|# define translateCharFP2	Rf_translateCharFP2
  ------------------
 2380|      0|	    if (!s || (mbcslocale && !mbcsValid(s)))
  ------------------
  |  | 1952|      0|# define mbcsValid		Rf_mbcsValid
  ------------------
  |  Branch (2380:10): [True: 0, False: 0]
  |  Branch (2380:17): [True: 0, False: 0]
  |  Branch (2380:31): [True: 0, False: 0]
  ------------------
 2381|      0|		error(_("input string %lld is invalid in this locale"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("input string %lld is invalid in this locale"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2382|      0|		      (long long)i+1);
 2383|      0|	}
 2384|       |
 2385|    110|	if (fixed_opt) {
  ------------------
  |  Branch (2385:6): [True: 32, False: 78]
  ------------------
 2386|     32|	    int st, nr, slen = (int) strlen(s);
 2387|     32|	    ns = slen;
 2388|     32|	    st = fgrep_one_bytes(spat, patlen, s, ns, useBytes, use_UTF8);
 2389|     32|	    if (st < 0)
  ------------------
  |  Branch (2389:10): [True: 20, False: 12]
  ------------------
 2390|     20|		SET_STRING_ELT(ans, i, markBytesOld(STRING_ELT(text, i),
 2391|     20|		                                    useBytes, haveBytesInput));
 2392|     12|	    else if (STRING_ELT(rep, 0) == NA_STRING)
  ------------------
  |  |  433|     12|#define NA_STRING	R_NaString
  ------------------
  |  Branch (2392:15): [True: 0, False: 12]
  ------------------
 2393|      0|		SET_STRING_ELT(ans, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
 2394|     12|	    else {
 2395|     12|		if (global) { /* need to find max number of matches */
  ------------------
  |  Branch (2395:7): [True: 0, False: 12]
  ------------------
 2396|      0|		    const char *ss= s;
 2397|      0|		    int sst = st;
 2398|      0|		    nr = 0;
 2399|      0|		    do {
 2400|      0|			nr++;
 2401|      0|			ss += sst+patlen;
 2402|      0|			slen -= (int)(sst+patlen);
 2403|      0|		    } while((sst = fgrep_one_bytes(spat, patlen, ss, slen,
  ------------------
  |  Branch (2403:15): [True: 0, False: 0]
  ------------------
 2404|      0|		                                   useBytes, use_UTF8)) >= 0);
 2405|     12|		} else nr = 1;
 2406|     12|		cbuf = u = R_Calloc(ns + nr*(replen - patlen) + 1, char);
  ------------------
  |  |   55|     12|#define R_Calloc(n, t)   (t *) R_chk_calloc( (R_SIZE_T) (n), sizeof(t) )
  ------------------
 2407|     12|		*u = '\0';
 2408|     12|		slen = ns;
 2409|     12|		do {
 2410|     12|		    strncpy(u, s, st);
 2411|     12|		    u += st;
 2412|     12|		    s += st+patlen;
 2413|     12|		    slen -= (int)(st+patlen);
 2414|     12|		    strncpy(u, srep, replen);
 2415|     12|		    u += replen;
 2416|     12|		} while(global && (st = fgrep_one_bytes(spat, patlen, s, slen,
  ------------------
  |  Branch (2416:11): [True: 0, False: 12]
  |  Branch (2416:21): [True: 0, False: 0]
  ------------------
 2417|      0|		                                        useBytes, use_UTF8)) >= 0);
 2418|     12|		strcpy(u, s);
 2419|     12|		if (useBytes)
  ------------------
  |  Branch (2419:7): [True: 12, False: 0]
  ------------------
 2420|     12|		    SET_STRING_ELT(ans, i, mkBytesNew(cbuf, haveBytesInput));
 2421|      0|		else if (use_UTF8)
  ------------------
  |  Branch (2421:12): [True: 0, False: 0]
  ------------------
 2422|      0|		    SET_STRING_ELT(ans, i, mkCharCE(cbuf, CE_UTF8));
  ------------------
  |  |  999|      0|#define mkCharCE		Rf_mkCharCE
  ------------------
 2423|      0|		else
 2424|      0|		    SET_STRING_ELT(ans, i, markKnown(cbuf, STRING_ELT(text, i)));
  ------------------
  |  | 1942|      0|# define markKnown		Rf_markKnown
  ------------------
 2425|     12|		R_Free(cbuf);
  ------------------
  |  |   57|     12|#define R_Free(p)      (R_chk_free( (void *)(p) ), (p) = NULL)
  ------------------
 2426|     12|	    }
 2427|     78|	} else if (perl_opt) {
  ------------------
  |  Branch (2427:13): [True: 0, False: 78]
  ------------------
 2428|      0|	   int ncap, maxrep;
 2429|      0|#ifdef HAVE_PCRE2
 2430|      0|	   uint32_t eflag;
 2431|      0|	   PCRE2_SIZE *ovector = NULL;
 2432|       |#else
 2433|       |	   int eflag;
 2434|       |	   int ovector[ovecsize];
 2435|       |	   /* zero for unknown patterns; this is done to make sure that back
 2436|       |              references to unset groups return an empty string, but it is
 2437|       |	      not needed anymore as ncap is being checked due to PCRE2 */
 2438|       |	   memset(ovector, 0, ovecsize*sizeof(int));
 2439|       |#endif
 2440|      0|	   ns = (int) strlen(s);
 2441|      0|	   sub_buffer_size_init(replen, ns, count_subs(srep), global,
 2442|      0|	                        &nns, &maxrep);
 2443|      0|	   u = cbuf = R_Calloc(nns, char);
  ------------------
  |  |   55|      0|#define R_Calloc(n, t)   (t *) R_chk_calloc( (R_SIZE_T) (n), sizeof(t) )
  ------------------
 2444|      0|	   offset = 0; nmatch = 0; eflag = 0; last_end = -1;
 2445|       |	   /* ncap is one more than the number of capturing patterns */
 2446|      0|#ifdef HAVE_PCRE2
 2447|      0|	   if (use_UTF8) eflag |= PCRE2_NO_UTF_CHECK;
  ------------------
  |  Branch (2447:9): [True: 0, False: 0]
  ------------------
 2448|       |	   /* PCRE2 has also pcre2_substitute */
 2449|      0|	   while ((rc = pcre2_match(re, (PCRE2_SPTR) s, (PCRE2_SIZE) ns,
  ------------------
  |  Branch (2449:12): [True: 0, False: 0]
  ------------------
 2450|      0|				    (PCRE2_SIZE) offset, eflag, mdata,
 2451|      0|				    mcontext)) >= 0 ) {
 2452|       |
 2453|      0|	       ovector = pcre2_get_ovector_pointer(mdata);
 2454|       |#else
 2455|       |	   while ((rc = pcre_exec(re_pcre, re_pe, s, ns, offset, eflag,
 2456|       |				  ovector, 30)) >= 0) {
 2457|       |#endif
 2458|       |	       /* printf("%s, %d, %d %d\n", s, offset,
 2459|       |		  ovector[0], ovector[1]); */
 2460|      0|	       nmatch++;
 2461|      0|	       for (j = offset; j < ovector[0]; j++) *u++ = s[j];
  ------------------
  |  Branch (2461:26): [True: 0, False: 0]
  ------------------
 2462|      0|	       ncap = rc > 0 ? rc : 10;
  ------------------
  |  Branch (2462:16): [True: 0, False: 0]
  ------------------
 2463|      0|	       if (last_end == -1 /* for PCRE2 */ || ovector[1] > last_end) {
  ------------------
  |  Branch (2463:13): [True: 0, False: 0]
  |  Branch (2463:47): [True: 0, False: 0]
  ------------------
 2464|      0|		   u = R_pcre_string_adj(u, s, srep, ovector, use_UTF8, ncap);
 2465|      0|		   last_end = (int) ovector[1];
 2466|      0|	       }
 2467|      0|	       offset = (int) ovector[1];
 2468|      0|	       if (s[offset] == '\0' || !global) break;
  ------------------
  |  Branch (2468:13): [True: 0, False: 0]
  |  Branch (2468:34): [True: 0, False: 0]
  ------------------
 2469|      0|	       if (ovector[1] == ovector[0]) {
  ------------------
  |  Branch (2469:13): [True: 0, False: 0]
  ------------------
 2470|       |		   /* advance by a char */
 2471|      0|		   if (use_UTF8) {
  ------------------
  |  Branch (2471:10): [True: 0, False: 0]
  ------------------
 2472|      0|		       int used, pos = 0;
 2473|      0|		       while( (used = utf8clen(s[pos])) ) {
  ------------------
  |  | 2008|      0|# define utf8clen		Rf_utf8clen
  ------------------
  |  Branch (2473:17): [True: 0, False: 0]
  ------------------
 2474|      0|			   pos += used;
 2475|      0|			   if (pos > offset) {
  ------------------
  |  Branch (2475:11): [True: 0, False: 0]
  ------------------
 2476|      0|			       for (j = offset; j < pos; j++) *u++ = s[j];
  ------------------
  |  Branch (2476:28): [True: 0, False: 0]
  ------------------
 2477|      0|			       offset = pos;
 2478|      0|			       break;
 2479|      0|			   }
 2480|      0|		       }
 2481|      0|		   } else
 2482|      0|		       *u++ = s[offset++];
 2483|      0|	       }
 2484|      0|	       double needed = (double)(u-cbuf) + (double)(ns-offset)
 2485|      0|	                       + (double)maxrep + 100.;
 2486|      0|	       sub_buffer_expand(needed, &nns, &cbuf, &u);
 2487|      0|#ifdef HAVE_PCRE2
 2488|      0|	       eflag = PCRE2_NOTBOL;  /* probably not needed */
 2489|      0|	       if (use_UTF8) eflag |= PCRE2_NO_UTF_CHECK;
  ------------------
  |  Branch (2489:13): [True: 0, False: 0]
  ------------------
 2490|       |#else
 2491|       |	       eflag = PCRE_NOTBOL;  /* probably not needed */
 2492|       |#endif
 2493|      0|	   }
 2494|      0|	   R_pcre_exec_error(rc, i);
 2495|      0|	   if (nmatch == 0)
  ------------------
  |  Branch (2495:9): [True: 0, False: 0]
  ------------------
 2496|      0|	       SET_STRING_ELT(ans, i, markBytesOld(STRING_ELT(text, i),
 2497|      0|		                                   useBytes, haveBytesInput));
 2498|      0|	   else if (STRING_ELT(rep, 0) == NA_STRING)
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (2498:14): [True: 0, False: 0]
  ------------------
 2499|      0|	       SET_STRING_ELT(ans, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
 2500|      0|	   else {
 2501|       |	       /* copy the tail */
 2502|      0|	       double needed = (double)(u-cbuf) + (double)(ns-offset) + 1.0;
 2503|      0|	       sub_buffer_expand(needed, &nns, &cbuf, &u);
 2504|      0|	       for (j = offset ; s[j] ; j++) *u++ = s[j];
  ------------------
  |  Branch (2504:27): [True: 0, False: 0]
  ------------------
 2505|      0|	       *u = '\0';
 2506|      0|	       if (useBytes)
  ------------------
  |  Branch (2506:13): [True: 0, False: 0]
  ------------------
 2507|      0|		   SET_STRING_ELT(ans, i, mkBytesNew(cbuf, haveBytesInput));
 2508|      0|	       else if (use_UTF8)
  ------------------
  |  Branch (2508:18): [True: 0, False: 0]
  ------------------
 2509|      0|		   SET_STRING_ELT(ans, i, mkCharCE(cbuf, CE_UTF8));
  ------------------
  |  |  999|      0|#define mkCharCE		Rf_mkCharCE
  ------------------
 2510|      0|	       else
 2511|      0|		   SET_STRING_ELT(ans, i, markKnown(cbuf, STRING_ELT(text, i)));
  ------------------
  |  | 1942|      0|# define markKnown		Rf_markKnown
  ------------------
 2512|      0|	   }
 2513|      0|	   R_Free(cbuf);
  ------------------
  |  |   57|      0|#define R_Free(p)      (R_chk_free( (void *)(p) ), (p) = NULL)
  ------------------
 2514|     78|       } else if (!use_WC) {
  ------------------
  |  Branch (2514:19): [True: 78, False: 0]
  ------------------
 2515|     78|	    int maxrep;
 2516|       |	    /* extended regexp in bytes */
 2517|       |
 2518|     78|	    ns = (int) strlen(s);
 2519|     78|	    sub_buffer_size_init(replen, ns, count_subs(srep), global,
 2520|     78|	                         &nns, &maxrep);
 2521|     78|	    u = cbuf = R_Calloc(nns, char);
  ------------------
  |  |   55|     78|#define R_Calloc(n, t)   (t *) R_chk_calloc( (R_SIZE_T) (n), sizeof(t) )
  ------------------
 2522|     78|	    offset = 0; nmatch = 0; eflags = 0; last_end = -1;
 2523|     78|	    while ((rc = tre_regexecb(&reg, s+offset, 10, regmatch, eflags))
  ------------------
  |  Branch (2523:13): [True: 24, False: 54]
  ------------------
 2524|     78|		   == 0) {
 2525|       |		/* printf("%s, %d %d\n", &s[offset],
 2526|       |		   regmatch[0].rm_so, regmatch[0].rm_eo); */
 2527|     24|		nmatch++;
 2528|     46|		for (j = 0; j < regmatch[0].rm_so ; j++)
  ------------------
  |  Branch (2528:15): [True: 22, False: 24]
  ------------------
 2529|     22|		    *u++ = s[offset+j];
 2530|     24|		if (offset+regmatch[0].rm_eo > last_end) {
  ------------------
  |  Branch (2530:7): [True: 24, False: 0]
  ------------------
 2531|     24|		    u = string_adj(u, s+offset, srep, regmatch);
 2532|     24|		    last_end = offset+regmatch[0].rm_eo;
 2533|     24|		}
 2534|     24|		offset += regmatch[0].rm_eo;
 2535|     24|		if (s[offset] == '\0' || !global) break;
  ------------------
  |  Branch (2535:7): [True: 22, False: 2]
  |  Branch (2535:28): [True: 2, False: 0]
  ------------------
 2536|      0|		if (regmatch[0].rm_eo == regmatch[0].rm_so)
  ------------------
  |  Branch (2536:7): [True: 0, False: 0]
  ------------------
 2537|      0|		    *u++ = s[offset++];
 2538|      0|		double needed = (double)(u-cbuf) + (double)(ns-offset)
 2539|      0|		                + (double)maxrep + 100.;
 2540|      0|		sub_buffer_expand(needed, &nns, &cbuf, &u);
 2541|      0|		eflags = REG_NOTBOL;
  ------------------
  |  |  112|      0|#define REG_NOTBOL 1
  ------------------
 2542|      0|	    }
 2543|       |	    // AFAICS the only possible error report is REG_ESPACE
 2544|     78|	    if (rc == REG_ESPACE)
  ------------------
  |  Branch (2544:10): [True: 0, False: 78]
  ------------------
 2545|      0|		warning("Out-of-memory error in regexp matching for element %d",
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
 2546|      0|			(int) i + 1);
 2547|       |
 2548|     78|	    if (nmatch == 0)
  ------------------
  |  Branch (2548:10): [True: 54, False: 24]
  ------------------
 2549|     54|		SET_STRING_ELT(ans, i, markBytesOld(STRING_ELT(text, i),
 2550|     54|		                                    useBytes, haveBytesInput));
 2551|     24|	    else if (STRING_ELT(rep, 0) == NA_STRING)
  ------------------
  |  |  433|     24|#define NA_STRING	R_NaString
  ------------------
  |  Branch (2551:15): [True: 0, False: 24]
  ------------------
 2552|      0|		SET_STRING_ELT(ans, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
 2553|     24|	    else {
 2554|       |		/* copy the tail */
 2555|     24|		double needed = (double)(u-cbuf) + (double)(ns-offset) + 1.0;
 2556|     24|		sub_buffer_expand(needed, &nns, &cbuf, &u);
 2557|     64|		for (j = offset ; s[j] ; j++) *u++ = s[j];
  ------------------
  |  Branch (2557:21): [True: 40, False: 24]
  ------------------
 2558|     24|		*u = '\0';
 2559|     24|		if (useBytes)
  ------------------
  |  Branch (2559:7): [True: 24, False: 0]
  ------------------
 2560|     24|		    SET_STRING_ELT(ans, i, mkBytesNew(cbuf, haveBytesInput));
 2561|      0|		else
 2562|      0|		    SET_STRING_ELT(ans, i, markKnown(cbuf, STRING_ELT(text, i)));
  ------------------
  |  | 1942|      0|# define markKnown		Rf_markKnown
  ------------------
 2563|     24|	    }
 2564|     78|	    R_Free(cbuf);
  ------------------
  |  |   57|     78|#define R_Free(p)      (R_chk_free( (void *)(p) ), (p) = NULL)
  ------------------
 2565|     78|	} else  {
 2566|       |	    /* extended regexp in wchar_t */
 2567|      0|	    wchar_t *u, *cbuf;
 2568|      0|	    int maxrep;
 2569|      0|	    bool ascii_texti = IS_ASCII(STRING_ELT(text, i));
 2570|       |
 2571|      0|	    ns = (int) wcslen(ws);
 2572|      0|	    sub_buffer_size_init(replen, ns, wcount_subs(wrep), global,
 2573|      0|	                         &nns, &maxrep);
 2574|      0|	    u = cbuf = R_Calloc(nns, wchar_t);
  ------------------
  |  |   55|      0|#define R_Calloc(n, t)   (t *) R_chk_calloc( (R_SIZE_T) (n), sizeof(t) )
  ------------------
 2575|      0|	    offset = 0; nmatch = 0; eflags = 0; last_end = -1;
 2576|      0|	    while (tre_regwexec(&reg, ws+offset, 10, regmatch, eflags) == 0) {
  ------------------
  |  Branch (2576:13): [True: 0, False: 0]
  ------------------
 2577|      0|		nmatch++;
 2578|      0|		for (j = 0; j < regmatch[0].rm_so ; j++)
  ------------------
  |  Branch (2578:15): [True: 0, False: 0]
  ------------------
 2579|      0|		    *u++ = ws[offset+j];
 2580|      0|		if (offset+regmatch[0].rm_eo > last_end) {
  ------------------
  |  Branch (2580:7): [True: 0, False: 0]
  ------------------
 2581|      0|		    u = wstring_adj(u, ws+offset, wrep, regmatch);
 2582|      0|		    last_end = offset+regmatch[0].rm_eo;
 2583|      0|		}
 2584|      0|		offset += regmatch[0].rm_eo;
 2585|      0|		if (ws[offset] == L'\0' || !global) break;
  ------------------
  |  Branch (2585:7): [True: 0, False: 0]
  |  Branch (2585:30): [True: 0, False: 0]
  ------------------
 2586|      0|		if (regmatch[0].rm_eo == regmatch[0].rm_so)
  ------------------
  |  Branch (2586:7): [True: 0, False: 0]
  ------------------
 2587|      0|		    *u++ = ws[offset++];
 2588|      0|		double needed = (double)(u-cbuf) + (double)(ns-offset)
 2589|      0|		                + (double)maxrep + 100.;
 2590|      0|		wsub_buffer_expand(needed, &nns, &cbuf, &u);
 2591|      0|		eflags = REG_NOTBOL;
  ------------------
  |  |  112|      0|#define REG_NOTBOL 1
  ------------------
 2592|      0|	    }
 2593|      0|	    if (nmatch == 0)
  ------------------
  |  Branch (2593:10): [True: 0, False: 0]
  ------------------
 2594|      0|		SET_STRING_ELT(ans, i, markBytesOld(STRING_ELT(text, i),
 2595|      0|		                                    useBytes, haveBytesInput));
 2596|      0|	    else if (STRING_ELT(rep, 0) == NA_STRING)
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (2596:15): [True: 0, False: 0]
  ------------------
 2597|      0|		SET_STRING_ELT(ans, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
 2598|      0|	    else {
 2599|       |		/* copy the tail */
 2600|      0|		double needed = (double)(u-cbuf) + (double)(ns-offset) + 1.;
 2601|      0|		wsub_buffer_expand(needed, &nns, &cbuf, &u);
 2602|      0|		for (j = offset ; ws[j] ; j++) *u++ = ws[j];
  ------------------
  |  Branch (2602:21): [True: 0, False: 0]
  ------------------
 2603|      0|		*u = L'\0';
 2604|      0|		SET_STRING_ELT(ans, i,
 2605|      0|		               mkCharWLenASCII(cbuf, (int)(u-cbuf),
 2606|      0|		                               ascii_patrep && ascii_texti));
  ------------------
  |  Branch (2606:34): [True: 0, False: 0]
  |  Branch (2606:50): [True: 0, False: 0]
  ------------------
 2607|      0|	    }
 2608|      0|	    R_Free(cbuf);
  ------------------
  |  |   57|      0|#define R_Free(p)      (R_chk_free( (void *)(p) ), (p) = NULL)
  ------------------
 2609|      0|	}
 2610|    110|	vmaxset(vmax);
 2611|    110|    }
 2612|       |
 2613|    100|    regex_cleanup_end(&ci, &cntxt);
 2614|       |
 2615|    100|  exit_gsub: 
 2616|    100|    SHALLOW_DUPLICATE_ATTRIB(ans, text);
 2617|       |    /* This also copied the class, if any */
 2618|    100|    UNPROTECT(1);
  ------------------
  |  |  358|    100|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2619|    100|    return ans;
 2620|    100|}
grep.c:have_bytes:
  316|  4.14k|{
  317|  4.14k|    R_xlen_t i;
  318|       |
  319|  8.29k|    for(i = 0; i < len; i++) 
  ------------------
  |  Branch (319:16): [True: 4.15k, False: 4.14k]
  ------------------
  320|  4.15k|	if (IS_BYTES(STRING_ELT(x, i))) return true;
  ------------------
  |  Branch (320:6): [True: 0, False: 4.15k]
  ------------------
  321|  4.14k|    return false;
  322|  4.14k|}
grep.c:only_ascii:
  306|  4.28k|{
  307|  4.28k|    R_xlen_t i;
  308|       |
  309|  12.8k|    for(i = 0; i < len; i++) 
  ------------------
  |  Branch (309:16): [True: 8.81k, False: 4.00k]
  ------------------
  310|  8.81k|	if (!IS_ASCII(STRING_ELT(x, i)) && STRING_ELT(x, i) != NA_STRING)  
  ------------------
  |  |  433|    287|#define NA_STRING	R_NaString
  ------------------
  |  Branch (310:6): [True: 287, False: 8.52k]
  |  Branch (310:37): [True: 287, False: 0]
  ------------------
  311|    287|	    return false;
  312|  4.00k|    return true;
  313|  4.28k|}
grep.c:have_utf8:
  325|    574|{
  326|    574|    R_xlen_t i;
  327|       |
  328|  1.14k|    for(i = 0; i < len; i++) 
  ------------------
  |  Branch (328:16): [True: 574, False: 574]
  ------------------
  329|    574|	if (IS_UTF8(STRING_ELT(x, i))) return true;
  ------------------
  |  Branch (329:6): [True: 0, False: 574]
  ------------------
  330|    574|    return false;
  331|    574|}
grep.c:have_latin1:
  334|    574|{
  335|    574|    R_xlen_t i;
  336|       |
  337|  1.14k|    for(i = 0; i < len; i++) 
  ------------------
  |  Branch (337:16): [True: 574, False: 574]
  ------------------
  338|    574|	if (IS_LATIN1(STRING_ELT(x, i))) return true;
  ------------------
  |  Branch (338:6): [True: 0, False: 574]
  ------------------
  339|    574|    return false;
  340|    574|}
grep.c:markBytesOld:
  202|     74|{
  203|       |    /* If 1, mark results of gsub, sub, strsplit as "bytes" when using bytes
  204|       |       and replacement, split did not happen. If 0, keep their original
  205|       |       encoding flag (pre-82589 behavior, see markBytesResultIfNew).
  206|       |
  207|       |       The intention of the marking (82589) was to avoid encoding flag
  208|       |       instability caused by 82587, e.g.
  209|       |       in gsub(weird_thing, "", useBytes=TRUE). The option is experimental
  210|       |       and intended to be removed.
  211|       |
  212|       |       Currently the default is the old behavior.
  213|       |    */
  214|     74|    static int markBytesResultIfOld = -1; /* -1 to allow setting */
  215|       |
  216|     74|    if (markBytesResultIfOld == -1) {
  ------------------
  |  Branch (216:9): [True: 2, False: 72]
  ------------------
  217|      2|	char *p = getenv("_R_REGEX_MARK_OLD_RESULT_AS_BYTES_");
  218|      2|	markBytesResultIfOld = (p && StringTrue(p)) ? 1 : 0;
  ------------------
  |  |   52|      0|#define StringTrue    Rf_StringTrue
  ------------------
  |  Branch (218:26): [True: 0, False: 2]
  |  Branch (218:31): [True: 0, False: 0]
  ------------------
  219|      2|    }
  220|     74|    if (!markBytesResultIfOld || !haveBytesInput ||
  ------------------
  |  Branch (220:9): [True: 74, False: 0]
  |  Branch (220:34): [True: 0, False: 0]
  ------------------
  221|      0|        !useBytes || IS_ASCII(x) || IS_BYTES(x) || x == NA_STRING)
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (221:9): [True: 0, False: 0]
  |  Branch (221:22): [True: 0, False: 0]
  |  Branch (221:37): [True: 0, False: 0]
  |  Branch (221:52): [True: 0, False: 0]
  ------------------
  222|       |
  223|     74|	return x;
  224|      0|    else
  225|      0|	return mkCharLenCE(CHAR(x), LENGTH(x), CE_BYTES);
  ------------------
  |  | 1001|      0|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
              	return mkCharLenCE(CHAR(x), LENGTH(x), CE_BYTES);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  226|     74|}
grep.c:mkBytesNew:
  229|   310k|{
  230|       |    /* If 1, mark results of gsub, sub, strsplit as "bytes" when using bytes
  231|       |       and replacement or split happened. If 0 and no input was marked as
  232|       |       "bytes", mark results as native/unknown, possibly creating an invalid
  233|       |       string (pre-82587 behavior). This option is experimental and intended
  234|       |       to be removed.
  235|       |
  236|       |       Currently the default is the old behavior when no input is marked as
  237|       |       "bytes". However, the new behavior applies when the input includes
  238|       |       a string marked as "bytes".
  239|       |    */
  240|   310k|    static int markBytesResultIfNew = -1; 
  241|       |
  242|   310k|    if (markBytesResultIfNew == -1) {
  ------------------
  |  Branch (242:9): [True: 2, False: 310k]
  ------------------
  243|      2|	char *p = getenv("_R_REGEX_MARK_NEW_RESULT_AS_BYTES_");
  244|      2|	markBytesResultIfNew = (p && StringTrue(p)) ? 1 : 0;
  ------------------
  |  |   52|      0|#define StringTrue    Rf_StringTrue
  ------------------
  |  Branch (244:26): [True: 0, False: 2]
  |  Branch (244:31): [True: 0, False: 0]
  ------------------
  245|      2|    }
  246|   310k|    if (haveBytesInput || markBytesResultIfNew)
  ------------------
  |  Branch (246:9): [True: 0, False: 310k]
  |  Branch (246:27): [True: 0, False: 310k]
  ------------------
  247|      0|	return mkCharCE(name, CE_BYTES);
  ------------------
  |  |  999|      0|#define mkCharCE		Rf_mkCharCE
  ------------------
  248|   310k|    else
  249|   310k|	return mkCharCE(name, CE_NATIVE);
  ------------------
  |  |  999|   310k|#define mkCharCE		Rf_mkCharCE
  ------------------
  250|   310k|}
grep.c:regex_cleanup_begin:
  606|    220|{
  607|    220|    ci->fixed_opt = fixed_opt;
  608|    220|    ci->perl_opt = perl_opt;
  609|    220|    ci->reg = reg;
  610|    220|    ci->tables = tables;
  611|    220|#ifdef HAVE_PCRE2
  612|    220|    ci->re = re;
  613|    220|    ci->mdata = mdata;
  614|    220|    ci->mcontext = mcontext;
  615|       |#else
  616|       |    ci->re_pcre = re_pcre;
  617|       |    ci->re_pe = re_pe;
  618|       |    ci->ovector = ovector;
  619|       |#endif
  620|    220|    begincontext(cntxt, CTXT_CCODE, call, R_BaseEnv, R_BaseEnv,
  ------------------
  |  | 1864|    220|# define begincontext		Rf_begincontext
  ------------------
  621|    220|		 R_NilValue, R_NilValue);
  622|    220|    cntxt->cend = &regex_cleanup;
  623|    220|    cntxt->cenddata = ci;
  624|    220|}
grep.c:regex_cleanup:
  569|    220|{
  570|    220|    regex_cleanup_info *ci = (regex_cleanup_info *) data;
  571|       |
  572|    220|    if (ci->fixed_opt)
  ------------------
  |  Branch (572:9): [True: 14, False: 206]
  ------------------
  573|     14|	return;
  574|    206|    if (ci->perl_opt) {
  ------------------
  |  Branch (574:9): [True: 0, False: 206]
  ------------------
  575|      0|#ifdef HAVE_PCRE2
  576|      0|	pcre2_match_data_free(ci->mdata);
  577|      0|	pcre2_code_free(ci->re);
  578|      0|	pcre2_match_context_free(ci->mcontext);
  579|      0|	if (ci->tables)
  ------------------
  |  Branch (579:6): [True: 0, False: 0]
  ------------------
  580|       |	    /* new PCRE2 will have pcre2_maketables_free() */
  581|      0|	    free((void *) ci->tables);
  582|       |#else
  583|       |	if (ci->re_pe)
  584|       |	    pcre_free_study(ci->re_pe);
  585|       |	pcre_free(ci->re_pcre);
  586|       |	pcre_free((void *) ci->tables);
  587|       |	free(ci->ovector);
  588|       |#endif
  589|    206|    } else {
  590|    206|	tre_regfree(ci->reg);
  591|    206|    }
  592|    206|}
grep.c:regex_cleanup_end:
  628|    220|{
  629|    220|    endcontext(cntxt);
  ------------------
  |  | 1895|    220|# define endcontext		Rf_endcontext
  ------------------
  630|    220|    regex_cleanup(ci);
  631|    220|}
grep.c:fgrep_one:
 1272|      6|{
 1273|      6|    int plen = (int) strlen(pat), len = (int) strlen(target);
 1274|      6|    int i = -1;
 1275|      6|    const char *p;
 1276|       |
 1277|      6|    if (plen == 0) {
  ------------------
  |  Branch (1277:9): [True: 0, False: 6]
  ------------------
 1278|      0|	if (next != NULL) *next = 1;
  ------------------
  |  Branch (1278:6): [True: 0, False: 0]
  ------------------
 1279|      0|	return 0;
 1280|      0|    }
 1281|      6|    if (plen == 1 && (useBytes || !(mbcslocale || use_UTF8))) {
  ------------------
  |  Branch (1281:9): [True: 6, False: 0]
  |  Branch (1281:23): [True: 6, False: 0]
  |  Branch (1281:37): [True: 0, False: 0]
  |  Branch (1281:51): [True: 0, False: 0]
  ------------------
 1282|       |	/* a single byte is a common case */
 1283|     54|	for (i = 0, p = target; *p; p++, i++)
  ------------------
  |  Branch (1283:26): [True: 48, False: 6]
  ------------------
 1284|     48|	    if (*p == pat[0]) {
  ------------------
  |  Branch (1284:10): [True: 0, False: 48]
  ------------------
 1285|      0|		if (next != NULL) *next = i + 1;
  ------------------
  |  Branch (1285:7): [True: 0, False: 0]
  ------------------
 1286|      0|		return i;
 1287|      0|	    }
 1288|      6|	return -1;
 1289|      6|    }
 1290|      0|    if (!useBytes && use_UTF8) {
  ------------------
  |  Branch (1290:9): [True: 0, False: 0]
  |  Branch (1290:22): [True: 0, False: 0]
  ------------------
 1291|       |	// target is const char*, so C23 says so is the value
 1292|      0|	const char *pos = strstr(target, pat);
 1293|      0|	if (pos) {
  ------------------
  |  Branch (1293:6): [True: 0, False: 0]
  ------------------
 1294|      0|	    int ib = (int) (pos-target);
 1295|      0|	    int jb;
 1296|       |
 1297|      0|	    if (next != NULL) *next = ib + plen;
  ------------------
  |  Branch (1297:10): [True: 0, False: 0]
  ------------------
 1298|      0|	    for (jb = 0, i = 0; jb < ib; jb++)
  ------------------
  |  Branch (1298:26): [True: 0, False: 0]
  ------------------
 1299|       |		/* count leading UTF-8 bytes */
 1300|      0|		if ((target[jb] & 0xc0) != 0x80) i++;
  ------------------
  |  Branch (1300:7): [True: 0, False: 0]
  ------------------
 1301|      0|	    return i;
 1302|      0|	}
 1303|      0|    } else if (!useBytes && mbcslocale) { /* skip along by chars */
  ------------------
  |  Branch (1303:16): [True: 0, False: 0]
  |  Branch (1303:29): [True: 0, False: 0]
  ------------------
 1304|      0|	mbstate_t mb_st;
 1305|      0|	int ib, used;
 1306|      0|	mbs_init(&mb_st);
  ------------------
  |  | 2454|      0|#define mbs_init(x) memset(x, 0, sizeof(mbstate_t))
  ------------------
 1307|      0|	for (ib = 0, i = 0; ib <= len-plen; i++) {
  ------------------
  |  Branch (1307:22): [True: 0, False: 0]
  ------------------
 1308|      0|	    if (strncmp(pat, target+ib, plen) == 0) {
  ------------------
  |  Branch (1308:10): [True: 0, False: 0]
  ------------------
 1309|      0|		if (next != NULL) *next = ib + plen;
  ------------------
  |  Branch (1309:7): [True: 0, False: 0]
  ------------------
 1310|      0|		return i;
 1311|      0|	    }
 1312|      0|	    used = (int) Mbrtowc(NULL,  target+ib, R_MB_CUR_MAX, &mb_st);
  ------------------
  |  | 1949|      0|# define Mbrtowc		Rf_mbrtowc
  ------------------
 1313|      0|	    if (used <= 0) break;
  ------------------
  |  Branch (1313:10): [True: 0, False: 0]
  ------------------
 1314|      0|	    ib += used;
 1315|      0|	}
 1316|      0|    } else {
 1317|       |	// target is const char*, so C23 says so is the value
 1318|      0|	const char *pos = strstr(target, pat);
 1319|      0|	if (pos) {
  ------------------
  |  Branch (1319:6): [True: 0, False: 0]
  ------------------
 1320|      0|	    i = (int) (pos-target);
 1321|      0|	    if (next != NULL) *next = i + plen;
  ------------------
  |  Branch (1321:10): [True: 0, False: 0]
  ------------------
 1322|      0|	    return i;
 1323|      0|	}
 1324|      0|    }
 1325|      0|    return -1;
 1326|      0|}
grep.c:fgrep_one_bytes:
 1335|     32|{
 1336|     32|    int i = -1;
 1337|     32|    const char *p;
 1338|       |
 1339|     32|    if (patlen == 0) return 0;
  ------------------
  |  Branch (1339:9): [True: 0, False: 32]
  ------------------
 1340|       |
 1341|       |    /* UTF-8 allows for byte-based search of valid pattern string inside
 1342|       |       valid target string, because lead and continuation bytes are taken
 1343|       |       from distinct ranges. */
 1344|     32|    if (patlen == 1 && (useBytes || use_UTF8 || !mbcslocale)) {
  ------------------
  |  Branch (1344:9): [True: 0, False: 32]
  |  Branch (1344:25): [True: 0, False: 0]
  |  Branch (1344:37): [True: 0, False: 0]
  |  Branch (1344:49): [True: 0, False: 0]
  ------------------
 1345|       |	/* a single byte is a common case */
 1346|      0|	for (i = 0, p = target; *p; p++, i++)
  ------------------
  |  Branch (1346:26): [True: 0, False: 0]
  ------------------
 1347|      0|	    if (*p == pat[0]) return i;
  ------------------
  |  Branch (1347:10): [True: 0, False: 0]
  ------------------
 1348|      0|	return -1;
 1349|      0|    }
 1350|     32|    if (!use_UTF8 && !useBytes && mbcslocale) { /* skip along by chars */
  ------------------
  |  Branch (1350:9): [True: 32, False: 0]
  |  Branch (1350:22): [True: 0, False: 32]
  |  Branch (1350:35): [True: 0, False: 0]
  ------------------
 1351|      0|	mbstate_t mb_st;
 1352|      0|	int ib, used;
 1353|      0|	mbs_init(&mb_st);
  ------------------
  |  | 2454|      0|#define mbs_init(x) memset(x, 0, sizeof(mbstate_t))
  ------------------
 1354|      0|	for (ib = 0, i = 0; ib <= len-patlen; i++) {
  ------------------
  |  Branch (1354:22): [True: 0, False: 0]
  ------------------
 1355|      0|	    if (strncmp(pat, target+ib, patlen) == 0) return ib;
  ------------------
  |  Branch (1355:10): [True: 0, False: 0]
  ------------------
 1356|      0|	    used = (int) Mbrtowc(NULL, target+ib, R_MB_CUR_MAX, &mb_st);
  ------------------
  |  | 1949|      0|# define Mbrtowc		Rf_mbrtowc
  ------------------
 1357|      0|	    if (used <= 0) break;
  ------------------
  |  Branch (1357:10): [True: 0, False: 0]
  ------------------
 1358|      0|	    ib += used;
 1359|      0|	}
 1360|     32|    } else {
 1361|       |	// target is const char*, so C23 says so is the value
 1362|     32|	const char *pos = strstr(target, pat);
 1363|     32|	if (pos) return (int) (pos-target);
  ------------------
  |  Branch (1363:6): [True: 12, False: 20]
  ------------------
 1364|     32|    }
 1365|     20|    return -1;
 1366|     32|}
grep.c:sub_buffer_size_init:
 2147|     78|{
 2148|       |   /* worst possible scenario is to put a copy of the
 2149|       |      replacement after every character, unless there are
 2150|       |      backrefs */
 2151|     78|    *maxrep = sub_buffer_check_overflow((double)replen + (ns-2.) * nsubs);
 2152|     78|    if (global) {
  ------------------
  |  Branch (2152:9): [True: 56, False: 22]
  ------------------
 2153|     56|	double dnns = (double)ns * (*maxrep + 1.) + 1000.;
 2154|     56|	if (dnns > 10000) dnns = 2.*ns + (double)replen + 1000.;
  ------------------
  |  Branch (2154:6): [True: 7, False: 49]
  ------------------
 2155|     56|	if (dnns < (double)ns + *maxrep + 1000.)
  ------------------
  |  Branch (2155:6): [True: 7, False: 49]
  ------------------
 2156|      7|	    dnns = (double)ns + *maxrep + 1000.;
 2157|     56|	*nns = sub_buffer_check_overflow(dnns);
 2158|     56|    } else
 2159|     22|	*nns = sub_buffer_check_overflow((double)ns +
 2160|     22|	                                 (double)*maxrep + 1000.);
 2161|     78|}
grep.c:sub_buffer_check_overflow:
 2136|    180|{
 2137|       |    /* 2147483647 is a length limit for R strings and 32-bit ints can be
 2138|       |       precisely represented in IEEE double (but not 64-bit ints) */
 2139|    180|    if (!(d < INT_MAX) || !(d < 2147483647))
  ------------------
  |  Branch (2139:9): [True: 0, False: 180]
  |  Branch (2139:27): [True: 0, False: 180]
  ------------------
 2140|      0|	error(_("result string is too long"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("result string is too long"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2141|    180|    return (int)d;
 2142|    180|}
grep.c:count_subs:
 2003|     78|{
 2004|     78|    int i = 0;
 2005|     78|    const char *p = repl;
 2006|    804|    while (*p) {
  ------------------
  |  Branch (2006:12): [True: 726, False: 78]
  ------------------
 2007|    726|	if (*p == '\\') {
  ------------------
  |  Branch (2007:6): [True: 126, False: 600]
  ------------------
 2008|    126|	    if ('1' <= p[1] && p[1] <= '9') {i++; p += 2;}
  ------------------
  |  Branch (2008:10): [True: 126, False: 0]
  |  Branch (2008:25): [True: 98, False: 28]
  ------------------
 2009|     28|	    else if (p[1] == 0) p++; else p += 2;
  ------------------
  |  Branch (2009:15): [True: 0, False: 28]
  ------------------
 2010|    126|	}
 2011|    600|	else p++;
 2012|    726|    }
 2013|     78|    return i;
 2014|     78|}
grep.c:sub_buffer_expand:
 2181|     24|{
 2182|     24|    if (sub_buffer_size_expand(needed, nns)) {
  ------------------
  |  Branch (2182:9): [True: 0, False: 24]
  ------------------
 2183|      0|       char *tmp;
 2184|      0|       tmp = R_Realloc(*cbuf, *nns, char);
  ------------------
  |  |   56|      0|#define R_Realloc(p,n,t) (t *) R_chk_realloc( (void *)(p), (R_SIZE_T)((n) * sizeof(t)) )
  ------------------
 2185|      0|       *u = tmp + (*u - *cbuf);
 2186|      0|       *cbuf = tmp;
 2187|      0|   }
 2188|     24|}
grep.c:sub_buffer_size_expand:
 2165|     24|{
 2166|     24|    int ineeded = sub_buffer_check_overflow(needed);
 2167|     24|    if (*nns < ineeded) {
  ------------------
  |  Branch (2167:9): [True: 0, False: 24]
  ------------------
 2168|       |	/* This could fail at smaller value on a 32-bit platform:
 2169|       |	   it is merely an integer overflow check */
 2170|      0|	if (*nns < INT_MAX/2)
  ------------------
  |  Branch (2170:6): [True: 0, False: 0]
  ------------------
 2171|      0|	    (*nns) *= 2;
 2172|      0|	if (*nns < ineeded)
  ------------------
  |  Branch (2172:6): [True: 0, False: 0]
  ------------------
 2173|      0|	    (*nns) = ineeded;
 2174|      0|	return 1; 
 2175|      0|    } else
 2176|     24|	return 0;
 2177|     24|}
grep.c:string_adj:
 1982|     24|{
 1983|     24|    int i, k;
 1984|     24|    const char *p = repl; char *t = target;
 1985|       |
 1986|    150|    while (*p) {
  ------------------
  |  Branch (1986:12): [True: 126, False: 24]
  ------------------
 1987|    126|	if (*p == '\\') {
  ------------------
  |  Branch (1987:6): [True: 18, False: 108]
  ------------------
 1988|     18|	    if ('1' <= p[1] && p[1] <= '9') {
  ------------------
  |  Branch (1988:10): [True: 18, False: 0]
  |  Branch (1988:25): [True: 18, False: 0]
  ------------------
 1989|     18|		k = p[1] - '0';
 1990|    138|		for (i = regmatch[k].rm_so ; i < regmatch[k].rm_eo ; i++)
  ------------------
  |  Branch (1990:32): [True: 120, False: 18]
  ------------------
 1991|    120|		    *t++ = orig[i];
 1992|     18|		p += 2;
 1993|     18|	    }
 1994|      0|	    else if (p[1] == 0) p++; else {p++; *t++ = *p++;}
  ------------------
  |  Branch (1994:15): [True: 0, False: 0]
  ------------------
 1995|     18|	}
 1996|    108|	else *t++ = *p++;
 1997|    126|    }
 1998|     24|    return t;
 1999|     24|}

R_gzopen:
  185|     72|{
  186|     72|    int err;
  187|     72|    int level = Z_DEFAULT_COMPRESSION; /* compression level */
  188|     72|    int strategy = Z_DEFAULT_STRATEGY; /* compression strategy */
  189|     72|    char *p = (char *) mode;
  190|     72|    gz_stream *s;
  191|     72|    char fmode[80]; /* copy of mode, without the compression level */
  192|     72|    char *m = fmode;
  193|       |
  194|     72|    if (!path || !mode) return Z_NULL;
  ------------------
  |  Branch (194:9): [True: 0, False: 72]
  |  Branch (194:18): [True: 0, False: 72]
  ------------------
  195|       |
  196|     72|    s = (gz_stream *) malloc(sizeof(gz_stream));
  197|     72|    if (!s) return Z_NULL;
  ------------------
  |  Branch (197:9): [True: 0, False: 72]
  ------------------
  198|       |
  199|     72|    s->stream.zalloc = (alloc_func) 0;
  200|     72|    s->stream.zfree = (free_func) 0;
  201|     72|    s->stream.opaque = (voidpf) 0;
  202|     72|    s->stream.next_in = s->buffer;
  203|     72|    s->stream.next_out = s->buffer;
  204|     72|    s->stream.avail_in = s->stream.avail_out = 0;
  205|     72|    s->file = NULL;
  206|     72|    s->z_err = Z_OK;
  207|     72|    s->z_eof = 0;
  208|     72|    s->in = 0;
  209|     72|    s->out = 0;
  210|     72|    s->crc = crc32(0L, Z_NULL, 0);
  211|     72|    s->transparent = 0;
  212|     72|    s->mode = '\0';
  213|    216|    do {
  214|    216|        if (*p == 'r') s->mode = 'r';
  ------------------
  |  Branch (214:13): [True: 72, False: 144]
  ------------------
  215|    216|        if (*p == 'w' || *p == 'a') s->mode = 'w';
  ------------------
  |  Branch (215:13): [True: 0, False: 216]
  |  Branch (215:26): [True: 0, False: 216]
  ------------------
  216|    216|        if (*p >= '0' && *p <= '9') level = *p - '0';
  ------------------
  |  Branch (216:13): [True: 144, False: 72]
  |  Branch (216:26): [True: 0, False: 144]
  ------------------
  217|    216|        else if (*p == 'f') strategy = Z_FILTERED;
  ------------------
  |  Branch (217:18): [True: 0, False: 216]
  ------------------
  218|    216|        else if (*p == 'h') strategy = Z_HUFFMAN_ONLY;
  ------------------
  |  Branch (218:18): [True: 0, False: 216]
  ------------------
  219|    216|        else if (*p == 'R') strategy = Z_RLE;
  ------------------
  |  Branch (219:18): [True: 0, False: 216]
  ------------------
  220|    216|        else *m++ = *p; /* copy the mode */
  221|    216|    } while (*p++ && m != fmode + sizeof(fmode));
  ------------------
  |  Branch (221:14): [True: 144, False: 72]
  |  Branch (221:22): [True: 144, False: 0]
  ------------------
  222|     72|    if (s->mode == '\0') return destroy(s), (gzFile) Z_NULL;
  ------------------
  |  Branch (222:9): [True: 0, False: 72]
  ------------------
  223|       |
  224|     72|    if (s->mode == 'w') {
  ------------------
  |  Branch (224:9): [True: 0, False: 72]
  ------------------
  225|      0|        err = deflateInit2(&(s->stream), level,
  226|      0|                           Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, strategy);
  227|       |        /* windowBits is passed < 0 to suppress zlib header */
  228|      0|        if (err != Z_OK) return destroy(s), (gzFile) Z_NULL;
  ------------------
  |  Branch (228:13): [True: 0, False: 0]
  ------------------
  229|     72|    } else {
  230|     72|        err = inflateInit2(&(s->stream), -MAX_WBITS);
  231|       |        /* windowBits is passed < 0 to tell that there is no zlib header.
  232|       |         * Note that in this case inflate *requires* an extra "dummy" byte
  233|       |         * after the compressed stream in order to complete decompression and
  234|       |         * return Z_STREAM_END. Here the gzip CRC32 ensures that 4 bytes are
  235|       |         * present after the compressed stream.
  236|       |         */
  237|     72|        if (err != Z_OK) return destroy(s), (gzFile) Z_NULL;
  ------------------
  |  Branch (237:13): [True: 0, False: 72]
  ------------------
  238|     72|    }
  239|     72|    s->stream.avail_out = Z_BUFSIZE;
  ------------------
  |  |   56|     72|#define Z_BUFSIZE 16384
  ------------------
  240|       |
  241|     72|    errno = 0;
  242|     72|    s->file = fopen(path, fmode);
  243|     72|    if (s->file == NULL) return destroy(s), (gzFile) Z_NULL;
  ------------------
  |  Branch (243:9): [True: 0, False: 72]
  ------------------
  244|       |
  245|     72|    if (s->mode == 'w') {
  ------------------
  |  Branch (245:9): [True: 0, False: 72]
  ------------------
  246|       |        /* Write a very simple .gz header */
  247|      0|        fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1],
  248|      0|		Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, 
  249|      0|		OS_CODE);
  ------------------
  |  |   43|      0|# define OS_CODE  0x03 
  ------------------
  250|      0|        s->start = 10L;
  251|     72|    } else {
  252|     72|        check_header(s); /* skip the .gz header */
  253|     72|        s->start = f_tell(s->file) - s->stream.avail_in;
  ------------------
  |  |  750|     72|# define f_tell ftello
  ------------------
  254|     72|    }
  255|     72|    return (gzFile) s;
  256|     72|}
R_gzclose:
  538|     72|{
  539|     72|    gz_stream *s = (gz_stream*) file;
  540|     72|    if (s == NULL) return Z_STREAM_ERROR;
  ------------------
  |  Branch (540:9): [True: 0, False: 72]
  ------------------
  541|     72|    if (s->mode == 'w') {
  ------------------
  |  Branch (541:9): [True: 0, False: 72]
  ------------------
  542|      0|        if (gz_flush (file, Z_FINISH) != Z_OK) 
  ------------------
  |  Branch (542:13): [True: 0, False: 0]
  ------------------
  543|      0|	    return destroy((gz_stream*) file);
  544|      0|        z_putLong (s->file, s->crc);
  545|      0|        z_putLong (s->file, (uLong) (s->in & 0xffffffff));
  546|      0|    }
  547|     72|    return destroy((gz_stream*) file);
  548|     72|}
connections.c:destroy:
   91|     72|{
   92|     72|    int err = Z_OK;
   93|       |
   94|     72|    if (!s) return Z_STREAM_ERROR;
  ------------------
  |  Branch (94:9): [True: 0, False: 72]
  ------------------
   95|       |
   96|     72|    if (s->stream.state != NULL) {
  ------------------
  |  Branch (96:9): [True: 72, False: 0]
  ------------------
   97|     72|        if (s->mode == 'w') err = deflateEnd(&(s->stream));
  ------------------
  |  Branch (97:13): [True: 0, False: 72]
  ------------------
   98|     72|        else if (s->mode == 'r') err = inflateEnd(&(s->stream));
  ------------------
  |  Branch (98:18): [True: 72, False: 0]
  ------------------
   99|     72|    }
  100|     72|    if (s->file != NULL && fclose(s->file)) {
  ------------------
  |  Branch (100:9): [True: 72, False: 0]
  |  Branch (100:28): [True: 0, False: 72]
  ------------------
  101|      0|#ifdef ESPIPE
  102|      0|        if (errno != ESPIPE) /* fclose is broken for pipes in HP/UX */
  ------------------
  |  Branch (102:13): [True: 0, False: 0]
  ------------------
  103|      0|#endif
  104|      0|            err = Z_ERRNO;
  105|      0|    }
  106|     72|    if (s->z_err < 0) err = s->z_err;
  ------------------
  |  Branch (106:9): [True: 0, False: 72]
  ------------------
  107|       |
  108|     72|    if(s) free(s);
  ------------------
  |  Branch (108:8): [True: 72, False: 0]
  ------------------
  109|     72|    return err;
  110|     72|}
connections.c:check_header:
  123|    144|{
  124|    144|    int method; /* method byte */
  125|    144|    int flags;  /* flags byte */
  126|    144|    uInt len;
  127|    144|    int c;
  128|       |
  129|       |    /* Assure two bytes in the buffer so we can peek ahead -- handle case
  130|       |       where first byte of header is at the end of the buffer after the last
  131|       |       gzip segment */
  132|    144|    len = s->stream.avail_in;
  133|    144|    if (len < 2) {
  ------------------
  |  Branch (133:9): [True: 144, False: 0]
  ------------------
  134|    144|        if (len) s->buffer[0] = s->stream.next_in[0];
  ------------------
  |  Branch (134:13): [True: 0, False: 144]
  ------------------
  135|    144|        errno = 0;
  136|    144|        len = (uInt) fread(s->buffer + len, 1, Z_BUFSIZE >> len, s->file);
  ------------------
  |  |   56|    144|#define Z_BUFSIZE 16384
  ------------------
  137|    144|        if (len == 0 && ferror(s->file)) s->z_err = Z_ERRNO;
  ------------------
  |  Branch (137:13): [True: 72, False: 72]
  |  Branch (137:25): [True: 0, False: 72]
  ------------------
  138|    144|        s->stream.avail_in += len;
  139|    144|        s->stream.next_in = s->buffer;
  140|    144|        if (s->stream.avail_in < 2) {
  ------------------
  |  Branch (140:13): [True: 72, False: 72]
  ------------------
  141|     72|            s->transparent = s->stream.avail_in;
  142|     72|            return;
  143|     72|        }
  144|    144|    }
  145|       |
  146|       |    /* Peek ahead to check the gzip magic header */
  147|     72|    if (s->stream.next_in[0] != gz_magic[0] ||
  ------------------
  |  Branch (147:9): [True: 0, False: 72]
  ------------------
  148|     72|        s->stream.next_in[1] != gz_magic[1]) {
  ------------------
  |  Branch (148:9): [True: 0, False: 72]
  ------------------
  149|      0|        s->transparent = 1;
  150|      0|        return;
  151|      0|    }
  152|     72|    s->stream.avail_in -= 2;
  153|     72|    s->stream.next_in += 2;
  154|       |
  155|       |    /* Check the rest of the gzip header */
  156|     72|    method = get_byte(s);
  157|     72|    flags = get_byte(s);
  158|     72|    if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
  ------------------
  |  |  120|     72|#define RESERVED     0xE0 /* bits 5..7: reserved */
  ------------------
  |  Branch (158:9): [True: 0, False: 72]
  |  Branch (158:33): [True: 0, False: 72]
  ------------------
  159|      0|        s->z_err = Z_DATA_ERROR;
  160|      0|        return;
  161|      0|    }
  162|       |
  163|       |    /* Discard time, xflags and OS code: */
  164|    504|    for (len = 0; len < 6; len++) (void)get_byte(s);
  ------------------
  |  Branch (164:19): [True: 432, False: 72]
  ------------------
  165|       |
  166|     72|    if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */
  ------------------
  |  |  117|     72|#define EXTRA_FIELD  0x04 /* bit 2 set: extra field present */
  ------------------
  |  Branch (166:9): [True: 0, False: 72]
  ------------------
  167|      0|        len  =  (uInt )get_byte(s);
  168|      0|        len += ((uInt) get_byte(s)) << 8;
  169|       |        /* len is garbage if EOF but the loop below will quit anyway */
  170|      0|        while (len-- != 0 && get_byte(s) != EOF) ;
  ------------------
  |  Branch (170:16): [True: 0, False: 0]
  |  Branch (170:30): [True: 0, False: 0]
  ------------------
  171|      0|    }
  172|     72|    if ((flags & ORIG_NAME) != 0) { /* skip the original file name */
  ------------------
  |  |  118|     72|#define ORIG_NAME    0x08 /* bit 3 set: original file name present */
  ------------------
  |  Branch (172:9): [True: 0, False: 72]
  ------------------
  173|      0|        while ((c = get_byte(s)) != 0 && c != EOF) ;
  ------------------
  |  Branch (173:16): [True: 0, False: 0]
  |  Branch (173:42): [True: 0, False: 0]
  ------------------
  174|      0|    }
  175|     72|    if ((flags & COMMENT) != 0) {   /* skip the .gz file comment */
  ------------------
  |  |  119|     72|#define COMMENT      0x10 /* bit 4 set: file comment present */
  ------------------
  |  Branch (175:9): [True: 0, False: 72]
  ------------------
  176|      0|        while ((c = get_byte(s)) != 0 && c != EOF) ;
  ------------------
  |  Branch (176:16): [True: 0, False: 0]
  |  Branch (176:42): [True: 0, False: 0]
  ------------------
  177|      0|    }
  178|     72|    if ((flags & HEAD_CRC) != 0) {  /* skip the header crc */
  ------------------
  |  |  116|     72|#define HEAD_CRC     0x02 /* bit 1 set: header CRC present */
  ------------------
  |  Branch (178:9): [True: 0, False: 72]
  ------------------
  179|      0|        for (len = 0; len < 2; len++) (void) get_byte(s);
  ------------------
  |  Branch (179:23): [True: 0, False: 0]
  ------------------
  180|      0|    }
  181|     72|    s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK;
  ------------------
  |  Branch (181:16): [True: 0, False: 72]
  ------------------
  182|     72|}
connections.c:get_byte:
   74|  1.15k|{
   75|  1.15k|    if (s->z_eof) return EOF;
  ------------------
  |  Branch (75:9): [True: 0, False: 1.15k]
  ------------------
   76|  1.15k|    if (s->stream.avail_in == 0) {
  ------------------
  |  Branch (76:9): [True: 0, False: 1.15k]
  ------------------
   77|      0|        errno = 0;
   78|      0|        s->stream.avail_in = (uInt) fread(s->buffer, 1, Z_BUFSIZE, s->file);
  ------------------
  |  |   56|      0|#define Z_BUFSIZE 16384
  ------------------
   79|      0|        if (s->stream.avail_in == 0) {
  ------------------
  |  Branch (79:13): [True: 0, False: 0]
  ------------------
   80|      0|            s->z_eof = 1;
   81|      0|            if (ferror(s->file)) s->z_err = Z_ERRNO;
  ------------------
  |  Branch (81:17): [True: 0, False: 0]
  ------------------
   82|      0|            return EOF;
   83|      0|        }
   84|      0|        s->stream.next_in = s->buffer;
   85|      0|    }
   86|  1.15k|    s->stream.avail_in--;
   87|  1.15k|    return *(s->stream.next_in)++;
   88|  1.15k|}
connections.c:R_gzread:
  281|  88.0k|{
  282|  88.0k|    gz_stream *s = (gz_stream*) file;
  283|  88.0k|    Bytef *start = (Bytef*) buf; /* starting point for crc computation */
  284|  88.0k|    Byte  *next_out; /* == stream.next_out but not forced far (for MSDOS) */
  285|       |
  286|  88.0k|    if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR;
  ------------------
  |  Branch (286:9): [True: 0, False: 88.0k]
  |  Branch (286:22): [True: 0, False: 88.0k]
  ------------------
  287|       |
  288|  88.0k|    if (s->z_err == Z_DATA_ERROR) {
  ------------------
  |  Branch (288:9): [True: 0, False: 88.0k]
  ------------------
  289|      0|	warning("invalid or incomplete compressed data");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  290|      0|	return -1;
  291|  88.0k|    } else if(s->z_err == Z_ERRNO) {
  ------------------
  |  Branch (291:15): [True: 0, False: 88.0k]
  ------------------
  292|      0|	warning("error reading the file");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  293|      0|	return -1;
  294|      0|    }
  295|  88.0k|    if (s->z_err == Z_STREAM_END) return 0;  /* EOF */
  ------------------
  |  Branch (295:9): [True: 0, False: 88.0k]
  ------------------
  296|       |
  297|  88.0k|    next_out = (Byte*) buf;
  298|  88.0k|    s->stream.next_out = (Bytef*) buf;
  299|  88.0k|    s->stream.avail_out = len;
  300|       |
  301|   176k|    while (s->stream.avail_out != 0) {
  ------------------
  |  Branch (301:12): [True: 88.0k, False: 87.9k]
  ------------------
  302|       |
  303|  88.0k|        if (s->transparent) {
  ------------------
  |  Branch (303:13): [True: 0, False: 88.0k]
  ------------------
  304|       |            /* Copy first the lookahead bytes: */
  305|      0|            uInt n = s->stream.avail_in;
  306|      0|            if (n > s->stream.avail_out) n = s->stream.avail_out;
  ------------------
  |  Branch (306:17): [True: 0, False: 0]
  ------------------
  307|      0|            if (n > 0) {
  ------------------
  |  Branch (307:17): [True: 0, False: 0]
  ------------------
  308|      0|                memcpy(s->stream.next_out, s->stream.next_in, n);
  309|      0|                next_out += n;
  310|      0|                s->stream.next_out = next_out;
  311|      0|                s->stream.next_in   += n;
  312|      0|                s->stream.avail_out -= n;
  313|      0|                s->stream.avail_in  -= n;
  314|      0|            }
  315|      0|            if (s->stream.avail_out > 0) {
  ------------------
  |  Branch (315:17): [True: 0, False: 0]
  ------------------
  316|      0|                s->stream.avail_out -=
  317|      0|                    (uInt) fread(next_out, 1, s->stream.avail_out, s->file);
  318|      0|            }
  319|      0|            len -= s->stream.avail_out;
  320|      0|            s->in  += len;
  321|      0|            s->out += len;
  322|      0|            if (len == 0) s->z_eof = 1;
  ------------------
  |  Branch (322:17): [True: 0, False: 0]
  ------------------
  323|      0|            return (int)len;
  324|      0|        }
  325|  88.0k|        if (s->stream.avail_in == 0 && !s->z_eof) {
  ------------------
  |  Branch (325:13): [True: 0, False: 88.0k]
  |  Branch (325:40): [True: 0, False: 0]
  ------------------
  326|      0|            errno = 0;
  327|      0|            s->stream.avail_in = (uInt) fread(s->buffer, 1, Z_BUFSIZE, s->file);
  ------------------
  |  |   56|      0|#define Z_BUFSIZE 16384
  ------------------
  328|      0|            if (s->stream.avail_in == 0) {
  ------------------
  |  Branch (328:17): [True: 0, False: 0]
  ------------------
  329|      0|                s->z_eof = 1;
  330|      0|                if (ferror(s->file)) {
  ------------------
  |  Branch (330:21): [True: 0, False: 0]
  ------------------
  331|      0|                    s->z_err = Z_ERRNO;
  332|      0|                    break;
  333|      0|                }
  334|      0|            }
  335|      0|            s->stream.next_in = s->buffer;
  336|      0|        }
  337|  88.0k|        s->in += s->stream.avail_in;
  338|  88.0k|        s->out += s->stream.avail_out;
  339|  88.0k|        s->z_err = inflate(&(s->stream), Z_NO_FLUSH);
  340|  88.0k|        s->in -= s->stream.avail_in;
  341|  88.0k|        s->out -= s->stream.avail_out;
  342|       |
  343|  88.0k|        if (s->z_err == Z_STREAM_END) {
  ------------------
  |  Branch (343:13): [True: 72, False: 87.9k]
  ------------------
  344|       |            /* Check CRC and original size */
  345|     72|            s->crc = crc32(s->crc, start, (uInt) (s->stream.next_out - start));
  346|     72|            start = s->stream.next_out;
  347|       |
  348|     72|            if (getLong(s) != s->crc) {
  ------------------
  |  Branch (348:17): [True: 0, False: 72]
  ------------------
  349|      0|		warning("invalid or incomplete compressed data");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  350|      0|                s->z_err = Z_DATA_ERROR;
  351|     72|            } else {
  352|     72|                (void)getLong(s);
  353|       |                /* The uncompressed length returned by above getlong() may be
  354|       |                 * different from s->out in case of concatenated .gz files.
  355|       |                 * Check for such files:
  356|       |                 */
  357|     72|                check_header(s);
  358|     72|                if (s->z_err == Z_OK) {
  ------------------
  |  Branch (358:21): [True: 0, False: 72]
  ------------------
  359|      0|                    inflateReset(&(s->stream));
  360|      0|                    s->crc = crc32(0L, Z_NULL, 0);
  361|      0|                }
  362|     72|            }
  363|     72|        }
  364|  88.0k|        if (s->z_err != Z_OK || s->z_eof) break;
  ------------------
  |  Branch (364:13): [True: 72, False: 87.9k]
  |  Branch (364:33): [True: 0, False: 87.9k]
  ------------------
  365|  88.0k|    }
  366|  88.0k|    s->crc = crc32(s->crc, start, (uInt) (s->stream.next_out - start));
  367|       |
  368|  88.0k|    if (len == s->stream.avail_out &&
  ------------------
  |  Branch (368:9): [True: 24, False: 88.0k]
  ------------------
  369|     24|        (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO)) {
  ------------------
  |  Branch (369:10): [True: 0, False: 24]
  |  Branch (369:38): [True: 0, False: 24]
  ------------------
  370|      0|	if(s->z_err == Z_DATA_ERROR)
  ------------------
  |  Branch (370:5): [True: 0, False: 0]
  ------------------
  371|      0|	    warning("invalid or incomplete compressed data");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  372|      0|	else if(s->z_err == Z_ERRNO)
  ------------------
  |  Branch (372:10): [True: 0, False: 0]
  ------------------
  373|      0|	    warning("error reading the file");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  374|      0|	return -1;
  375|      0|    }
  376|  88.0k|    return (int)(len - s->stream.avail_out);
  377|  88.0k|}
connections.c:getLong:
  268|    144|{
  269|    144|    uLong x = (uLong) get_byte(s);
  270|    144|    int c;
  271|       |
  272|    144|    x += ((uLong) get_byte(s)) << 8;
  273|    144|    x += ((uLong) get_byte(s)) << 16;
  274|    144|    c = get_byte(s);
  275|    144|    if (c == EOF) s->z_err = Z_DATA_ERROR;
  ------------------
  |  Branch (275:9): [True: 0, False: 144]
  ------------------
  276|    144|    x += ((uLong) c) << 24;
  277|    144|    return x;
  278|    144|}

do_identical:
   51|    911|{
   52|    911|    int nargs = length(args);
  ------------------
  |  |  987|    911|#define length(x)		Rf_length(x)
  ------------------
   53|       |    /* avoid problems with earlier (and future) versions captured in S4
   54|       |       methods: but this should be fixed where it is caused, in
   55|       |       'methods'!
   56|       |
   57|       |       checkArity(op, args); */
   58|    911|    if (nargs < 5)
  ------------------
  |  Branch (58:9): [True: 0, False: 911]
  ------------------
   59|      0|	error("%d arguments passed to .Internal(%s) which requires %d",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
   60|      0|	      length(args), PRIMNAME(op), PRIMARITY(op));
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
              	      length(args), PRIMNAME(op), PRIMARITY(op));
  ------------------
  |  | 1346|      0|#define PRIMNAME(x)	(R_FunTab[PRIMOFFSET(x)].name)
  ------------------
              	      length(args), PRIMNAME(op), PRIMARITY(op));
  ------------------
  |  | 1348|      0|#define PRIMARITY(x)	(R_FunTab[PRIMOFFSET(x)].arity)
  ------------------
   61|       |
   62|    911|    SEXP x = CAR(args); args = CDR(args);
   63|    911|    SEXP y = CAR(args); args = CDR(args);
   64|       |
   65|    911|    int num_as_bits = ! asFlag(CAR(args), "num.eq"); args = CDR(args);
   66|    911|    int NA_as_bits = ! asFlag(CAR(args), "single.NA"); args = CDR(args);
   67|    911|    int attr_by_order = ! asFlag(CAR(args), "attrib.as.set"); args = CDR(args);
   68|       |
   69|    911|    int use_bytecode = FALSE;
   70|    911|    if (nargs >= 6)
  ------------------
  |  Branch (70:9): [True: 911, False: 0]
  ------------------
   71|    911|	use_bytecode = ! asFlag(CAR(args), "ignore.bytecode");
   72|       |
   73|    911|    int use_cloenv = TRUE;
   74|    911|    if (nargs >= 7)
  ------------------
  |  Branch (74:9): [True: 911, False: 0]
  ------------------
   75|    911|	use_cloenv = ! asFlag(CADR(args), "ignore.environment");
   76|       |
   77|    911|    int use_srcref = FALSE;
   78|    911|    if (nargs >= 8)
  ------------------
  |  Branch (78:9): [True: 911, False: 0]
  ------------------
   79|    911|	use_srcref = ! asFlag(CADDR(args), "ignore.srcref");
   80|       |
   81|    911|    int extptr_as_ref = FALSE;
   82|    911|    if (nargs >= 9)
  ------------------
  |  Branch (82:9): [True: 911, False: 0]
  ------------------
   83|    911|	extptr_as_ref = asFlag(CADDDR(args), "extptr.as.ref");
   84|       |
   85|    911|    int flags = 0;
   86|    911|    if (num_as_bits) flags |= IDENT_NUM_AS_BITS;
  ------------------
  |  |  840|      0|#define IDENT_NUM_AS_BITS      1
  ------------------
  |  Branch (86:9): [True: 0, False: 911]
  ------------------
   87|    911|    if (NA_as_bits) flags |= IDENT_NA_AS_BITS;
  ------------------
  |  |  841|      0|#define IDENT_NA_AS_BITS       2
  ------------------
  |  Branch (87:9): [True: 0, False: 911]
  ------------------
   88|    911|    if (attr_by_order) flags |= IDENT_ATTR_BY_ORDER;
  ------------------
  |  |  842|      0|#define IDENT_ATTR_BY_ORDER    4
  ------------------
  |  Branch (88:9): [True: 0, False: 911]
  ------------------
   89|    911|    if (use_bytecode) flags |= IDENT_USE_BYTECODE;
  ------------------
  |  |  843|      0|#define IDENT_USE_BYTECODE     8
  ------------------
  |  Branch (89:9): [True: 0, False: 911]
  ------------------
   90|    911|    if (use_cloenv) flags |= IDENT_USE_CLOENV;
  ------------------
  |  |  844|    911|#define IDENT_USE_CLOENV      16
  ------------------
  |  Branch (90:9): [True: 911, False: 0]
  ------------------
   91|    911|    if (use_srcref) flags |= IDENT_USE_SRCREF;
  ------------------
  |  |  845|      0|#define IDENT_USE_SRCREF      32
  ------------------
  |  Branch (91:9): [True: 0, False: 911]
  ------------------
   92|    911|    if (extptr_as_ref) flags |= IDENT_EXTPTR_AS_REF;
  ------------------
  |  |  846|      0|#define IDENT_EXTPTR_AS_REF   64
  ------------------
  |  Branch (92:9): [True: 0, False: 911]
  ------------------
   93|       |
   94|    911|    return ScalarLogical(R_compute_identical(x, y, flags));
  ------------------
  |  | 1023|    911|#define ScalarLogical		Rf_ScalarLogical
  ------------------
   95|    911|}
R_compute_identical:
  109|  4.83k|{
  110|  4.83k|    if(x == y) /* same pointer */
  ------------------
  |  Branch (110:8): [True: 475, False: 4.35k]
  ------------------
  111|    475|	return TRUE;
  112|  4.35k|    if(TYPEOF(x) != TYPEOF(y) ||
  ------------------
  |  Branch (112:8): [True: 2.16k, False: 2.18k]
  ------------------
  113|  2.18k|       OBJECT(x) != OBJECT(y) ||
  ------------------
  |  Branch (113:8): [True: 4, False: 2.18k]
  ------------------
  114|  2.18k|       IS_S4_OBJECT(x) != IS_S4_OBJECT(y))
  ------------------
  |  Branch (114:8): [True: 0, False: 2.18k]
  ------------------
  115|  2.17k|	return FALSE;
  116|       |
  117|       |    /* Skip attribute checks for CHARSXP
  118|       |       -- such attributes are used for the cache.  */
  119|  2.18k|    if(TYPEOF(x) == CHARSXP) {
  ------------------
  |  |  120|  2.18k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (119:8): [True: 0, False: 2.18k]
  ------------------
  120|       |	/* This matches NAs */
  121|      0|	return Seql(x, y) == 1;
  ------------------
  |  | 1983|      0|# define Seql			Rf_Seql
  ------------------
  122|      0|    }
  123|  2.18k|    SEXP ax, ay;
  124|  2.18k|    if (IGNORE_SRCREF && TYPEOF(x) == CLOSXP) {
  ------------------
  |  |  102|  4.36k|#define IGNORE_SRCREF   (!(flags & IDENT_USE_SRCREF))
  |  |  ------------------
  |  |  |  |  845|  2.18k|#define IDENT_USE_SRCREF      32
  |  |  ------------------
  |  |  |  Branch (102:25): [True: 2.18k, False: 0]
  |  |  ------------------
  ------------------
                  if (IGNORE_SRCREF && TYPEOF(x) == CLOSXP) {
  ------------------
  |  |  114|  2.18k|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (124:26): [True: 0, False: 2.18k]
  ------------------
  125|       |	/* Remove "srcref" attribute - and below, treat body(x), body(y) */
  126|      0|	SEXP x_ = PROTECT(duplicate(x)), y_ = PROTECT(duplicate(y));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
              	SEXP x_ = PROTECT(duplicate(x)), y_ = PROTECT(duplicate(y));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  127|      0|	setAttrib(x_, R_SrcrefSymbol, R_NilValue);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  128|      0|	setAttrib(y_, R_SrcrefSymbol, R_NilValue);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  129|      0|	ax = ATTRIB(x_); ay = ATTRIB(y_);
  130|      0|	UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  131|      0|    }
  132|  2.18k|    else {
  133|  2.18k|	ax = ATTRIB(x); ay = ATTRIB(y);
  134|  2.18k|    }
  135|       |
  136|  2.18k|    if(ax != R_NilValue || ay != R_NilValue) {
  ------------------
  |  Branch (136:8): [True: 27, False: 2.15k]
  |  Branch (136:28): [True: 0, False: 2.15k]
  ------------------
  137|     27|	if(ax == R_NilValue || ay == R_NilValue)
  ------------------
  |  Branch (137:5): [True: 0, False: 27]
  |  Branch (137:25): [True: 14, False: 13]
  ------------------
  138|     14|	    return FALSE;
  139|       |	/* Attributes are tagged pairlists with unique non-empty non-NA tags.
  140|       |	   This code still includes a check and if they are not pairlists,
  141|       |	   they are not compared, with a warning (could be turned into an error
  142|       |	   or removed). */
  143|     13|	if(TYPEOF(ax) != LISTSXP || TYPEOF(ay) != LISTSXP) {
  ------------------
  |  |  113|     26|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
              	if(TYPEOF(ax) != LISTSXP || TYPEOF(ay) != LISTSXP) {
  ------------------
  |  |  113|     13|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (143:5): [True: 0, False: 13]
  |  Branch (143:30): [True: 0, False: 13]
  ------------------
  144|      0|	    warning(_("ignoring non-pairlist attributes"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("ignoring non-pairlist attributes"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  145|     13|	} else if (!ATTR_AS_SET) {
  ------------------
  |  |   99|     13|#define ATTR_AS_SET     (!(flags & IDENT_ATTR_BY_ORDER))
  |  |  ------------------
  |  |  |  |  842|     13|#define IDENT_ATTR_BY_ORDER    4
  |  |  ------------------
  ------------------
  |  Branch (145:13): [True: 0, False: 13]
  ------------------
  146|       |	    /* ax, ay might be fresh allocations from duplicating into
  147|       |	       x_, y_) above, so need to be protected from possible
  148|       |	       allocations in getAttrib and recursive calls to
  149|       |	       R_compute_identical in the loop. */
  150|      0|	    PROTECT(ax);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  151|      0|	    PROTECT(ay);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  152|      0|	    while (ax != R_NilValue) {
  ------------------
  |  Branch (152:13): [True: 0, False: 0]
  ------------------
  153|      0|		if (ay == R_NilValue) {
  ------------------
  |  Branch (153:7): [True: 0, False: 0]
  ------------------
  154|      0|		    UNPROTECT(2); /* ax, ay */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  155|      0|		    return FALSE;
  156|      0|		}
  157|       |		/* Need to check for R_RowNamesSymbol and treat specially */
  158|      0|		if (TAG(ax) == R_RowNamesSymbol) {
  ------------------
  |  Branch (158:7): [True: 0, False: 0]
  ------------------
  159|      0|		    SEXP atrx = PROTECT(getAttrib(x, R_RowNamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  160|      0|		    SEXP atry = PROTECT(getAttrib(y, R_RowNamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  161|      0|		    if (!R_compute_identical(atrx, atry, flags)) {
  ------------------
  |  Branch (161:11): [True: 0, False: 0]
  ------------------
  162|      0|			UNPROTECT(4); /* atrx, atry, ax, ay */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  163|      0|			return FALSE;
  164|      0|		    } 
  165|      0|		    UNPROTECT(2); /* atrx, atry */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  166|      0|		} else if (!R_compute_identical(CAR(ax), CAR(ay), flags)) {	  
  ------------------
  |  Branch (166:14): [True: 0, False: 0]
  ------------------
  167|      0|		    UNPROTECT(2); /* ax, ay */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  168|      0|		    return FALSE;
  169|      0|		}
  170|      0|		if (!R_compute_identical(PRINTNAME(TAG(ax)),
  ------------------
  |  Branch (170:7): [True: 0, False: 0]
  ------------------
  171|      0|					 PRINTNAME(TAG(ay)), flags)) {
  172|      0|		    UNPROTECT(2); /* ax, ay */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  173|      0|		    return FALSE;
  174|      0|		}
  175|      0|		ax = CDR(ax);
  176|      0|		ay = CDR(ay);
  177|      0|	    }
  178|      0|	    UNPROTECT(2); /* ax, ay */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  179|      0|	    if (ay != R_NilValue)
  ------------------
  |  Branch (179:10): [True: 0, False: 0]
  ------------------
  180|      0|		return FALSE;
  181|     13|	} else /* ATTR_AS_SET */ {
  182|       |	    /* This code is not very efficient, but then neither is using
  183|       |	       pairlists for attributes.  If long attribute lists become more
  184|       |	       common (and they are used for S4 slots) we should store them in
  185|       |	       a hash table. */
  186|     13|	    SEXP elx, ely;
  187|     13|	    if(length(ax) != length(ay)) return FALSE;
  ------------------
  |  |  987|     13|#define length(x)		Rf_length(x)
  ------------------
              	    if(length(ax) != length(ay)) return FALSE;
  ------------------
  |  |  987|     13|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (187:9): [True: 12, False: 1]
  ------------------
  188|       |	    /* They are the same length and should have
  189|       |	       unique non-empty non-NA tags */
  190|       |	    /* ax, ay might be fresh allocations from duplicating into
  191|       |	       x_, y_) above, so need to be protected from possible
  192|       |	       allocations in getAttrib and recursive calls to
  193|       |	       R_compute_identical in the loop. */
  194|      1|	    PROTECT(ax);
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
  195|      1|	    PROTECT(ay);
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
  196|      2|	    for(elx = ax; elx != R_NilValue; elx = CDR(elx)) {
  ------------------
  |  Branch (196:20): [True: 1, False: 1]
  ------------------
  197|      1|		const char *tx = CHAR(PRINTNAME(TAG(elx)));
  ------------------
  |  |  203|      1|#define CHAR(x) R_CHAR(x)
  ------------------
  198|      1|		for(ely = ay; ely != R_NilValue; ely = CDR(ely))
  ------------------
  |  Branch (198:17): [True: 1, False: 0]
  ------------------
  199|      1|		    if(streql(tx, CHAR(PRINTNAME(TAG(ely))))) {
  ------------------
  |  | 1498|      1|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  200|       |			/* We need to treat row.names specially here */
  201|      1|			if(streql(tx, "row.names")) {
  ------------------
  |  | 1498|      1|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  202|      0|			    SEXP
  203|      0|				atrx = PROTECT(getAttrib(x, R_RowNamesSymbol)),
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  204|      0|				atry = PROTECT(getAttrib(y, R_RowNamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  205|      0|			    if(!R_compute_identical(atrx, atry, flags)) {
  ------------------
  |  Branch (205:11): [True: 0, False: 0]
  ------------------
  206|      0|				UNPROTECT(4); /* atrx, atry, ax, ay */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  207|      0|				return FALSE;
  208|      0|			    } else
  209|      0|				UNPROTECT(2); /* atrx, atry */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  210|      0|			} else
  211|      1|			    if(!R_compute_identical(CAR(elx), CAR(ely),
  ------------------
  |  Branch (211:11): [True: 0, False: 1]
  ------------------
  212|      1|						    flags)) {
  213|      0|				UNPROTECT(2); /* ax, ay */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  214|      0|				return FALSE;
  215|      0|			    }
  216|      1|			break;
  217|      1|		    }
  218|      1|		if(ely == R_NilValue) {
  ------------------
  |  Branch (218:6): [True: 0, False: 1]
  ------------------
  219|      0|		    UNPROTECT(2); /* ax, ay */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  220|      0|		    return FALSE;
  221|      0|		}
  222|      1|	    }
  223|      1|	    UNPROTECT(2); /* ax, ay */
  ------------------
  |  |  358|      1|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  224|      1|	}
  225|     13|    }
  226|       |
  227|  2.15k|    switch (TYPEOF(x)) {
  228|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (228:5): [True: 0, False: 2.15k]
  ------------------
  229|      0|	return TRUE;
  230|      4|    case LGLSXP:
  ------------------
  |  |  121|      4|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (230:5): [True: 4, False: 2.15k]
  ------------------
  231|      4|	if (XLENGTH(x) != XLENGTH(y)) return FALSE;
  ------------------
  |  Branch (231:6): [True: 0, False: 4]
  ------------------
  232|       |	/* Use memcmp (which is ISO C90) to speed up the comparison */
  233|      4|	return memcmp((const void *)LOGICAL_RO(x), (const void *)LOGICAL_RO(y),
  ------------------
  |  Branch (233:9): [True: 4, False: 0]
  ------------------
  234|      4|		      xlength(x) * sizeof(int)) == 0 ? TRUE : FALSE;
  ------------------
  |  | 1049|      4|#define xlength(x)		Rf_xlength(x)
  ------------------
  235|     31|    case INTSXP:
  ------------------
  |  |  123|     31|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (235:5): [True: 31, False: 2.12k]
  ------------------
  236|     31|	if (XLENGTH(x) != XLENGTH(y)) return FALSE;
  ------------------
  |  Branch (236:6): [True: 20, False: 11]
  ------------------
  237|       |	/* Use memcmp (which is ISO C90) to speed up the comparison */
  238|     11|	return memcmp((const void *)INTEGER_RO(x), (const void *)INTEGER_RO(y),
  ------------------
  |  Branch (238:9): [True: 8, False: 3]
  ------------------
  239|     11|		      xlength(x) * sizeof(int)) == 0 ? TRUE : FALSE;
  ------------------
  |  | 1049|     11|#define xlength(x)		Rf_xlength(x)
  ------------------
  240|      1|    case REALSXP:
  ------------------
  |  |  124|      1|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (240:5): [True: 1, False: 2.15k]
  ------------------
  241|      1|    {
  242|      1|	R_xlen_t n = XLENGTH(x);
  243|      1|	if(n != XLENGTH(y)) return FALSE;
  ------------------
  |  Branch (243:5): [True: 0, False: 1]
  ------------------
  244|      1|	else {
  245|      1|	    const double *xp = REAL_RO(x), *yp = REAL_RO(y);
  246|      1|	    int ne_strict = NUM_EQ | (SINGLE_NA << 1);
  ------------------
  |  |   97|      1|#define NUM_EQ		(!(flags & IDENT_NUM_AS_BITS))
  |  |  ------------------
  |  |  |  |  840|      1|#define IDENT_NUM_AS_BITS      1
  |  |  ------------------
  ------------------
              	    int ne_strict = NUM_EQ | (SINGLE_NA << 1);
  ------------------
  |  |   98|      1|#define SINGLE_NA       (!(flags & IDENT_NA_AS_BITS))
  |  |  ------------------
  |  |  |  |  841|      1|#define IDENT_NA_AS_BITS       2
  |  |  ------------------
  ------------------
  247|      2|	    for(R_xlen_t i = 0; i < n; i++)
  ------------------
  |  Branch (247:26): [True: 1, False: 1]
  ------------------
  248|      1|		if(neWithNaN(xp[i], yp[i], ne_strict)) return FALSE;
  ------------------
  |  Branch (248:6): [True: 0, False: 1]
  ------------------
  249|      1|	}
  250|      1|	return TRUE;
  251|      1|    }
  252|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (252:5): [True: 0, False: 2.15k]
  ------------------
  253|      0|    {
  254|      0|	R_xlen_t n = XLENGTH(x);
  255|      0|	if(n != XLENGTH(y)) return FALSE;
  ------------------
  |  Branch (255:5): [True: 0, False: 0]
  ------------------
  256|      0|	else {
  257|      0|	    const Rcomplex *xp = COMPLEX_RO(x), *yp = COMPLEX_RO(y);
  258|      0|	    int ne_strict = NUM_EQ | (SINGLE_NA << 1);
  ------------------
  |  |   97|      0|#define NUM_EQ		(!(flags & IDENT_NUM_AS_BITS))
  |  |  ------------------
  |  |  |  |  840|      0|#define IDENT_NUM_AS_BITS      1
  |  |  ------------------
  ------------------
              	    int ne_strict = NUM_EQ | (SINGLE_NA << 1);
  ------------------
  |  |   98|      0|#define SINGLE_NA       (!(flags & IDENT_NA_AS_BITS))
  |  |  ------------------
  |  |  |  |  841|      0|#define IDENT_NA_AS_BITS       2
  |  |  ------------------
  ------------------
  259|      0|	    for(R_xlen_t i = 0; i < n; i++)
  ------------------
  |  Branch (259:26): [True: 0, False: 0]
  ------------------
  260|      0|		if(neWithNaN(xp[i].r, yp[i].r, ne_strict) ||
  ------------------
  |  Branch (260:6): [True: 0, False: 0]
  ------------------
  261|      0|		   neWithNaN(xp[i].i, yp[i].i, ne_strict))
  ------------------
  |  Branch (261:6): [True: 0, False: 0]
  ------------------
  262|      0|		    return FALSE;
  263|      0|	}
  264|      0|	return TRUE;
  265|      0|    }
  266|     61|    case STRSXP:
  ------------------
  |  |  126|     61|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (266:5): [True: 61, False: 2.09k]
  ------------------
  267|     61|    {
  268|     61|	R_xlen_t i, n = XLENGTH(x);
  269|     61|	if(n != XLENGTH(y)) return FALSE;
  ------------------
  |  Branch (269:5): [True: 28, False: 33]
  ------------------
  270|     71|	for(i = 0; i < n; i++) {
  ------------------
  |  Branch (270:13): [True: 47, False: 24]
  ------------------
  271|       |	    /* This special-casing for NAs is not needed */
  272|     47|	    bool na1 = (STRING_ELT(x, i) == NA_STRING),
  ------------------
  |  |  433|     47|#define NA_STRING	R_NaString
  ------------------
  273|     47|		na2 = (STRING_ELT(y, i) == NA_STRING);
  ------------------
  |  |  433|     47|#define NA_STRING	R_NaString
  ------------------
  274|     47|	    if(na1 ^ na2) return FALSE;
  ------------------
  |  Branch (274:9): [True: 4, False: 43]
  ------------------
  275|     43|	    if(na1 && na2) continue;
  ------------------
  |  Branch (275:9): [True: 0, False: 43]
  |  Branch (275:16): [True: 0, False: 0]
  ------------------
  276|     43|	    if (! Seql(STRING_ELT(x, i), STRING_ELT(y, i))) return FALSE;
  ------------------
  |  | 1983|     43|# define Seql			Rf_Seql
  ------------------
  |  Branch (276:10): [True: 5, False: 38]
  ------------------
  277|     43|	}
  278|     24|	return TRUE;
  279|     33|    }
  280|      0|    case CHARSXP: /* Probably unreachable, but better safe than sorry... */
  ------------------
  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (280:5): [True: 0, False: 2.15k]
  ------------------
  281|      0|    {
  282|       |	/* This matches NAs */
  283|      0|	return Seql(x, y) == 1;
  ------------------
  |  | 1983|      0|# define Seql			Rf_Seql
  ------------------
  284|     33|    }
  285|      6|    case VECSXP:
  ------------------
  |  |  131|      6|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (285:5): [True: 6, False: 2.15k]
  ------------------
  286|      6|    case EXPRSXP:
  ------------------
  |  |  132|      6|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (286:5): [True: 0, False: 2.15k]
  ------------------
  287|      6|    {
  288|      6|	R_xlen_t i, n = XLENGTH(x);
  289|      6|	if(n != XLENGTH(y)) return FALSE;
  ------------------
  |  Branch (289:5): [True: 0, False: 6]
  ------------------
  290|      9|	for(i = 0; i < n; i++)
  ------------------
  |  Branch (290:13): [True: 8, False: 1]
  ------------------
  291|      8|	    if(!R_compute_identical(VECTOR_ELT(x, i),VECTOR_ELT(y, i), flags))
  ------------------
  |  Branch (291:9): [True: 5, False: 3]
  ------------------
  292|      5|		return FALSE;
  293|      1|	return TRUE;
  294|      6|    }
  295|    758|    case LANGSXP:
  ------------------
  |  |  117|    758|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (295:5): [True: 758, False: 1.39k]
  ------------------
  296|    758|    case LISTSXP:
  ------------------
  |  |  113|    758|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (296:5): [True: 0, False: 2.15k]
  ------------------
  297|    758|    case DOTSXP:
  ------------------
  |  |  127|    758|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (297:5): [True: 0, False: 2.15k]
  ------------------
  298|    758|    {
  299|    781|	while (x != R_NilValue) {
  ------------------
  |  Branch (299:9): [True: 780, False: 1]
  ------------------
  300|    780|	    if(y == R_NilValue)
  ------------------
  |  Branch (300:9): [True: 0, False: 780]
  ------------------
  301|      0|		return FALSE;
  302|    780|	    if(!R_compute_identical(CAR(x), CAR(y), flags))
  ------------------
  |  Branch (302:9): [True: 757, False: 23]
  ------------------
  303|    757|		return FALSE;
  304|     23|	    if(!R_compute_identical(PRINTNAME(TAG(x)), PRINTNAME(TAG(y)), flags))
  ------------------
  |  Branch (304:9): [True: 0, False: 23]
  ------------------
  305|      0|		return FALSE;
  306|     23|	    x = CDR(x);
  307|     23|	    y = CDR(y);
  308|     23|	}
  309|      1|	return(y == R_NilValue);
  310|    758|    }
  311|      0|    case CLOSXP:
  ------------------
  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (311:5): [True: 0, False: 2.15k]
  ------------------
  312|      0|    {
  313|      0|	if(!R_compute_identical(FORMALS(x), FORMALS(y), flags)) return FALSE;
  ------------------
  |  Branch (313:5): [True: 0, False: 0]
  ------------------
  314|      0|	if(IGNORE_BYTECODE) {
  ------------------
  |  |  100|      0|#define IGNORE_BYTECODE (!(flags & IDENT_USE_BYTECODE))
  |  |  ------------------
  |  |  |  |  843|      0|#define IDENT_USE_BYTECODE     8
  |  |  ------------------
  |  |  |  Branch (100:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  315|      0|	    if(IGNORE_SRCREF) {
  ------------------
  |  |  102|      0|#define IGNORE_SRCREF   (!(flags & IDENT_USE_SRCREF))
  |  |  ------------------
  |  |  |  |  845|      0|#define IDENT_USE_SRCREF      32
  |  |  ------------------
  |  |  |  Branch (102:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  316|      0|		SEXP x_ = PROTECT(R_body_no_src(x)),
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  317|      0|		     y_ = PROTECT(R_body_no_src(y));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  318|      0|		Rboolean id_body = R_compute_identical(x_, y_, flags);
  319|      0|		UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  320|      0|		if(!id_body) return FALSE;
  ------------------
  |  Branch (320:6): [True: 0, False: 0]
  ------------------
  321|      0|	    } else if(!R_compute_identical(BODY_EXPR(x), BODY_EXPR(y), flags))
  ------------------
  |  | 1220|      0|#define BODY_EXPR(e) R_ClosureExpr(e)
  ------------------
              	    } else if(!R_compute_identical(BODY_EXPR(x), BODY_EXPR(y), flags))
  ------------------
  |  | 1220|      0|#define BODY_EXPR(e) R_ClosureExpr(e)
  ------------------
  |  Branch (321:16): [True: 0, False: 0]
  ------------------
  322|      0|		return FALSE;
  323|      0|	} else { // !IGNORE_BYTECODE: use byte code for comparison of function bodies :
  324|      0|	    if(!R_compute_identical(BODY(x), BODY(y), flags)) return FALSE;
  ------------------
  |  Branch (324:9): [True: 0, False: 0]
  ------------------
  325|      0|	}
  326|       |	// now, formals and body are equal, check the environment(.)s:
  327|      0|	return (IGNORE_ENV || CLOENV(x) == CLOENV(y) ? TRUE : FALSE);
  ------------------
  |  |  101|      0|#define IGNORE_ENV      (!(flags & IDENT_USE_CLOENV))
  |  |  ------------------
  |  |  |  |  844|      0|#define IDENT_USE_CLOENV      16
  |  |  ------------------
  |  |  |  Branch (101:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (327:24): [True: 0, False: 0]
  ------------------
  328|      0|    }
  329|      0|    case SPECIALSXP:
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (329:5): [True: 0, False: 2.15k]
  ------------------
  330|      0|    case BUILTINSXP:
  ------------------
  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (330:5): [True: 0, False: 2.15k]
  ------------------
  331|      0|	return(PRIMOFFSET(x) == PRIMOFFSET(y) ? TRUE : FALSE);
  ------------------
  |  Branch (331:9): [True: 0, False: 0]
  ------------------
  332|    271|    case ENVSXP:
  ------------------
  |  |  115|    271|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (332:5): [True: 271, False: 1.88k]
  ------------------
  333|  1.26k|    case SYMSXP:
  ------------------
  |  |  112|  1.26k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (333:5): [True: 997, False: 1.15k]
  ------------------
  334|  1.26k|    case WEAKREFSXP: /**** is this the best approach? */
  ------------------
  |  |  135|  1.26k|#define WEAKREFSXP  23    /* weak reference */
  ------------------
  |  Branch (334:5): [True: 0, False: 2.15k]
  ------------------
  335|  1.26k|	return(x == y ? TRUE : FALSE);
  ------------------
  |  Branch (335:9): [True: 0, False: 1.26k]
  ------------------
  336|     27|    case BCODESXP:
  ------------------
  |  |  133|     27|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (336:5): [True: 27, False: 2.12k]
  ------------------
  337|     27|	return R_compute_identical(BCODE_CODE(x), BCODE_CODE(y), flags) &&
  ------------------
  |  |  735|     27|#define BCODE_CODE(x)	CAR(x)
  ------------------
              	return R_compute_identical(BCODE_CODE(x), BCODE_CODE(y), flags) &&
  ------------------
  |  |  735|     27|#define BCODE_CODE(x)	CAR(x)
  ------------------
  |  Branch (337:9): [True: 6, False: 21]
  ------------------
  338|      6|	       R_compute_identical(BCODE_EXPR(x), BCODE_EXPR(y), flags) &&
  ------------------
  |  |  738|      6|#define BCODE_EXPR(x)	TAG(x)
  ------------------
              	       R_compute_identical(BCODE_EXPR(x), BCODE_EXPR(y), flags) &&
  ------------------
  |  |  738|      6|#define BCODE_EXPR(x)	TAG(x)
  ------------------
  |  Branch (338:9): [True: 6, False: 0]
  ------------------
  339|      6|	       R_compute_identical(BCODE_CONSTS(x), BCODE_CONSTS(y), flags);
  ------------------
  |  |  737|      6|#define BCODE_CONSTS(x) CDR(x)
  ------------------
              	       R_compute_identical(BCODE_CONSTS(x), BCODE_CONSTS(y), flags);
  ------------------
  |  |  737|      6|#define BCODE_CONSTS(x) CDR(x)
  ------------------
  |  Branch (339:9): [True: 1, False: 5]
  ------------------
  340|      0|    case EXTPTRSXP:
  ------------------
  |  |  134|      0|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (340:5): [True: 0, False: 2.15k]
  ------------------
  341|      0|	if (EXTPTR_AS_REF)
  ------------------
  |  |  103|      0|#define EXTPTR_AS_REF   (flags & IDENT_EXTPTR_AS_REF)
  |  |  ------------------
  |  |  |  |  846|      0|#define IDENT_EXTPTR_AS_REF   64
  |  |  ------------------
  |  |  |  Branch (103:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  342|      0|	    return x == y ? TRUE : FALSE;
  ------------------
  |  Branch (342:13): [True: 0, False: 0]
  ------------------
  343|      0|	else
  344|      0|	    return (EXTPTR_PTR(x) == EXTPTR_PTR(y) ? TRUE : FALSE);
  ------------------
  |  Branch (344:14): [True: 0, False: 0]
  ------------------
  345|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (345:5): [True: 0, False: 2.15k]
  ------------------
  346|      0|	if (XLENGTH(x) != XLENGTH(y)) return FALSE;
  ------------------
  |  Branch (346:6): [True: 0, False: 0]
  ------------------
  347|       |	/* Use memcmp (which is ISO C90) to speed up the comparison */
  348|      0|	return memcmp((const void *)RAW_RO(x), (const void *)RAW_RO(y),
  ------------------
  |  Branch (348:9): [True: 0, False: 0]
  ------------------
  349|      0|		      XLENGTH(x) * sizeof(Rbyte)) == 0 ? TRUE : FALSE;
  350|      0|    case PROMSXP:
  ------------------
  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (350:5): [True: 0, False: 2.15k]
  ------------------
  351|      0|    {
  352|       |	// args are evaluated -- but can be seen from DOTSXP dissection
  353|       |	/* test for equality of the substituted expression -- or should
  354|       |	   we require both expression and environment to be identical? */
  355|      0|	SEXP sy = PROTECT(substitute(PREXPR(y), PRENV(y)));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  356|      0|	SEXP sx = PROTECT(substitute(PREXPR(x), PRENV(x)));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  357|      0|	Rboolean ans = R_compute_identical(sx, sy, flags);
  358|      0|	UNPROTECT(2); /* sx, sy */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  359|      0|	return ans;
  360|      0|    }
  361|      0|    case OBJSXP:
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (361:5): [True: 0, False: 2.15k]
  ------------------
  362|       |	/* attributes already tested, so all slots identical */
  363|      0|	return TRUE;
  364|      0|    default:
  ------------------
  |  Branch (364:5): [True: 0, False: 2.15k]
  ------------------
  365|       |	/* these are all supposed to be types that represent constant
  366|       |	   entities, so no further testing required ?? */
  367|      0|	printf("Unknown Type in identical(): %s (%x)\n", R_typeToChar(x), TYPEOF(x));
  368|      0|	return TRUE;
  369|  2.15k|    }
  370|  2.15k|}
identical.c:asFlag:
   42|  6.37k|{
   43|  6.37k|    int val = asLogical(x);
  ------------------
  |  |  886|  6.37k|#define asLogical		Rf_asLogical
  ------------------
   44|  6.37k|    if (val == NA_LOGICAL)
  ------------------
  |  |   55|  6.37k|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (44:9): [True: 0, False: 6.37k]
  ------------------
   45|      0|	error(_("invalid '%s' value"), name);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' value"), name);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   46|  6.37k|    return val;
   47|  6.37k|}
identical.c:neWithNaN:
  391|      1|{
  392|      1|    switch (str) {
  ------------------
  |  Branch (392:13): [True: 1, False: 0]
  ------------------
  393|      1|    case single_NA__num_eq:
  ------------------
  |  Branch (393:5): [True: 1, False: 0]
  ------------------
  394|      1|    case single_NA__num_bit:
  ------------------
  |  Branch (394:5): [True: 0, False: 1]
  ------------------
  395|      1|	if(R_IsNA(x))
  ------------------
  |  Branch (395:5): [True: 0, False: 1]
  ------------------
  396|      0|	    return(R_IsNA(y) ? FALSE : TRUE);
  ------------------
  |  Branch (396:13): [True: 0, False: 0]
  ------------------
  397|      1|	if(R_IsNA(y))
  ------------------
  |  Branch (397:5): [True: 0, False: 1]
  ------------------
  398|      0|	    return(R_IsNA(x) ? FALSE : TRUE);
  ------------------
  |  Branch (398:13): [True: 0, False: 0]
  ------------------
  399|      1|	if(ISNAN(x))
  ------------------
  |  |   76|      1|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  400|      0|	    return(ISNAN(y) ? FALSE : TRUE);
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  401|       |
  402|      1|    case bit_NA__num_eq:
  ------------------
  |  Branch (402:5): [True: 0, False: 1]
  ------------------
  403|      1|    case bit_NA__num_bit:
  ------------------
  |  Branch (403:5): [True: 0, False: 1]
  ------------------
  404|      1|	; /* do nothing */
  405|      1|    }
  406|       |
  407|      1|    switch (str) {
  408|      1|    case single_NA__num_eq:
  ------------------
  |  Branch (408:5): [True: 1, False: 0]
  ------------------
  409|      1|	return(x != y);
  410|      0|    case bit_NA__num_eq:
  ------------------
  |  Branch (410:5): [True: 0, False: 1]
  ------------------
  411|      0|	if(!ISNAN(x) && !ISNAN(y))
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  ------------------
              	if(!ISNAN(x) && !ISNAN(y))
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  ------------------
  |  Branch (411:5): [True: 0, False: 0]
  |  Branch (411:18): [True: 0, False: 0]
  ------------------
  412|      0|	    return(x != y);
  413|      0|	else /* bitwise check for NA/NaN's */
  414|      0|	    return memcmp((const void *) &x,
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|			  (const void *) &y, sizeof(double)) ? TRUE : FALSE;
  416|      0|    case bit_NA__num_bit:
  ------------------
  |  Branch (416:5): [True: 0, False: 1]
  ------------------
  417|      0|    case single_NA__num_bit:
  ------------------
  |  Branch (417:5): [True: 0, False: 1]
  ------------------
  418|      0|	return memcmp((const void *) &x,
  ------------------
  |  Branch (418:9): [True: 0, False: 0]
  ------------------
  419|      0|		      (const void *) &y, sizeof(double)) ? TRUE : FALSE;
  420|      0|    default: /* Wall */
  ------------------
  |  Branch (420:5): [True: 0, False: 1]
  ------------------
  421|      0|	return FALSE;
  422|      1|    }
  423|      1|}

R_IoBufferWriteReset:
   75|      2|{
   76|      2|    if (iob == NULL || iob->start_buf == NULL)
  ------------------
  |  Branch (76:9): [True: 0, False: 2]
  |  Branch (76:24): [True: 0, False: 2]
  ------------------
   77|      0|	return 0;
   78|      2|    iob->write_buf = iob->start_buf;
   79|      2|    iob->write_ptr = iob->write_buf->buf;
   80|      2|    iob->write_offset = 0;
   81|      2|    iob->read_buf = iob->start_buf;
   82|      2|    iob->read_ptr = iob->read_buf->buf;
   83|      2|    iob->read_offset = 0;
   84|      2|    return 1;
   85|      2|}
R_IoBufferInit:
  103|      2|{
  104|      2|    if (iob == NULL) return 0;
  ------------------
  |  Branch (104:9): [True: 0, False: 2]
  ------------------
  105|      2|    iob->start_buf = (BufferListItem*)malloc(sizeof(BufferListItem));
  106|      2|    if (iob->start_buf == NULL) return 0;
  ------------------
  |  Branch (106:9): [True: 0, False: 2]
  ------------------
  107|      2|    iob->start_buf->next = NULL;
  108|      2|    return R_IoBufferWriteReset(iob);
  109|      2|}
R_TextBufferInit:
  200|     32|{
  201|     32|    int i, k, l, n;
  202|     32|    if (isString(text)) {
  ------------------
  |  |  966|     32|#define isString		Rf_isString
  ------------------
  |  Branch (202:9): [True: 32, False: 0]
  ------------------
  203|       |	// translateChar might allocate
  204|     32|	void *vmax = vmaxget();
  205|     32|	n = length(text);
  ------------------
  |  |  987|     32|#define length(x)		Rf_length(x)
  ------------------
  206|     32|	l = 0;
  207|     64|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (207:14): [True: 32, False: 32]
  ------------------
  208|     32|	    if (STRING_ELT(text, i) != R_NilValue) {
  ------------------
  |  Branch (208:10): [True: 32, False: 0]
  ------------------
  209|     32|		k = (int) strlen(translateCharWithOverride(STRING_ELT(text, i)));
  210|     32|		if (k > l)
  ------------------
  |  Branch (210:7): [True: 32, False: 0]
  ------------------
  211|     32|		    l = k;
  212|     32|	    }
  213|     32|	}
  214|     32|	vmaxset(vmax);
  215|     32|	txtb->vmax = vmax;
  216|     32|	txtb->buf = (unsigned char *)R_alloc(l+2, sizeof(char)); /* '\n' and '\0' */
  217|     32|	txtb->bufp = txtb->buf;
  218|     32|	txtb->text = text;
  219|     32|	txtb->ntext = n;
  220|     32|	txtb->offset = 0;
  221|     32|	transferChars(txtb->buf,
  222|     32|		      translateCharWithOverride(STRING_ELT(txtb->text, txtb->offset)));
  223|     32|	txtb->offset++;
  224|     32|	return 1;
  225|     32|    }
  226|      0|    else {
  227|      0|	txtb->vmax = vmaxget();
  228|      0|	txtb->buf = NULL;
  229|       |	txtb->bufp = NULL;
  230|      0|	txtb->text = R_NilValue;
  231|      0|	txtb->ntext = 0;
  232|      0|	txtb->offset = 1;
  233|      0|	return 0;
  234|      0|    }
  235|     32|}
R_TextBufferFree:
  240|     32|{
  241|     32|    vmaxset(txtb->vmax);
  242|     32|    return 0;/* not used */
  243|     32|}
R_TextBufferGetc:
  248|  6.17k|{
  249|  6.17k|    if (txtb->buf == NULL)
  ------------------
  |  Branch (249:9): [True: 0, False: 6.17k]
  ------------------
  250|      0|	return EOF;
  251|  6.17k|    if (*(txtb->bufp) == '\0') {
  ------------------
  |  Branch (251:9): [True: 32, False: 6.13k]
  ------------------
  252|     32|	if (txtb->offset == txtb->ntext) {
  ------------------
  |  Branch (252:6): [True: 32, False: 0]
  ------------------
  253|     32|	    txtb->buf = NULL;
  254|     32|	    return EOF;
  255|     32|	} else {
  256|      0|	    const void *vmax = vmaxget();
  257|      0|	    transferChars(txtb->buf,
  258|      0|			  translateCharWithOverride(STRING_ELT(txtb->text,
  259|      0|			                                       txtb->offset)));
  260|      0|	    txtb->bufp = txtb->buf;
  261|      0|	    txtb->offset++;
  262|      0|	    vmaxset(vmax);
  263|      0|	}
  264|     32|    }
  265|  6.13k|    return *txtb->bufp++;
  266|  6.17k|}
iosupport.c:translateCharWithOverride:
  189|     64|{
  190|     64|    if (!IS_LATIN1(x) && !mbcslocale && known_to_be_utf8)
  ------------------
  |  Branch (190:9): [True: 64, False: 0]
  |  Branch (190:26): [True: 64, False: 0]
  |  Branch (190:41): [True: 0, False: 64]
  ------------------
  191|       |	/* A hack to allow UTF-8 string literals, comments when
  192|       |	   parsing on Windows. Note that the parser cannot handle
  193|       |	   invalid characters when running in UTF-8 locale. */
  194|      0|	return CHAR(x);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  195|     64|    else
  196|     64|	return translateChar(x);
  ------------------
  |  | 1037|     64|#define translateChar		Rf_translateChar
  ------------------
  197|     64|}
iosupport.c:transferChars:
  181|     32|{
  182|  6.13k|    while (*q) *p++ = *q++;
  ------------------
  |  Branch (182:12): [True: 6.10k, False: 32]
  ------------------
  183|     32|    *p++ = '\n';
  184|     32|    *p++ = '\0';
  185|     32|}

do_logic:
   42|   790k|{
   43|   790k|    SEXP arg1 = CAR(args); //, arg2 = CADR(args)
   44|   790k|    Rboolean attr1 = ATTRIB(arg1) != R_NilValue;
   45|   790k|    if (attr1 || ATTRIB(CADR(args)) != R_NilValue) {
  ------------------
  |  Branch (45:9): [True: 506, False: 790k]
  |  Branch (45:18): [True: 0, False: 790k]
  ------------------
   46|    506|	SEXP ans;
   47|    506|	if (DispatchGroup("Ops", call, op, args, env, &ans))
  ------------------
  |  | 1886|    506|# define DispatchGroup		Rf_DispatchGroup
  ------------------
  |  Branch (47:6): [True: 0, False: 506]
  ------------------
   48|      0|	    return ans;
   49|    506|    }
   50|       |    /* The above did dispatch to valid S3/S4 methods, including those with
   51|       |     * "wrong" number of arguments.
   52|       |     * Now require binary calls to `&` and `|`  or unary calls to `!` : */
   53|   790k|    checkArity(op, args);
  ------------------
  |  | 1788|   790k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
   54|       |
   55|   790k|    if (CDR(args) == R_NilValue) { // one argument  <==>  !(arg1)
  ------------------
  |  Branch (55:9): [True: 790k, False: 44]
  ------------------
   56|   790k|	if (!attr1 && IS_SCALAR(arg1, LGLSXP)) {
  ------------------
  |  |  121|   790k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (56:6): [True: 790k, False: 504]
  |  Branch (56:16): [True: 789k, False: 244]
  ------------------
   57|       |	    /* directly handle '!' operator for simple logical scalars. */
   58|   789k|	    int v = SCALAR_LVAL(arg1);
   59|   789k|	    return ScalarLogical(v == NA_LOGICAL ? v : ! v);
  ------------------
  |  | 1023|   789k|#define ScalarLogical		Rf_ScalarLogical
  ------------------
              	    return ScalarLogical(v == NA_LOGICAL ? v : ! v);
  ------------------
  |  |   55|   789k|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (59:27): [True: 2, False: 789k]
  ------------------
   60|   789k|	}
   61|    748|	return lunary(call, op, arg1);
   62|   790k|    }
   63|       |    // else : two arguments
   64|     44|    return lbinary(call, op, args);
   65|   790k|}
do_logic2:
  270|    136|{
  271|       |/*  &&	and  ||	 */
  272|    136|    SEXP s1, s2;
  273|    136|    int x1, x2;
  274|    136|    int ans = FALSE;
  275|       |
  276|    136|    if (length(args) != 2)
  ------------------
  |  |  987|    136|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (276:9): [True: 0, False: 136]
  ------------------
  277|      0|	error(_("'%s' operator requires 2 arguments"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'%s' operator requires 2 arguments"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  278|      0|	      PRIMVAL(op) == 1 ? "&&" : "||");
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (278:8): [True: 0, False: 0]
  ------------------
  279|       |
  280|    136|    s1 = CAR(args);
  281|    136|    s2 = CADR(args);
  282|    136|    PROTECT(s1 = eval(s1, env));
  ------------------
  |  |  357|    136|#define PROTECT(s)	Rf_protect(s)
  ------------------
  283|    136|    if (!isNumber(s1))
  ------------------
  |  |  958|    136|#define isNumber		Rf_isNumber
  ------------------
  |  Branch (283:9): [True: 0, False: 136]
  ------------------
  284|      0|	errorcall(call, _("invalid 'x' type in 'x %s y'"),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid 'x' type in 'x %s y'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  285|      0|		  PRIMVAL(op) == 1 ? "&&" : "||");
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (285:5): [True: 0, False: 0]
  ------------------
  286|       |
  287|    136|    x1 = asLogical2(s1, /*checking*/ 1, call);
  ------------------
  |  |  887|    136|#define asLogical2		Rf_asLogical2
  ------------------
  288|    136|    UNPROTECT(1); /* s1 */
  ------------------
  |  |  358|    136|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  289|       |
  290|    136|#define get_2nd							\
  291|    136|	PROTECT(s2 = eval(s2, env));				\
  292|    136|	if (!isNumber(s2))					\
  293|    136|	    errorcall(call, _("invalid 'y' type in 'x %s y'"),	\
  294|    136|		      PRIMVAL(op) == 1 ? "&&" : "||");		\
  295|    136|	x2 = asLogical2(s2, 1, call);			\
  296|    136|	UNPROTECT(1); /* s2 */
  297|       |
  298|    136|    switch (PRIMVAL(op)) {
  ------------------
  |  | 1347|    136|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (1347:20): [True: 136, False: 0]
  |  |  ------------------
  ------------------
  299|     16|    case 1: /* && */
  ------------------
  |  Branch (299:5): [True: 16, False: 120]
  ------------------
  300|     16|	if (x1 == FALSE)
  ------------------
  |  Branch (300:6): [True: 16, False: 0]
  ------------------
  301|     16|	    ans = FALSE;
  302|      0|	else {
  303|      0|	    get_2nd;
  ------------------
  |  |  291|      0|	PROTECT(s2 = eval(s2, env));				\
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  292|      0|	if (!isNumber(s2))					\
  |  |  ------------------
  |  |  |  |  958|      0|#define isNumber		Rf_isNumber
  |  |  ------------------
  |  |  |  Branch (292:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  293|      0|	    errorcall(call, _("invalid 'y' type in 'x %s y'"),	\
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |               	    errorcall(call, _("invalid 'y' type in 'x %s y'"),	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  294|      0|		      PRIMVAL(op) == 1 ? "&&" : "||");		\
  |  |  ------------------
  |  |  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (294:9): [True: 0, False: 0]
  |  |  ------------------
  |  |  295|      0|	x2 = asLogical2(s2, 1, call);			\
  |  |  ------------------
  |  |  |  |  887|      0|#define asLogical2		Rf_asLogical2
  |  |  ------------------
  |  |  296|      0|	UNPROTECT(1); /* s2 */
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  ------------------
  304|      0|	    if (x1 == NA_LOGICAL)
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (304:10): [True: 0, False: 0]
  ------------------
  305|      0|		ans = (x2 == NA_LOGICAL || x2) ? NA_LOGICAL : x2;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
              		ans = (x2 == NA_LOGICAL || x2) ? NA_LOGICAL : x2;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (305:10): [True: 0, False: 0]
  |  Branch (305:30): [True: 0, False: 0]
  ------------------
  306|      0|	    else /* x1 == TRUE */
  307|      0|		ans = x2;
  308|      0|	}
  309|     16|	break;
  310|    120|    case 2: /* || */
  ------------------
  |  Branch (310:5): [True: 120, False: 16]
  ------------------
  311|    120|	if (x1 == TRUE)
  ------------------
  |  Branch (311:6): [True: 0, False: 120]
  ------------------
  312|      0|	    ans = TRUE;
  313|    120|	else {
  314|    120|	    get_2nd;
  ------------------
  |  |  291|    120|	PROTECT(s2 = eval(s2, env));				\
  |  |  ------------------
  |  |  |  |  357|    120|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  292|    120|	if (!isNumber(s2))					\
  |  |  ------------------
  |  |  |  |  958|    120|#define isNumber		Rf_isNumber
  |  |  ------------------
  |  |  |  Branch (292:6): [True: 0, False: 120]
  |  |  ------------------
  |  |  293|    120|	    errorcall(call, _("invalid 'y' type in 'x %s y'"),	\
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |               	    errorcall(call, _("invalid 'y' type in 'x %s y'"),	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  294|      0|		      PRIMVAL(op) == 1 ? "&&" : "||");		\
  |  |  ------------------
  |  |  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  |  |  ------------------
  |  |  |  Branch (294:9): [True: 0, False: 0]
  |  |  ------------------
  |  |  295|    120|	x2 = asLogical2(s2, 1, call);			\
  |  |  ------------------
  |  |  |  |  887|    120|#define asLogical2		Rf_asLogical2
  |  |  ------------------
  |  |  296|    120|	UNPROTECT(1); /* s2 */
  |  |  ------------------
  |  |  |  |  358|    120|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  ------------------
  315|    120|	    if (x1 == NA_LOGICAL)
  ------------------
  |  |   55|    120|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (315:10): [True: 0, False: 120]
  ------------------
  316|      0|		ans = (x2 == NA_LOGICAL || !x2) ? NA_LOGICAL : x2;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
              		ans = (x2 == NA_LOGICAL || !x2) ? NA_LOGICAL : x2;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (316:10): [True: 0, False: 0]
  |  Branch (316:30): [True: 0, False: 0]
  ------------------
  317|    120|	    else /* x1 == FALSE */
  318|    120|		ans = x2;
  319|    120|	}
  320|    136|    }
  321|    136|    return ScalarLogical(ans);
  ------------------
  |  | 1023|    136|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  322|    136|}
do_logic3:
  444|  1.54M|{
  445|  1.54M|    SEXP ans, s, t, call2;
  446|  1.54M|    int narm, has_na = 0;
  447|       |    /* initialize for behavior on empty vector
  448|       |       all(logical(0)) -> TRUE
  449|       |       any(logical(0)) -> FALSE
  450|       |     */
  451|  1.54M|    int val = PRIMVAL(op) == _OP_ALL ? TRUE : FALSE;
  ------------------
  |  | 1347|  1.54M|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
                  int val = PRIMVAL(op) == _OP_ALL ? TRUE : FALSE;
  ------------------
  |  |  414|  1.54M|#define _OP_ALL 1
  ------------------
  |  Branch (451:15): [True: 1.08k, False: 1.54M]
  ------------------
  452|       |
  453|  1.54M|    PROTECT(args = fixup_NaRm(args));
  ------------------
  |  |  357|  1.54M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  454|  1.54M|    PROTECT(call2 = shallow_duplicate(call));
  ------------------
  |  |  357|  1.54M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  455|  1.54M|    R_args_enable_refcnt(args);
  456|  1.54M|    SETCDR(call2, args);
  457|       |
  458|  1.54M|    if (DispatchGroup("Summary", call2, op, args, env, &ans)) {
  ------------------
  |  | 1886|  1.54M|# define DispatchGroup		Rf_DispatchGroup
  ------------------
  |  Branch (458:9): [True: 0, False: 1.54M]
  ------------------
  459|      0|	UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  460|      0|	SETCDR(call2, R_NilValue); /* clear refcnt on args */
  461|      0|	R_try_clear_args_refcnt(args);
  462|      0|	return(ans);
  463|      0|    }
  464|  1.54M|    SETCDR(call2, R_NilValue); /* clear refcnt on args */
  465|  1.54M|    R_try_clear_args_refcnt(args);
  466|       |
  467|  1.54M|    ans = matchArgExact(R_NaRmSymbol, &args);
  ------------------
  |  | 1945|  1.54M|# define matchArgExact		Rf_matchArgExact
  ------------------
  468|  1.54M|    narm = asLogical2(ans, /*warn_level*/ 1, call);
  ------------------
  |  |  887|  1.54M|#define asLogical2		Rf_asLogical2
  ------------------
  469|       |
  470|  3.08M|    for (s = args; s != R_NilValue; s = CDR(s)) {
  ------------------
  |  Branch (470:20): [True: 1.54M, False: 1.54M]
  ------------------
  471|  1.54M|	t = CAR(s);
  472|       |	/* Avoid memory waste from coercing empty inputs, and also
  473|       |	   avoid warnings with empty lists coming from sapply */
  474|  1.54M|	if(xlength(t) == 0) continue;
  ------------------
  |  | 1049|  1.54M|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (474:5): [True: 74, False: 1.54M]
  ------------------
  475|       |	/* coerceVector protects its argument so this actually works
  476|       |	   just fine */
  477|  1.54M|	if (TYPEOF(t) != LGLSXP) {
  ------------------
  |  |  121|  1.54M|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (477:6): [True: 12, False: 1.54M]
  ------------------
  478|       |	    /* Coercion of integers seems reasonably safe, but for
  479|       |	       other types it is more often than not an error.
  480|       |	       One exception is perhaps the result of lapply, but
  481|       |	       then sapply was often what was intended. */
  482|     12|	    if(TYPEOF(t) != INTSXP)
  ------------------
  |  |  123|     12|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (482:9): [True: 0, False: 12]
  ------------------
  483|      0|		warningcall(call,
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
  484|      0|			    _("coercing argument of type '%s' to logical"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  485|      0|			    R_typeToChar(t));
  486|     12|	    t = coerceVector(t, LGLSXP);
  ------------------
  |  |  895|     12|#define coerceVector		Rf_coerceVector
  ------------------
              	    t = coerceVector(t, LGLSXP);
  ------------------
  |  |  121|     12|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  487|     12|	}
  488|  1.54M|	val = checkValues(PRIMVAL(op), narm, t, XLENGTH(t));
  ------------------
  |  | 1347|  1.54M|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  489|  1.54M|	if (val != NA_LOGICAL) {
  ------------------
  |  |   55|  1.54M|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (489:6): [True: 1.54M, False: 0]
  ------------------
  490|  1.54M|	    if ((PRIMVAL(op) == _OP_ANY && val)
  ------------------
  |  | 1347|  1.54M|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
              	    if ((PRIMVAL(op) == _OP_ANY && val)
  ------------------
  |  |  415|  3.08M|#define _OP_ANY 2
  ------------------
  |  Branch (490:11): [True: 1.54M, False: 1.06k]
  |  Branch (490:37): [True: 34, False: 1.54M]
  ------------------
  491|  1.54M|		|| (PRIMVAL(op) == _OP_ALL && !val)) {
  ------------------
  |  | 1347|  1.54M|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
              		|| (PRIMVAL(op) == _OP_ALL && !val)) {
  ------------------
  |  |  414|  3.08M|#define _OP_ALL 1
  ------------------
  |  Branch (491:7): [True: 1.06k, False: 1.54M]
  |  Branch (491:33): [True: 30, False: 1.03k]
  ------------------
  492|     64|		has_na = 0;
  493|     64|		break;
  494|     64|	    }
  495|  1.54M|	} else has_na = 1;
  496|  1.54M|    }
  497|  1.54M|    UNPROTECT(2);
  ------------------
  |  |  358|  1.54M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  498|  1.54M|    return has_na ? ScalarLogical(NA_LOGICAL) : ScalarLogical(val);
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
                  return has_na ? ScalarLogical(NA_LOGICAL) : ScalarLogical(val);
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
                  return has_na ? ScalarLogical(NA_LOGICAL) : ScalarLogical(val);
  ------------------
  |  | 1023|  1.54M|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  |  Branch (498:12): [True: 0, False: 1.54M]
  ------------------
  499|  1.54M|}
logic.c:lbinary:
   69|     44|{
   70|       |/* logical binary : "&" or "|" */
   71|     44|    SEXP
   72|     44|	x = CAR(args),
   73|     44|	y = CADR(args);
   74|       |
   75|     44|    if (isRaw(x) && isRaw(y)) {
  ------------------
  |  |   67|     88|#define isRaw(x) (TYPEOF(x) == RAWSXP)
  |  |  ------------------
  |  |  |  |  136|     44|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (67:18): [True: 0, False: 44]
  |  |  ------------------
  ------------------
                  if (isRaw(x) && isRaw(y)) {
  ------------------
  |  |   67|      0|#define isRaw(x) (TYPEOF(x) == RAWSXP)
  |  |  ------------------
  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (67:18): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   76|      0|    }
   77|     44|    else if ( !(isNull(x) || isNumber(x)) ||
  ------------------
  |  |  956|     44|#define isNull			Rf_isNull
  ------------------
                  else if ( !(isNull(x) || isNumber(x)) ||
  ------------------
  |  |  958|     44|#define isNumber		Rf_isNumber
  ------------------
  |  Branch (77:17): [True: 0, False: 44]
  |  Branch (77:30): [True: 44, False: 0]
  ------------------
   78|     44|	      !(isNull(y) || isNumber(y)) )
  ------------------
  |  |  956|     44|#define isNull			Rf_isNull
  ------------------
              	      !(isNull(y) || isNumber(y)) )
  ------------------
  |  |  958|     44|#define isNumber		Rf_isNumber
  ------------------
  |  Branch (78:10): [True: 0, False: 44]
  |  Branch (78:23): [True: 44, False: 0]
  ------------------
   79|      0|	errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
   80|      0|		  _("operations are possible only for numeric, logical or complex types"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   81|       |
   82|     44|    R_xlen_t
   83|     44|	nx = xlength(x),
  ------------------
  |  | 1049|     44|#define xlength(x)		Rf_xlength(x)
  ------------------
   84|     44|	ny = xlength(y);
  ------------------
  |  | 1049|     44|#define xlength(x)		Rf_xlength(x)
  ------------------
   85|     44|    Rboolean
   86|     44|	xarray = isArray(x),
  ------------------
  |  |  940|     44|#define isArray			Rf_isArray
  ------------------
   87|     44|	yarray = isArray(y),
  ------------------
  |  |  940|     44|#define isArray			Rf_isArray
  ------------------
   88|     44|	xts = isTs(x),
  ------------------
  |  |  967|     44|#define isTs			Rf_isTs
  ------------------
   89|     44|	yts = isTs(y);
  ------------------
  |  |  967|     44|#define isTs			Rf_isTs
  ------------------
   90|     44|    SEXP dims, xnames, ynames;
   91|     44|    if (xarray || yarray) {
  ------------------
  |  Branch (91:9): [True: 0, False: 44]
  |  Branch (91:19): [True: 0, False: 44]
  ------------------
   92|      0|	if (xarray && yarray) {
  ------------------
  |  Branch (92:6): [True: 0, False: 0]
  |  Branch (92:16): [True: 0, False: 0]
  ------------------
   93|      0|	    if (!conformable(x, y))
  ------------------
  |  |  896|      0|#define conformable		Rf_conformable
  ------------------
  |  Branch (93:10): [True: 0, False: 0]
  ------------------
   94|      0|		errorcall(call, _("non-conformable arrays"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		errorcall(call, _("non-conformable arrays"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   95|      0|	    PROTECT(dims = getAttrib(x, R_DimSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
   96|      0|	}
   97|      0|	else if (xarray && (ny != 0 || nx == 0)) {
  ------------------
  |  Branch (97:11): [True: 0, False: 0]
  |  Branch (97:22): [True: 0, False: 0]
  |  Branch (97:33): [True: 0, False: 0]
  ------------------
   98|      0|	    PROTECT(dims = getAttrib(x, R_DimSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
   99|      0|	}
  100|      0|	else if (yarray && (nx != 0 || ny == 0)) {
  ------------------
  |  Branch (100:11): [True: 0, False: 0]
  |  Branch (100:22): [True: 0, False: 0]
  |  Branch (100:33): [True: 0, False: 0]
  ------------------
  101|      0|	    PROTECT(dims = getAttrib(y, R_DimSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  102|      0|	} else
  103|      0|	    PROTECT(dims = R_NilValue);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  104|       |
  105|      0|	PROTECT(xnames = getAttrib(x, R_DimNamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  106|      0|	PROTECT(ynames = getAttrib(y, R_DimNamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  107|      0|    }
  108|     44|    else {
  109|     44|	PROTECT(dims = R_NilValue);
  ------------------
  |  |  357|     44|#define PROTECT(s)	Rf_protect(s)
  ------------------
  110|     44|	PROTECT(xnames = getAttrib(x, R_NamesSymbol));
  ------------------
  |  |  357|     44|#define PROTECT(s)	Rf_protect(s)
  ------------------
  111|     44|	PROTECT(ynames = getAttrib(y, R_NamesSymbol));
  ------------------
  |  |  357|     44|#define PROTECT(s)	Rf_protect(s)
  ------------------
  112|     44|    }
  113|       |
  114|     44|    SEXP klass = NULL, tsp = NULL; // -Wall
  115|     44|    if (xts || yts) {
  ------------------
  |  Branch (115:9): [True: 0, False: 44]
  |  Branch (115:16): [True: 0, False: 44]
  ------------------
  116|      0|	if (xts && yts) {
  ------------------
  |  Branch (116:6): [True: 0, False: 0]
  |  Branch (116:13): [True: 0, False: 0]
  ------------------
  117|       |	    /* could check ts conformance here */
  118|      0|	    PROTECT(tsp = getAttrib(x, R_TspSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  119|      0|	    PROTECT(klass = getAttrib(x, R_ClassSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  120|      0|	}
  121|      0|	else if (xts) {
  ------------------
  |  Branch (121:11): [True: 0, False: 0]
  ------------------
  122|      0|	    if (nx < ny)
  ------------------
  |  Branch (122:10): [True: 0, False: 0]
  ------------------
  123|      0|		ErrorMessage(call, ERROR_TSVEC_MISMATCH);
  ------------------
  |  | 1897|      0|# define ErrorMessage		Rf_ErrorMessage
  ------------------
  124|      0|	    PROTECT(tsp = getAttrib(x, R_TspSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  125|      0|	    PROTECT(klass = getAttrib(x, R_ClassSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  126|      0|	}
  127|      0|	else /*(yts)*/ {
  128|      0|	    if (ny < nx)
  ------------------
  |  Branch (128:10): [True: 0, False: 0]
  ------------------
  129|      0|		ErrorMessage(call, ERROR_TSVEC_MISMATCH);
  ------------------
  |  | 1897|      0|# define ErrorMessage		Rf_ErrorMessage
  ------------------
  130|      0|	    PROTECT(tsp = getAttrib(y, R_TspSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  131|      0|	    PROTECT(klass = getAttrib(y, R_ClassSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  132|      0|	}
  133|      0|    }
  134|     44|    if (nx > 0 && ny > 0) {
  ------------------
  |  Branch (134:9): [True: 44, False: 0]
  |  Branch (134:19): [True: 44, False: 0]
  ------------------
  135|     44|	if(((nx > ny) ? nx % ny : ny % nx) != 0) // mismatch
  ------------------
  |  Branch (135:5): [True: 0, False: 44]
  |  Branch (135:6): [True: 0, False: 44]
  ------------------
  136|      0|	    warningcall(call,
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
  137|      0|			_("longer object length is not a multiple of shorter object length"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  138|       |
  139|     44|	if (isRaw(x) && isRaw(y)) {
  ------------------
  |  |   67|     88|#define isRaw(x) (TYPEOF(x) == RAWSXP)
  |  |  ------------------
  |  |  |  |  136|     44|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (67:18): [True: 0, False: 44]
  |  |  ------------------
  ------------------
              	if (isRaw(x) && isRaw(y)) {
  ------------------
  |  |   67|      0|#define isRaw(x) (TYPEOF(x) == RAWSXP)
  |  |  ------------------
  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (67:18): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  140|      0|	    x = binaryLogic2(PRIMVAL(op), x, y);
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  141|      0|	}
  142|     44|	else {
  143|     44|	    if(isNull(x))
  ------------------
  |  |  956|     44|#define isNull			Rf_isNull
  ------------------
  |  Branch (143:9): [True: 0, False: 44]
  ------------------
  144|      0|		x = SETCAR(args, allocVector(LGLSXP, 0));
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              		x = SETCAR(args, allocVector(LGLSXP, 0));
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  145|     44|	    else // isNumeric(x)
  146|     44|		x = SETCAR(args, coerceVector(x, LGLSXP));
  ------------------
  |  |  895|     44|#define coerceVector		Rf_coerceVector
  ------------------
              		x = SETCAR(args, coerceVector(x, LGLSXP));
  ------------------
  |  |  121|     44|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  147|     44|	    if(isNull(y))
  ------------------
  |  |  956|     44|#define isNull			Rf_isNull
  ------------------
  |  Branch (147:9): [True: 0, False: 44]
  ------------------
  148|      0|		y = SETCAR(args, allocVector(LGLSXP, 0));
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              		y = SETCAR(args, allocVector(LGLSXP, 0));
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  149|     44|	    else // isNumeric(y)
  150|     44|		y = SETCADR(args, coerceVector(y, LGLSXP));
  ------------------
  |  |  895|     44|#define coerceVector		Rf_coerceVector
  ------------------
              		y = SETCADR(args, coerceVector(y, LGLSXP));
  ------------------
  |  |  121|     44|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  151|     44|	    x = binaryLogic(PRIMVAL(op), x, y);
  ------------------
  |  | 1347|     44|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  152|     44|	}
  153|     44|    } else { // nx == 0 || ny == 0
  154|      0|	x = allocVector((isRaw(x) && isRaw(y)) ? RAWSXP : LGLSXP, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	x = allocVector((isRaw(x) && isRaw(y)) ? RAWSXP : LGLSXP, 0);
  ------------------
  |  |   67|      0|#define isRaw(x) (TYPEOF(x) == RAWSXP)
  |  |  ------------------
  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (67:18): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	x = allocVector((isRaw(x) && isRaw(y)) ? RAWSXP : LGLSXP, 0);
  ------------------
  |  |   67|      0|#define isRaw(x) (TYPEOF(x) == RAWSXP)
  |  |  ------------------
  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (67:18): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	x = allocVector((isRaw(x) && isRaw(y)) ? RAWSXP : LGLSXP, 0);
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
              	x = allocVector((isRaw(x) && isRaw(y)) ? RAWSXP : LGLSXP, 0);
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  155|      0|    }
  156|       |
  157|     44|    PROTECT(x);
  ------------------
  |  |  357|     44|#define PROTECT(s)	Rf_protect(s)
  ------------------
  158|     44|    if (dims != R_NilValue) {
  ------------------
  |  Branch (158:9): [True: 0, False: 44]
  ------------------
  159|      0|	setAttrib(x, R_DimSymbol, dims);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  160|      0|	if(xnames != R_NilValue)
  ------------------
  |  Branch (160:5): [True: 0, False: 0]
  ------------------
  161|      0|	    setAttrib(x, R_DimNamesSymbol, xnames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  162|      0|	else if(ynames != R_NilValue)
  ------------------
  |  Branch (162:10): [True: 0, False: 0]
  ------------------
  163|      0|	    setAttrib(x, R_DimNamesSymbol, ynames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  164|      0|    }
  165|     44|    else {
  166|     44|	if(xnames != R_NilValue && XLENGTH(x) == XLENGTH(xnames))
  ------------------
  |  Branch (166:5): [True: 2, False: 42]
  |  Branch (166:29): [True: 2, False: 0]
  ------------------
  167|      2|	    setAttrib(x, R_NamesSymbol, xnames);
  ------------------
  |  | 1027|      2|#define setAttrib		Rf_setAttrib
  ------------------
  168|     42|	else if(ynames != R_NilValue && XLENGTH(x) == XLENGTH(ynames))
  ------------------
  |  Branch (168:10): [True: 0, False: 42]
  |  Branch (168:34): [True: 0, False: 0]
  ------------------
  169|      0|	    setAttrib(x, R_NamesSymbol, ynames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  170|     44|    }
  171|       |
  172|     44|    if (xts || yts) {
  ------------------
  |  Branch (172:9): [True: 0, False: 44]
  |  Branch (172:16): [True: 0, False: 44]
  ------------------
  173|      0|	setAttrib(x, R_TspSymbol, tsp);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  174|      0|	setAttrib(x, R_ClassSymbol, klass);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  175|      0|	UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  176|      0|    }
  177|     44|    UNPROTECT(4);
  ------------------
  |  |  358|     44|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  178|     44|    return x;
  179|     44|}
logic.c:binaryLogic:
  325|     44|{
  326|     44|    R_xlen_t i, n, n1, n2, i1, i2;
  327|     44|    int x1, x2;
  328|     44|    SEXP ans;
  329|       |
  330|     44|    n1 = XLENGTH(s1);
  331|     44|    n2 = XLENGTH(s2);
  332|     44|    n = (n1 > n2) ? n1 : n2;
  ------------------
  |  Branch (332:9): [True: 0, False: 44]
  ------------------
  333|     44|    if (n1 == 0 || n2 == 0) {
  ------------------
  |  Branch (333:9): [True: 0, False: 44]
  |  Branch (333:20): [True: 0, False: 44]
  ------------------
  334|      0|	ans = allocVector(LGLSXP, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	ans = allocVector(LGLSXP, 0);
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  335|      0|	return ans;
  336|      0|    }
  337|     44|    ans = allocVector(LGLSXP, n);
  ------------------
  |  |  875|     44|#define allocVector		Rf_allocVector
  ------------------
                  ans = allocVector(LGLSXP, n);
  ------------------
  |  |  121|     44|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  338|       |
  339|     44|    int *px1 = LOGICAL(s1);
  340|     44|    int *px2 = LOGICAL(s2);
  341|     44|    int *pa = LOGICAL(ans);
  342|       |
  343|     44|    switch (code) {
  ------------------
  |  Branch (343:13): [True: 44, False: 0]
  ------------------
  344|      4|    case 1:		/* & : AND */
  ------------------
  |  Branch (344:5): [True: 4, False: 40]
  ------------------
  345|      4|	MOD_ITERATE2(n, n1, n2, i, i1, i2, {
  ------------------
  |  |   87|      4|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   88|      4|	i = i1 = i2 = 0;					\
  |  |   89|      4|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  ------------------
  |  |  |  |   78|      4|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |   79|     20|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (79:9): [True: 16, False: 4]
  |  |  |  |  ------------------
  |  |  |  |   80|     16|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:12): [True: 4, False: 12]
  |  |  |  |  ------------------
  |  |  |  |   81|     16|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (81:9): [True: 4, False: 12]
  |  |  |  |  ------------------
  |  |  |  |   82|     16|		 ++i) {							\
  |  |  |  |   83|     62|	    loop_body							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (83:6): [True: 2, False: 14]
  |  |  |  |  |  Branch (83:6): [True: 14, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   84|     16|		}							\
  |  |  |  |   85|      4|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:14): [Folded, False: 4]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      4|    } while (0)
  |  |  ------------------
  |  |  |  Branch (90:14): [Folded, False: 4]
  |  |  ------------------
  ------------------
  346|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  347|      4|	    x1 = px1[i1];
  348|      4|	    x2 = px2[i2];
  349|      4|	    if (x1 == 0 || x2 == 0)
  350|      4|		pa[i] = 0;
  351|      4|	    else if (x1 == NA_LOGICAL || x2 == NA_LOGICAL)
  352|      4|		pa[i] = NA_LOGICAL;
  353|      4|	    else
  354|      4|		pa[i] = 1;
  355|      4|	});
  356|      4|	break;
  357|     40|    case 2:		/* | : OR */
  ------------------
  |  Branch (357:5): [True: 40, False: 4]
  ------------------
  358|     40|	MOD_ITERATE2(n, n1, n2, i, i1, i2, {
  ------------------
  |  |   87|     40|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   88|     40|	i = i1 = i2 = 0;					\
  |  |   89|     40|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  ------------------
  |  |  |  |   78|     40|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |   79|     80|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (79:9): [True: 40, False: 40]
  |  |  |  |  ------------------
  |  |  |  |   80|     40|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:12): [True: 40, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   81|     40|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (81:9): [True: 40, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   82|     40|		 ++i) {							\
  |  |  |  |   83|    200|	    loop_body							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (83:6): [True: 40, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 40, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   84|     40|		}							\
  |  |  |  |   85|     40|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:14): [Folded, False: 40]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|     40|    } while (0)
  |  |  ------------------
  |  |  |  Branch (90:14): [Folded, False: 40]
  |  |  ------------------
  ------------------
  359|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  360|     40|	    x1 = px1[i1];
  361|     40|	    x2 = px2[i2];
  362|     40|	    if ((x1 != NA_LOGICAL && x1) || (x2 != NA_LOGICAL && x2))
  363|     40|		pa[i] = 1;
  364|     40|	    else if (x1 == 0 && x2 == 0)
  365|     40|		pa[i] = 0;
  366|     40|	    else
  367|     40|		pa[i] = NA_LOGICAL;
  368|     40|	});
  369|     40|	break;
  370|      0|    case 3:
  ------------------
  |  Branch (370:5): [True: 0, False: 44]
  ------------------
  371|      0|	error(_("Unary operator `!' called with two arguments"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("Unary operator `!' called with two arguments"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  372|      0|	break;
  373|     44|    }
  374|     44|    return ans;
  375|     44|}
logic.c:lunary:
  182|    748|{
  183|    748|    SEXP x, dim, dimnames, names;
  184|    748|    R_xlen_t i, len;
  185|       |
  186|    748|    len = XLENGTH(arg);
  187|    748|    if (!isLogical(arg) && !isNumber(arg) && !isRaw(arg)) {
  ------------------
  |  |  952|    748|#define isLogical		Rf_isLogical
  ------------------
                  if (!isLogical(arg) && !isNumber(arg) && !isRaw(arg)) {
  ------------------
  |  |  958|    170|#define isNumber		Rf_isNumber
  ------------------
                  if (!isLogical(arg) && !isNumber(arg) && !isRaw(arg)) {
  ------------------
  |  |   67|      0|#define isRaw(x) (TYPEOF(x) == RAWSXP)
  |  |  ------------------
  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  ------------------
  |  Branch (187:9): [True: 170, False: 578]
  |  Branch (187:28): [True: 0, False: 170]
  |  Branch (187:46): [True: 0, False: 0]
  ------------------
  188|       |	/* For back-compatibility */
  189|      0|	if (!len) return allocVector(LGLSXP, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	if (!len) return allocVector(LGLSXP, 0);
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (189:6): [True: 0, False: 0]
  ------------------
  190|      0|	errorcall(call, _("invalid argument type"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid argument type"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  191|      0|    }
  192|    748|    if (isLogical(arg) || isRaw(arg))
  ------------------
  |  |  952|    748|#define isLogical		Rf_isLogical
  ------------------
                  if (isLogical(arg) || isRaw(arg))
  ------------------
  |  |   67|    170|#define isRaw(x) (TYPEOF(x) == RAWSXP)
  |  |  ------------------
  |  |  |  |  136|    170|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (67:18): [True: 0, False: 170]
  |  |  ------------------
  ------------------
  |  Branch (192:9): [True: 578, False: 170]
  ------------------
  193|       |	// copy all attributes in this case
  194|    578|	x = PROTECT(shallow_duplicate(arg));
  ------------------
  |  |  357|    578|#define PROTECT(s)	Rf_protect(s)
  ------------------
  195|    170|    else {
  196|    170|	x = PROTECT(allocVector(isRaw(arg) ? RAWSXP : LGLSXP, len));
  ------------------
  |  |  357|    340|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  |  Branch (357:31): [True: 0, False: 170]
  |  |  ------------------
  ------------------
  197|    170|	PROTECT(names = getAttrib(arg, R_NamesSymbol));
  ------------------
  |  |  357|    170|#define PROTECT(s)	Rf_protect(s)
  ------------------
  198|    170|	PROTECT(dim = getAttrib(arg, R_DimSymbol));
  ------------------
  |  |  357|    170|#define PROTECT(s)	Rf_protect(s)
  ------------------
  199|    170|	PROTECT(dimnames = getAttrib(arg, R_DimNamesSymbol));
  ------------------
  |  |  357|    170|#define PROTECT(s)	Rf_protect(s)
  ------------------
  200|    170|	if(names != R_NilValue) setAttrib(x, R_NamesSymbol, names);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  |  Branch (200:5): [True: 0, False: 170]
  ------------------
  201|    170|	if(dim != R_NilValue) setAttrib(x, R_DimSymbol, dim);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  |  Branch (201:5): [True: 0, False: 170]
  ------------------
  202|    170|	if(dimnames != R_NilValue) setAttrib(x, R_DimNamesSymbol, dimnames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  |  Branch (202:5): [True: 0, False: 170]
  ------------------
  203|    170|	UNPROTECT(3);
  ------------------
  |  |  358|    170|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  204|    170|    }
  205|    748|    switch(TYPEOF(arg)) {
  206|    578|    case LGLSXP:
  ------------------
  |  |  121|    578|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (206:5): [True: 578, False: 170]
  ------------------
  207|    578|	{
  208|    578|	    int *px = LOGICAL(x);
  209|    578|	    const int *parg = LOGICAL_RO(arg);
  210|  9.92k|	    for (i = 0; i < len; i++) {
  ------------------
  |  Branch (210:18): [True: 9.34k, False: 578]
  ------------------
  211|       |//	        if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  212|  9.34k|		int v = parg[i];
  213|  9.34k|		px[i] = (v == NA_LOGICAL) ? NA_LOGICAL : v == 0;
  ------------------
  |  |   55|  9.34k|#define NA_LOGICAL	R_NaInt
  ------------------
              		px[i] = (v == NA_LOGICAL) ? NA_LOGICAL : v == 0;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (213:11): [True: 0, False: 9.34k]
  ------------------
  214|  9.34k|	    }
  215|    578|	}
  216|    578|	break;
  217|    170|    case INTSXP:
  ------------------
  |  |  123|    170|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (217:5): [True: 170, False: 578]
  ------------------
  218|    170|	{
  219|    170|	    int *px = LOGICAL(x);
  220|    170|	    const int *parg = INTEGER_RO(arg);
  221|    340|	    for (i = 0; i < len; i++) {
  ------------------
  |  Branch (221:18): [True: 170, False: 170]
  ------------------
  222|       |//	        if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  223|    170|		int v = parg[i];
  224|    170|		px[i] = (v == NA_INTEGER) ? NA_LOGICAL : v == 0;
  ------------------
  |  |   56|    170|#define NA_INTEGER	R_NaInt
  ------------------
              		px[i] = (v == NA_INTEGER) ? NA_LOGICAL : v == 0;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (224:11): [True: 0, False: 170]
  ------------------
  225|    170|	    }
  226|    170|	}
  227|    170|	break;
  228|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (228:5): [True: 0, False: 748]
  ------------------
  229|      0|	{
  230|      0|	    int *px = LOGICAL(x);
  231|      0|	    const double *parg = REAL_RO(arg);
  232|      0|	    for (i = 0; i < len; i++){
  ------------------
  |  Branch (232:18): [True: 0, False: 0]
  ------------------
  233|       |//	        if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  234|      0|		double v = parg[i];
  235|      0|		px[i] = ISNAN(v) ? NA_LOGICAL : v == 0;
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              		px[i] = ISNAN(v) ? NA_LOGICAL : v == 0;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  236|      0|	    }
  237|      0|	}
  238|      0|	break;
  239|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (239:5): [True: 0, False: 748]
  ------------------
  240|      0|	{
  241|      0|	    int *px = LOGICAL(x);
  242|      0|	    const Rcomplex *parg = COMPLEX_RO(arg);
  243|      0|	    for (i = 0; i < len; i++) {
  ------------------
  |  Branch (243:18): [True: 0, False: 0]
  ------------------
  244|       |//	        if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  245|      0|		Rcomplex v = parg[i];
  246|      0|		px[i] = (ISNAN(v.r) || ISNAN(v.i))
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              		px[i] = (ISNAN(v.r) || ISNAN(v.i))
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  247|      0|		    ? NA_LOGICAL : (v.r == 0. && v.i == 0.);
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (247:23): [True: 0, False: 0]
  |  Branch (247:36): [True: 0, False: 0]
  ------------------
  248|      0|	    }
  249|      0|	}
  250|      0|	break;
  251|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (251:5): [True: 0, False: 748]
  ------------------
  252|      0|	{
  253|      0|	    Rbyte *px = RAW(x);
  254|      0|	    const Rbyte *parg = RAW_RO(arg);
  255|      0|	    for (i = 0; i < len; i++) {
  ------------------
  |  Branch (255:18): [True: 0, False: 0]
  ------------------
  256|       |//	        if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  257|      0|		px[i] = 0xFF ^ parg[i];
  258|      0|	    }
  259|      0|	}
  260|      0|	break;
  261|      0|    default:
  ------------------
  |  Branch (261:5): [True: 0, False: 748]
  ------------------
  262|      0|	UNIMPLEMENTED_TYPE("lunary", arg);
  263|    748|    }
  264|    748|    UNPROTECT(1);
  ------------------
  |  |  358|    748|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  265|    748|    return x;
  266|    748|}
logic.c:checkValues:
  418|  1.54M|{
  419|  1.54M|    R_xlen_t i;
  420|  1.54M|    int has_na = 0;
  421|  1.54M|    int *px = LOGICAL(x);
  422|  3.90M|    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (422:17): [True: 2.36M, False: 1.54M]
  ------------------
  423|       |//	if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  424|  2.36M|	int xi = px[i];
  425|  2.36M|	if (!na_rm && xi == NA_LOGICAL) has_na = 1;
  ------------------
  |  |   55|  2.36M|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (425:6): [True: 2.36M, False: 0]
  |  Branch (425:16): [True: 0, False: 2.36M]
  ------------------
  426|  2.36M|	else {
  427|  2.36M|	    if (xi == TRUE && op == _OP_ANY) return TRUE;
  ------------------
  |  |  415|  4.13k|#define _OP_ANY 2
  ------------------
  |  Branch (427:10): [True: 4.13k, False: 2.35M]
  |  Branch (427:24): [True: 34, False: 4.10k]
  ------------------
  428|  2.36M|	    if (xi == FALSE && op == _OP_ALL) return FALSE;
  ------------------
  |  |  414|  2.35M|#define _OP_ALL 1
  ------------------
  |  Branch (428:10): [True: 2.35M, False: 4.10k]
  |  Branch (428:25): [True: 30, False: 2.35M]
  ------------------
  429|  2.36M|	}
  430|  2.36M|    }
  431|  1.54M|    switch (op) {
  432|  1.54M|    case _OP_ANY:
  ------------------
  |  |  415|  1.54M|#define _OP_ANY 2
  ------------------
  |  Branch (432:5): [True: 1.54M, False: 1.03k]
  ------------------
  433|  1.54M|	return has_na ? NA_LOGICAL : FALSE;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (433:9): [True: 0, False: 1.54M]
  ------------------
  434|  1.03k|    case _OP_ALL:
  ------------------
  |  |  414|  1.03k|#define _OP_ALL 1
  ------------------
  |  Branch (434:5): [True: 1.03k, False: 1.54M]
  ------------------
  435|  1.03k|	return has_na ? NA_LOGICAL : TRUE;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (435:9): [True: 0, False: 1.03k]
  ------------------
  436|      0|    default:
  ------------------
  |  Branch (436:5): [True: 0, False: 1.54M]
  ------------------
  437|      0|	error("bad op value for do_logic3");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  438|  1.54M|    }
  439|      0|    return NA_LOGICAL; /* -Wall */
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  440|  1.54M|}

machine.c:machar:
   98|      2|{
   99|      2|	volatile DTYPE a, b, beta, betain, betah, one,
  100|      2|		t, temp, tempa, temp1, two, y, z, zero;
  101|      2|	int i, iz, j, k, mx, nxres;
  102|       |
  103|      2|	one = 1;
  104|      2|	two = one+one;
  105|      2|	zero = one-one;
  106|       |
  107|       |		/* determine ibeta, beta ala malcolm. */
  108|      2|	a = one; // a = <large> = 9.0072e+15 for 'double' is used later
  109|    106|	do {
  110|    106|		a = a + a;
  111|    106|		temp = a + one;
  112|    106|		temp1 = temp - a;
  113|    106|	}
  114|    106|	while(temp1 - one == zero);
  ------------------
  |  Branch (114:8): [True: 104, False: 2]
  ------------------
  115|       |#ifdef _no_longer___did_overflow_ // on IBM PowerPPC ('Power 8')
  116|       |	int itemp;
  117|       |	b = one;
  118|       |	do {
  119|       |		b = b + b;
  120|       |		temp = a + b;
  121|       |		itemp = (int)(temp - a);
  122|       |	}
  123|       |	while (itemp == 0);
  124|       |	*ibeta = itemp;
  125|       |#else
  126|      2|	*ibeta = (int) FLT_RADIX;
  127|      2|#endif
  128|      2|	beta = *ibeta;
  129|       |
  130|       |		/* determine it, irnd */
  131|       |
  132|      2|	*it = 0;
  133|      2|	b = one;
  134|    106|	do {
  135|    106|		*it = *it + 1;
  136|    106|		b = b * beta;
  137|    106|		temp = b + one;
  138|    106|		temp1 = temp - b;
  139|    106|	}
  140|    106|	while(temp1 - one == zero);
  ------------------
  |  Branch (140:8): [True: 104, False: 2]
  ------------------
  141|      2|	*irnd = 0;
  142|      2|	betah = beta / two;
  143|      2|	temp = a + betah;
  144|      2|	if (temp - a != zero)
  ------------------
  |  Branch (144:6): [True: 0, False: 2]
  ------------------
  145|      0|		*irnd = 1;
  146|      2|	tempa = a + beta;
  147|      2|	temp = tempa + betah;
  148|      2|	if (*irnd == 0 && temp - tempa != zero)
  ------------------
  |  Branch (148:6): [True: 2, False: 0]
  |  Branch (148:20): [True: 2, False: 0]
  ------------------
  149|      2|		*irnd = 2;
  150|       |
  151|       |		/* determine negep, epsneg */
  152|       |
  153|      2|	*negep = *it + 3;
  154|      2|	betain = one / beta;
  155|      2|	a = one;
  156|    114|	for(i=1 ; i<=*negep ; i++)
  ------------------
  |  Branch (156:12): [True: 112, False: 2]
  ------------------
  157|    112|		a = a * betain;
  158|      2|	b = a;
  159|      8|	for(;;) {
  160|      8|		temp = one - a;
  161|      8|		if (temp - one != zero)
  ------------------
  |  Branch (161:7): [True: 2, False: 6]
  ------------------
  162|      2|			break;
  163|      6|		a = a * beta;
  164|      6|		*negep = *negep - 1;
  165|      6|	}
  166|      2|	*negep = -*negep;
  167|      2|	*epsneg = a;
  168|      2|	if (*ibeta != 2 && *irnd != 0) {
  ------------------
  |  Branch (168:6): [True: 0, False: 2]
  |  Branch (168:21): [True: 0, False: 0]
  ------------------
  169|      0|		a = (a * (one + a)) / two;
  170|      0|		temp = one - a;
  171|      0|		if (temp - one != zero)
  ------------------
  |  Branch (171:7): [True: 0, False: 0]
  ------------------
  172|      0|			*epsneg = a;
  173|      0|	}
  174|       |
  175|       |		/* determine machep, eps */
  176|       |
  177|      2|	*machep = -*it - 3;
  178|      2|	a = b;
  179|     10|	for(;;) {
  180|     10|		temp = one + a;
  181|     10|		if (temp - one != zero)
  ------------------
  |  Branch (181:7): [True: 2, False: 8]
  ------------------
  182|      2|			break;
  183|      8|		a = a * beta;
  184|      8|		*machep = *machep + 1;
  185|      8|	}
  186|      2|	*eps = a;
  187|      2|	temp = tempa + beta * (one + *eps);
  188|      2|	if (*ibeta != 2 && *irnd != 0) {
  ------------------
  |  Branch (188:6): [True: 0, False: 2]
  |  Branch (188:21): [True: 0, False: 0]
  ------------------
  189|      0|		a = (a * (one + a)) / two;
  190|      0|		temp = one + a;
  191|      0|		if (temp - one != zero)
  ------------------
  |  Branch (191:7): [True: 0, False: 0]
  ------------------
  192|      0|			*eps = a;
  193|      0|	}
  194|       |
  195|       |		/* determine ngrd */
  196|       |
  197|      2|	*ngrd = 0;
  198|      2|	temp = one + *eps;
  199|      2|	if (*irnd == 0 && temp * one - one != zero)
  ------------------
  |  Branch (199:6): [True: 0, False: 2]
  |  Branch (199:20): [True: 0, False: 0]
  ------------------
  200|      0|		*ngrd = 1;
  201|       |
  202|       |	/* determine iexp, minexp, xmin */
  203|       |
  204|       |	/* loop to determine largest i and k = 2**i such that */
  205|       |	/*        (1/beta) ** (2**(i)) */
  206|       |	/* does not underflow. */
  207|       |	/* exit from loop is signaled by an underflow. */
  208|       |
  209|      2|	i = 0;
  210|      2|	k = 1;
  211|      2|	z = betain;
  212|      2|	t = one + *eps;
  213|      2|	nxres = 0;
  214|     20|	for(;;) {
  215|     20|		y = z;
  216|     20|		z = y * y;
  217|       |
  218|       |		/* check for underflow here */
  219|       |
  220|     20|		a = z * one;
  221|     20|		temp = z * t;
  222|     20|		if (a+a == zero || ABS(z) >= y)
  ------------------
  |  |   36|     20|#define ABS fabs
  ------------------
  |  Branch (222:7): [True: 0, False: 20]
  |  Branch (222:22): [True: 0, False: 20]
  ------------------
  223|      0|			break;
  224|     20|		temp1 = temp * betain;
  225|     20|		if (temp1 * beta == z)
  ------------------
  |  Branch (225:7): [True: 2, False: 18]
  ------------------
  226|      2|			break;
  227|     18|		i = i+1;
  228|     18|		k = k+k;
  229|     18|	}
  230|      2|	if (*ibeta != 10) {
  ------------------
  |  Branch (230:6): [True: 2, False: 0]
  ------------------
  231|      2|		*iexp = i + 1;
  232|      2|		mx = k + k;
  233|      2|	}
  234|      0|	else {
  235|       |		/* this segment is for decimal machines only */
  236|       |
  237|      0|		*iexp = 2;
  238|      0|		iz = *ibeta;
  239|      0|		while (k >= iz) {
  ------------------
  |  Branch (239:10): [True: 0, False: 0]
  ------------------
  240|      0|			iz = iz * *ibeta;
  241|      0|			iexp = iexp + 1;
  242|      0|		}
  243|      0|		mx = iz + iz - 1;
  244|      0|	}
  245|  1.02k|	do {
  246|       |		/* loop to determine minexp, xmin */
  247|       |		/* exit from loop is signaled by an underflow */
  248|       |
  249|  1.02k|		*xmin = y;
  250|  1.02k|		y = y * betain;
  251|       |
  252|       |		/* check for underflow here */
  253|       |
  254|  1.02k|		a = y * one;
  255|  1.02k|		temp = y * t;
  256|  1.02k|		if (a+a == zero || ABS(y) >= *xmin)
  ------------------
  |  |   36|  1.02k|#define ABS fabs
  ------------------
  |  Branch (256:7): [True: 0, False: 1.02k]
  |  Branch (256:22): [True: 0, False: 1.02k]
  ------------------
  257|      0|			goto L10;
  258|  1.02k|		k = k + 1;
  259|  1.02k|		temp1 = temp * betain;
  260|  1.02k|	}
  261|  1.02k|	while(temp1 * beta != y);
  ------------------
  |  Branch (261:8): [True: 1.01k, False: 2]
  ------------------
  262|      2|	nxres = 3;
  263|      2|	*xmin = y;
  264|      2|L10:	*minexp = -k;
  265|       |
  266|       |	/* determine maxexp, xmax */
  267|       |
  268|      2|	if (mx <= k + k - 3 && *ibeta != 10) {
  ------------------
  |  Branch (268:6): [True: 2, False: 0]
  |  Branch (268:25): [True: 2, False: 0]
  ------------------
  269|      2|		mx = mx + mx;
  270|      2|		*iexp = *iexp + 1;
  271|      2|	}
  272|      2|	*maxexp = mx + *minexp;
  273|       |
  274|       |	/* adjust irnd to reflect partial underflow */
  275|       |
  276|      2|	*irnd = *irnd + nxres;
  277|       |
  278|       |	/* adjust for ieee-style machines */
  279|       |
  280|      2|	if (*irnd == 2 || *irnd == 5)
  ------------------
  |  Branch (280:6): [True: 0, False: 2]
  |  Branch (280:20): [True: 2, False: 0]
  ------------------
  281|      2|		*maxexp = *maxexp - 2;
  282|       |
  283|       |	/* adjust for non-ieee machines with partial underflow */
  284|       |
  285|      2|	if (*irnd == 3 || *irnd == 4)
  ------------------
  |  Branch (285:6): [True: 0, False: 2]
  |  Branch (285:20): [True: 0, False: 2]
  ------------------
  286|      0|		*maxexp = *maxexp - *it;
  287|       |
  288|       |	/* adjust for machines with implicit leading bit in binary */
  289|       |	/* significand, and machines with radix point at extreme */
  290|       |	/* right of significand. */
  291|       |
  292|      2|	i = *maxexp + *minexp;
  293|      2|	if (*ibeta == 2 && i == 0)
  ------------------
  |  Branch (293:6): [True: 2, False: 0]
  |  Branch (293:21): [True: 0, False: 2]
  ------------------
  294|      0|		*maxexp = *maxexp - 1;
  295|      2|	if (i > 20)
  ------------------
  |  Branch (295:6): [True: 0, False: 2]
  ------------------
  296|      0|		*maxexp = *maxexp - 1;
  297|      2|	if (a != y)
  ------------------
  |  Branch (297:6): [True: 0, False: 2]
  ------------------
  298|      0|		*maxexp = *maxexp - 2;
  299|      2|	*xmax = one - *epsneg;
  300|      2|	if (*xmax * one != *xmax)
  ------------------
  |  Branch (300:6): [True: 0, False: 2]
  ------------------
  301|      0|		*xmax = one - beta * *epsneg;
  302|      2|	*xmax = *xmax / (beta * beta * beta * *xmin);
  303|      2|	i = *maxexp + *minexp + 3;
  304|      2|	if (i>0)
  ------------------
  |  Branch (304:6): [True: 2, False: 0]
  ------------------
  305|     12|		for(j=1 ; j<=i ; j++) {
  ------------------
  |  Branch (305:13): [True: 10, False: 2]
  ------------------
  306|     10|			if (*ibeta == 2)
  ------------------
  |  Branch (306:8): [True: 10, False: 0]
  ------------------
  307|     10|				*xmax = *xmax + *xmax;
  308|     10|			if (*ibeta != 2)
  ------------------
  |  Branch (308:8): [True: 0, False: 10]
  ------------------
  309|      0|				*xmax = *xmax * beta;
  310|     10|		}
  311|      2|}
machine.c:machar_LD:
   98|      2|{
   99|      2|	volatile DTYPE a, b, beta, betain, betah, one,
  100|      2|		t, temp, tempa, temp1, two, y, z, zero;
  101|      2|	int i, iz, j, k, mx, nxres;
  102|       |
  103|      2|	one = 1;
  104|      2|	two = one+one;
  105|      2|	zero = one-one;
  106|       |
  107|       |		/* determine ibeta, beta ala malcolm. */
  108|      2|	a = one; // a = <large> = 9.0072e+15 for 'double' is used later
  109|    128|	do {
  110|    128|		a = a + a;
  111|    128|		temp = a + one;
  112|    128|		temp1 = temp - a;
  113|    128|	}
  114|    128|	while(temp1 - one == zero);
  ------------------
  |  Branch (114:8): [True: 126, False: 2]
  ------------------
  115|       |#ifdef _no_longer___did_overflow_ // on IBM PowerPPC ('Power 8')
  116|       |	int itemp;
  117|       |	b = one;
  118|       |	do {
  119|       |		b = b + b;
  120|       |		temp = a + b;
  121|       |		itemp = (int)(temp - a);
  122|       |	}
  123|       |	while (itemp == 0);
  124|       |	*ibeta = itemp;
  125|       |#else
  126|      2|	*ibeta = (int) FLT_RADIX;
  127|      2|#endif
  128|      2|	beta = *ibeta;
  129|       |
  130|       |		/* determine it, irnd */
  131|       |
  132|      2|	*it = 0;
  133|      2|	b = one;
  134|    128|	do {
  135|    128|		*it = *it + 1;
  136|    128|		b = b * beta;
  137|    128|		temp = b + one;
  138|    128|		temp1 = temp - b;
  139|    128|	}
  140|    128|	while(temp1 - one == zero);
  ------------------
  |  Branch (140:8): [True: 126, False: 2]
  ------------------
  141|      2|	*irnd = 0;
  142|      2|	betah = beta / two;
  143|      2|	temp = a + betah;
  144|      2|	if (temp - a != zero)
  ------------------
  |  Branch (144:6): [True: 0, False: 2]
  ------------------
  145|      0|		*irnd = 1;
  146|      2|	tempa = a + beta;
  147|      2|	temp = tempa + betah;
  148|      2|	if (*irnd == 0 && temp - tempa != zero)
  ------------------
  |  Branch (148:6): [True: 2, False: 0]
  |  Branch (148:20): [True: 2, False: 0]
  ------------------
  149|      2|		*irnd = 2;
  150|       |
  151|       |		/* determine negep, epsneg */
  152|       |
  153|      2|	*negep = *it + 3;
  154|      2|	betain = one / beta;
  155|      2|	a = one;
  156|    136|	for(i=1 ; i<=*negep ; i++)
  ------------------
  |  Branch (156:12): [True: 134, False: 2]
  ------------------
  157|    134|		a = a * betain;
  158|      2|	b = a;
  159|      8|	for(;;) {
  160|      8|		temp = one - a;
  161|      8|		if (temp - one != zero)
  ------------------
  |  Branch (161:7): [True: 2, False: 6]
  ------------------
  162|      2|			break;
  163|      6|		a = a * beta;
  164|      6|		*negep = *negep - 1;
  165|      6|	}
  166|      2|	*negep = -*negep;
  167|      2|	*epsneg = a;
  168|      2|	if (*ibeta != 2 && *irnd != 0) {
  ------------------
  |  Branch (168:6): [True: 0, False: 2]
  |  Branch (168:21): [True: 0, False: 0]
  ------------------
  169|      0|		a = (a * (one + a)) / two;
  170|      0|		temp = one - a;
  171|      0|		if (temp - one != zero)
  ------------------
  |  Branch (171:7): [True: 0, False: 0]
  ------------------
  172|      0|			*epsneg = a;
  173|      0|	}
  174|       |
  175|       |		/* determine machep, eps */
  176|       |
  177|      2|	*machep = -*it - 3;
  178|      2|	a = b;
  179|     10|	for(;;) {
  180|     10|		temp = one + a;
  181|     10|		if (temp - one != zero)
  ------------------
  |  Branch (181:7): [True: 2, False: 8]
  ------------------
  182|      2|			break;
  183|      8|		a = a * beta;
  184|      8|		*machep = *machep + 1;
  185|      8|	}
  186|      2|	*eps = a;
  187|      2|	temp = tempa + beta * (one + *eps);
  188|      2|	if (*ibeta != 2 && *irnd != 0) {
  ------------------
  |  Branch (188:6): [True: 0, False: 2]
  |  Branch (188:21): [True: 0, False: 0]
  ------------------
  189|      0|		a = (a * (one + a)) / two;
  190|      0|		temp = one + a;
  191|      0|		if (temp - one != zero)
  ------------------
  |  Branch (191:7): [True: 0, False: 0]
  ------------------
  192|      0|			*eps = a;
  193|      0|	}
  194|       |
  195|       |		/* determine ngrd */
  196|       |
  197|      2|	*ngrd = 0;
  198|      2|	temp = one + *eps;
  199|      2|	if (*irnd == 0 && temp * one - one != zero)
  ------------------
  |  Branch (199:6): [True: 0, False: 2]
  |  Branch (199:20): [True: 0, False: 0]
  ------------------
  200|      0|		*ngrd = 1;
  201|       |
  202|       |	/* determine iexp, minexp, xmin */
  203|       |
  204|       |	/* loop to determine largest i and k = 2**i such that */
  205|       |	/*        (1/beta) ** (2**(i)) */
  206|       |	/* does not underflow. */
  207|       |	/* exit from loop is signaled by an underflow. */
  208|       |
  209|      2|	i = 0;
  210|      2|	k = 1;
  211|      2|	z = betain;
  212|      2|	t = one + *eps;
  213|      2|	nxres = 0;
  214|     28|	for(;;) {
  215|     28|		y = z;
  216|     28|		z = y * y;
  217|       |
  218|       |		/* check for underflow here */
  219|       |
  220|     28|		a = z * one;
  221|     28|		temp = z * t;
  222|     28|		if (a+a == zero || ABS(z) >= y)
  ------------------
  |  |   45|     28|# define ABS fabsl
  ------------------
  |  Branch (222:7): [True: 0, False: 28]
  |  Branch (222:22): [True: 0, False: 28]
  ------------------
  223|      0|			break;
  224|     28|		temp1 = temp * betain;
  225|     28|		if (temp1 * beta == z)
  ------------------
  |  Branch (225:7): [True: 2, False: 26]
  ------------------
  226|      2|			break;
  227|     26|		i = i+1;
  228|     26|		k = k+k;
  229|     26|	}
  230|      2|	if (*ibeta != 10) {
  ------------------
  |  Branch (230:6): [True: 2, False: 0]
  ------------------
  231|      2|		*iexp = i + 1;
  232|      2|		mx = k + k;
  233|      2|	}
  234|      0|	else {
  235|       |		/* this segment is for decimal machines only */
  236|       |
  237|      0|		*iexp = 2;
  238|      0|		iz = *ibeta;
  239|      0|		while (k >= iz) {
  ------------------
  |  Branch (239:10): [True: 0, False: 0]
  ------------------
  240|      0|			iz = iz * *ibeta;
  241|      0|			iexp = iexp + 1;
  242|      0|		}
  243|      0|		mx = iz + iz - 1;
  244|      0|	}
  245|  16.3k|	do {
  246|       |		/* loop to determine minexp, xmin */
  247|       |		/* exit from loop is signaled by an underflow */
  248|       |
  249|  16.3k|		*xmin = y;
  250|  16.3k|		y = y * betain;
  251|       |
  252|       |		/* check for underflow here */
  253|       |
  254|  16.3k|		a = y * one;
  255|  16.3k|		temp = y * t;
  256|  16.3k|		if (a+a == zero || ABS(y) >= *xmin)
  ------------------
  |  |   45|  16.3k|# define ABS fabsl
  ------------------
  |  Branch (256:7): [True: 0, False: 16.3k]
  |  Branch (256:22): [True: 0, False: 16.3k]
  ------------------
  257|      0|			goto L10;
  258|  16.3k|		k = k + 1;
  259|  16.3k|		temp1 = temp * betain;
  260|  16.3k|	}
  261|  16.3k|	while(temp1 * beta != y);
  ------------------
  |  Branch (261:8): [True: 16.3k, False: 2]
  ------------------
  262|      2|	nxres = 3;
  263|      2|	*xmin = y;
  264|      2|L10:	*minexp = -k;
  265|       |
  266|       |	/* determine maxexp, xmax */
  267|       |
  268|      2|	if (mx <= k + k - 3 && *ibeta != 10) {
  ------------------
  |  Branch (268:6): [True: 2, False: 0]
  |  Branch (268:25): [True: 2, False: 0]
  ------------------
  269|      2|		mx = mx + mx;
  270|      2|		*iexp = *iexp + 1;
  271|      2|	}
  272|      2|	*maxexp = mx + *minexp;
  273|       |
  274|       |	/* adjust irnd to reflect partial underflow */
  275|       |
  276|      2|	*irnd = *irnd + nxres;
  277|       |
  278|       |	/* adjust for ieee-style machines */
  279|       |
  280|      2|	if (*irnd == 2 || *irnd == 5)
  ------------------
  |  Branch (280:6): [True: 0, False: 2]
  |  Branch (280:20): [True: 2, False: 0]
  ------------------
  281|      2|		*maxexp = *maxexp - 2;
  282|       |
  283|       |	/* adjust for non-ieee machines with partial underflow */
  284|       |
  285|      2|	if (*irnd == 3 || *irnd == 4)
  ------------------
  |  Branch (285:6): [True: 0, False: 2]
  |  Branch (285:20): [True: 0, False: 2]
  ------------------
  286|      0|		*maxexp = *maxexp - *it;
  287|       |
  288|       |	/* adjust for machines with implicit leading bit in binary */
  289|       |	/* significand, and machines with radix point at extreme */
  290|       |	/* right of significand. */
  291|       |
  292|      2|	i = *maxexp + *minexp;
  293|      2|	if (*ibeta == 2 && i == 0)
  ------------------
  |  Branch (293:6): [True: 2, False: 0]
  |  Branch (293:21): [True: 0, False: 2]
  ------------------
  294|      0|		*maxexp = *maxexp - 1;
  295|      2|	if (i > 20)
  ------------------
  |  Branch (295:6): [True: 0, False: 2]
  ------------------
  296|      0|		*maxexp = *maxexp - 1;
  297|      2|	if (a != y)
  ------------------
  |  Branch (297:6): [True: 0, False: 2]
  ------------------
  298|      0|		*maxexp = *maxexp - 2;
  299|      2|	*xmax = one - *epsneg;
  300|      2|	if (*xmax * one != *xmax)
  ------------------
  |  Branch (300:6): [True: 0, False: 2]
  ------------------
  301|      0|		*xmax = one - beta * *epsneg;
  302|      2|	*xmax = *xmax / (beta * beta * beta * *xmin);
  303|      2|	i = *maxexp + *minexp + 3;
  304|      2|	if (i>0)
  ------------------
  |  Branch (304:6): [True: 2, False: 0]
  ------------------
  305|     12|		for(j=1 ; j<=i ; j++) {
  ------------------
  |  Branch (305:13): [True: 10, False: 2]
  ------------------
  306|     10|			if (*ibeta == 2)
  ------------------
  |  Branch (306:8): [True: 10, False: 0]
  ------------------
  307|     10|				*xmax = *xmax + *xmax;
  308|     10|			if (*ibeta != 2)
  ------------------
  |  Branch (308:8): [True: 0, False: 10]
  ------------------
  309|      0|				*xmax = *xmax * beta;
  310|     10|		}
  311|      2|}

Init_R_Machine:
   61|      2|{
   62|      2|    machar(&R_AccuracyInfo.ibeta,
   63|      2|	   &R_AccuracyInfo.it,
   64|      2|	   &R_AccuracyInfo.irnd,
   65|      2|	   &R_AccuracyInfo.ngrd,
   66|      2|	   &R_AccuracyInfo.machep,
   67|      2|	   &R_AccuracyInfo.negep,
   68|      2|	   &R_AccuracyInfo.iexp,
   69|      2|	   &R_AccuracyInfo.minexp,
   70|      2|	   &R_AccuracyInfo.maxexp,
   71|      2|	   &R_AccuracyInfo.eps,
   72|      2|	   &R_AccuracyInfo.epsneg,
   73|      2|	   &R_AccuracyInfo.xmin,
   74|      2|	   &R_AccuracyInfo.xmax);
   75|       |
   76|      2|    R_dec_min_exponent = (int) floor(log10(R_AccuracyInfo.xmin)); /* smallest decimal exponent */
   77|       |
   78|       |    /*
   79|       |#ifdef HAVE_LONG_DOUBLE
   80|       |# define MACH_SIZE 18+10
   81|       |#else
   82|       |# define MACH_SIZE 18
   83|       |#endif
   84|       |    */
   85|      2|    int MACH_SIZE = 19;
   86|      2|    if (sizeof(LDOUBLE) > sizeof(double)) MACH_SIZE += 10;
  ------------------
  |  Branch (86:9): [True: 2, Folded]
  ------------------
   87|       |    
   88|      2|    SEXP ans = PROTECT(allocVector(VECSXP, MACH_SIZE)),
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
   89|      2|	 nms = PROTECT(allocVector(STRSXP, MACH_SIZE));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
   90|       |
   91|      2|    SET_STRING_ELT(nms, 0, mkChar("double.eps"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   92|      2|    SET_VECTOR_ELT(ans, 0, ScalarReal(R_AccuracyInfo.eps));
  ------------------
  |  | 1024|      2|#define ScalarReal		Rf_ScalarReal
  ------------------
   93|       |
   94|      2|    SET_STRING_ELT(nms, 1, mkChar("double.neg.eps"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   95|      2|    SET_VECTOR_ELT(ans, 1, ScalarReal(R_AccuracyInfo.epsneg));
  ------------------
  |  | 1024|      2|#define ScalarReal		Rf_ScalarReal
  ------------------
   96|       |
   97|      2|    SET_STRING_ELT(nms, 2, mkChar("double.xmin"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   98|      2|    SET_VECTOR_ELT(ans, 2, ScalarReal(R_AccuracyInfo.xmin));
  ------------------
  |  | 1024|      2|#define ScalarReal		Rf_ScalarReal
  ------------------
   99|       |
  100|      2|    SET_STRING_ELT(nms, 3, mkChar("double.xmax"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  101|      2|    SET_VECTOR_ELT(ans, 3, ScalarReal(R_AccuracyInfo.xmax));
  ------------------
  |  | 1024|      2|#define ScalarReal		Rf_ScalarReal
  ------------------
  102|       |
  103|      2|    SET_STRING_ELT(nms, 4, mkChar("double.base"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  104|      2|    SET_VECTOR_ELT(ans, 4, ScalarInteger(R_AccuracyInfo.ibeta));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  105|       |
  106|      2|    SET_STRING_ELT(nms, 5, mkChar("double.digits"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  107|      2|    SET_VECTOR_ELT(ans, 5, ScalarInteger(R_AccuracyInfo.it));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  108|       |
  109|      2|    SET_STRING_ELT(nms, 6, mkChar("double.rounding"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  110|      2|    SET_VECTOR_ELT(ans, 6, ScalarInteger(R_AccuracyInfo.irnd));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  111|       |
  112|      2|    SET_STRING_ELT(nms, 7, mkChar("double.guard"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  113|      2|    SET_VECTOR_ELT(ans, 7, ScalarInteger(R_AccuracyInfo.ngrd));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  114|       |
  115|      2|    SET_STRING_ELT(nms, 8, mkChar("double.ulp.digits"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  116|      2|    SET_VECTOR_ELT(ans, 8, ScalarInteger(R_AccuracyInfo.machep));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  117|       |
  118|      2|    SET_STRING_ELT(nms, 9, mkChar("double.neg.ulp.digits"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  119|      2|    SET_VECTOR_ELT(ans, 9, ScalarInteger(R_AccuracyInfo.negep));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  120|       |
  121|      2|    SET_STRING_ELT(nms, 10, mkChar("double.exponent"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  122|      2|    SET_VECTOR_ELT(ans, 10, ScalarInteger(R_AccuracyInfo.iexp));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  123|       |
  124|      2|    SET_STRING_ELT(nms, 11, mkChar("double.min.exp"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  125|      2|    SET_VECTOR_ELT(ans, 11, ScalarInteger(R_AccuracyInfo.minexp));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  126|       |
  127|      2|    SET_STRING_ELT(nms, 12, mkChar("double.max.exp"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  128|      2|    SET_VECTOR_ELT(ans, 12, ScalarInteger(R_AccuracyInfo.maxexp));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  129|       |
  130|      2|    SET_STRING_ELT(nms, 13, mkChar("integer.max"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  131|      2|    SET_VECTOR_ELT(ans, 13, ScalarInteger(INT_MAX));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  132|       |
  133|      2|    SET_STRING_ELT(nms, 14, mkChar("sizeof.long"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  134|      2|    SET_VECTOR_ELT(ans, 14, ScalarInteger(SIZEOF_LONG));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
                  SET_VECTOR_ELT(ans, 14, ScalarInteger(SIZEOF_LONG));
  ------------------
  |  | 1125|      2|#define SIZEOF_LONG 8
  ------------------
  135|       |
  136|      2|    SET_STRING_ELT(nms, 15, mkChar("sizeof.longlong"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  137|      2|    SET_VECTOR_ELT(ans, 15, ScalarInteger(SIZEOF_LONG_LONG));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
                  SET_VECTOR_ELT(ans, 15, ScalarInteger(SIZEOF_LONG_LONG));
  ------------------
  |  | 1131|      2|#define SIZEOF_LONG_LONG 8
  ------------------
  138|       |
  139|      2|    SET_STRING_ELT(nms, 16, mkChar("sizeof.longdouble"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  140|      2|#ifdef HAVE_LONG_DOUBLE
  141|      2|    SET_VECTOR_ELT(ans, 16, ScalarInteger(SIZEOF_LONG_DOUBLE));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
                  SET_VECTOR_ELT(ans, 16, ScalarInteger(SIZEOF_LONG_DOUBLE));
  ------------------
  |  | 1128|      2|#define SIZEOF_LONG_DOUBLE 16
  ------------------
  142|       |#else
  143|       |    SET_VECTOR_ELT(ans, 16, ScalarInteger(0));
  144|       |#endif
  145|       |
  146|      2|    SET_STRING_ELT(nms, 17, mkChar("sizeof.pointer"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  147|      2|    SET_VECTOR_ELT(ans, 17, ScalarInteger(sizeof(SEXP)));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  148|       |
  149|      2|    SET_STRING_ELT(nms, 18, mkChar("sizeof.time_t"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  150|       |#ifdef  USE_INTERNAL_MKTIME
  151|       |    SET_VECTOR_ELT(ans, 18, ScalarInteger(sizeof(R_time_t)));
  152|       |#else
  153|      2|    SET_VECTOR_ELT(ans, 18, ScalarInteger(sizeof(time_t)));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  154|      2|#endif
  155|       |/* This used to be just
  156|       |#ifdef HAVE_LONG_DOUBLE
  157|       |   but platforms can have the type and it be identical to double
  158|       |   (as on ARM).  So do the same as capabilities("long.double")
  159|       |*/
  160|      2|#ifdef HAVE_LONG_DOUBLE
  161|      2|    if (sizeof(LDOUBLE) > sizeof(double)) {
  ------------------
  |  Branch (161:9): [True: 2, Folded]
  ------------------
  162|      2|	static struct {
  163|      2|	    int ibeta, it, irnd, ngrd, machep, negep, iexp, minexp, maxexp;
  164|      2|	    long double eps, epsneg, xmin, xmax;
  165|      2|	} R_LD_AccuracyInfo;
  166|       |	
  167|      2|	machar_LD(&R_LD_AccuracyInfo.ibeta,
  168|      2|		  &R_LD_AccuracyInfo.it,
  169|      2|		  &R_LD_AccuracyInfo.irnd,
  170|      2|		  &R_LD_AccuracyInfo.ngrd,
  171|      2|		  &R_LD_AccuracyInfo.machep,
  172|      2|		  &R_LD_AccuracyInfo.negep,
  173|      2|		  &R_LD_AccuracyInfo.iexp,
  174|      2|		  &R_LD_AccuracyInfo.minexp,
  175|      2|		  &R_LD_AccuracyInfo.maxexp,
  176|      2|		  &R_LD_AccuracyInfo.eps,
  177|      2|		  &R_LD_AccuracyInfo.epsneg,
  178|      2|		  &R_LD_AccuracyInfo.xmin,
  179|      2|		  &R_LD_AccuracyInfo.xmax);
  180|      2|#define PT1 19
  181|      2|	SET_STRING_ELT(nms, PT1+0, mkChar("longdouble.eps"));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_STRING_ELT(nms, PT1+0, mkChar("longdouble.eps"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  182|      2|	SET_VECTOR_ELT(ans, PT1+0, ScalarReal((double) R_LD_AccuracyInfo.eps));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_VECTOR_ELT(ans, PT1+0, ScalarReal((double) R_LD_AccuracyInfo.eps));
  ------------------
  |  | 1024|      2|#define ScalarReal		Rf_ScalarReal
  ------------------
  183|       |
  184|      2|	SET_STRING_ELT(nms, PT1+1, mkChar("longdouble.neg.eps"));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_STRING_ELT(nms, PT1+1, mkChar("longdouble.neg.eps"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  185|      2|	SET_VECTOR_ELT(ans, PT1+1, ScalarReal((double) R_LD_AccuracyInfo.epsneg));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_VECTOR_ELT(ans, PT1+1, ScalarReal((double) R_LD_AccuracyInfo.epsneg));
  ------------------
  |  | 1024|      2|#define ScalarReal		Rf_ScalarReal
  ------------------
  186|      2|	SET_STRING_ELT(nms, PT1+2, mkChar("longdouble.digits"));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_STRING_ELT(nms, PT1+2, mkChar("longdouble.digits"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  187|      2|	SET_VECTOR_ELT(ans, PT1+2, ScalarInteger(R_LD_AccuracyInfo.it));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_VECTOR_ELT(ans, PT1+2, ScalarInteger(R_LD_AccuracyInfo.it));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  188|       |
  189|      2|	SET_STRING_ELT(nms, PT1+3, mkChar("longdouble.rounding"));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_STRING_ELT(nms, PT1+3, mkChar("longdouble.rounding"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  190|      2|	SET_VECTOR_ELT(ans, PT1+3, ScalarInteger(R_LD_AccuracyInfo.irnd));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_VECTOR_ELT(ans, PT1+3, ScalarInteger(R_LD_AccuracyInfo.irnd));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  191|       |
  192|      2|	SET_STRING_ELT(nms, PT1+4, mkChar("longdouble.guard"));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_STRING_ELT(nms, PT1+4, mkChar("longdouble.guard"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  193|      2|	SET_VECTOR_ELT(ans, PT1+4, ScalarInteger(R_LD_AccuracyInfo.ngrd));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_VECTOR_ELT(ans, PT1+4, ScalarInteger(R_LD_AccuracyInfo.ngrd));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  194|       |
  195|      2|	SET_STRING_ELT(nms, PT1+5, mkChar("longdouble.ulp.digits"));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_STRING_ELT(nms, PT1+5, mkChar("longdouble.ulp.digits"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  196|      2|	SET_VECTOR_ELT(ans, PT1+5, ScalarInteger(R_LD_AccuracyInfo.machep));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_VECTOR_ELT(ans, PT1+5, ScalarInteger(R_LD_AccuracyInfo.machep));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  197|       |
  198|      2|	SET_STRING_ELT(nms, PT1+6, mkChar("longdouble.neg.ulp.digits"));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_STRING_ELT(nms, PT1+6, mkChar("longdouble.neg.ulp.digits"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  199|      2|	SET_VECTOR_ELT(ans, PT1+6, ScalarInteger(R_LD_AccuracyInfo.negep));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_VECTOR_ELT(ans, PT1+6, ScalarInteger(R_LD_AccuracyInfo.negep));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  200|       |
  201|      2|	SET_STRING_ELT(nms, PT1+7, mkChar("longdouble.exponent"));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_STRING_ELT(nms, PT1+7, mkChar("longdouble.exponent"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  202|      2|	SET_VECTOR_ELT(ans, PT1+7, ScalarInteger(R_LD_AccuracyInfo.iexp));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_VECTOR_ELT(ans, PT1+7, ScalarInteger(R_LD_AccuracyInfo.iexp));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  203|       |
  204|      2|	SET_STRING_ELT(nms, PT1+8, mkChar("longdouble.min.exp"));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_STRING_ELT(nms, PT1+8, mkChar("longdouble.min.exp"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  205|      2|	SET_VECTOR_ELT(ans, PT1+8, ScalarInteger(R_LD_AccuracyInfo.minexp));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_VECTOR_ELT(ans, PT1+8, ScalarInteger(R_LD_AccuracyInfo.minexp));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  206|       |
  207|      2|	SET_STRING_ELT(nms, PT1+9, mkChar("longdouble.max.exp"));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_STRING_ELT(nms, PT1+9, mkChar("longdouble.max.exp"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  208|      2|	SET_VECTOR_ELT(ans, PT1+9, ScalarInteger(R_LD_AccuracyInfo.maxexp));
  ------------------
  |  |  180|      2|#define PT1 19
  ------------------
              	SET_VECTOR_ELT(ans, PT1+9, ScalarInteger(R_LD_AccuracyInfo.maxexp));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  209|       |
  210|      2|    }
  211|      2|#endif
  212|       |
  213|      2|    setAttrib(ans, R_NamesSymbol, nms);
  ------------------
  |  | 1027|      2|#define setAttrib		Rf_setAttrib
  ------------------
  214|      2|    defineVar(install(".Machine"), ans, rho);
  ------------------
  |  |  905|      2|#define defineVar		Rf_defineVar
  ------------------
                  defineVar(install(".Machine"), ans, rho);
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  215|      2|    UNPROTECT(2);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  216|      2|}

Rf_BindDomain:
  740|      2|{
  741|      2|#ifdef ENABLE_NLS
  742|      2|    char *localedir = NULL;
  743|      2|# if defined(LC_MESSAGES) && !defined(Win32)
  744|      2|    setlocale(LC_MESSAGES,"");
  745|      2|# endif
  746|      2|    textdomain(PACKAGE);
  ------------------
  |  | 1054|      2|#define PACKAGE "R"
  ------------------
  747|      2|    char *p = getenv("R_TRANSLATIONS");
  748|      2|    if (p) Rasprintf_malloc(&localedir, "%s", p);
  ------------------
  |  Branch (748:9): [True: 0, False: 2]
  ------------------
  749|      2|    else Rasprintf_malloc(&localedir, "%s/library/translations", R_Home);
  750|      2|    if (!localedir)
  ------------------
  |  Branch (750:9): [True: 0, False: 2]
  ------------------
  751|      0|	R_Suicide("allocation failure in BindDomain");
  752|      2|    bindtextdomain(PACKAGE, localedir); // PACKAGE = DOMAIN = "R"
  ------------------
  |  | 1054|      2|#define PACKAGE "R"
  ------------------
  753|      2|    bindtextdomain("R-base", localedir);
  754|       |# ifdef _WIN32
  755|       |    bindtextdomain("RGui", localedir);
  756|       |# endif
  757|      2|    free(localedir);
  758|      2|#endif
  759|      2|}
setup_Rmainloop:
  823|      2|{
  824|      2|    volatile int doneit;
  825|      2|    volatile SEXP baseNSenv;
  826|      2|    SEXP cmd;
  827|      2|    char deferred_warnings[12][250];
  828|      2|    volatile int ndeferred_warnings = 0;
  829|       |
  830|       |#ifdef Win32
  831|       |    {
  832|       |	char *p = getenv("_R_WIN_CHECK_INVALID_PARAMETERS_");
  833|       |	if (p && StringTrue(p))
  834|       |	    _set_invalid_parameter_handler(invalid_parameter_handler_abort);
  835|       |	else if (p && !strcmp(p, "watson"))
  836|       |	    _set_invalid_parameter_handler(invalid_parameter_handler_watson);
  837|       |    }
  838|       |#endif
  839|       |
  840|       |#ifdef DEBUG_STACK_DETECTION
  841|       |    /* testing stack base and size detection */
  842|       |    printf("stack limit %lu, start %lu dir %d \n",
  843|       |	(unsigned long) R_CStackLimit,
  844|       |        (unsigned long) R_CStackStart,
  845|       |	R_CStackDir);
  846|       |    uintptr_t firstb = R_CStackStart - R_CStackDir;
  847|       |    printf("first accessible byte %lx\n", (unsigned long) firstb);
  848|       |    if (R_CStackLimit != (uintptr_t)(-1)) {
  849|       |        uintptr_t lastb = R_CStackStart - R_CStackDir * R_CStackLimit;
  850|       |	printf("last accessible byte %lx\n", (unsigned long) lastb);
  851|       |    }
  852|       |    printf("accessing first byte...\n");
  853|       |    volatile char dummy = *(char *)firstb;
  854|       |    if (R_CStackLimit != (uintptr_t)(-1)) {
  855|       |	/* have to access all bytes in order to map stack, e.g. on Linux
  856|       |	   just reading does not seem to always do the job, so better
  857|       |	   first almost fill up the stack using recursive function calls
  858|       |	 */
  859|       |	printf("almost filling up stack...\n");
  860|       |	printf("filled stack up to %lx\n", almostFillStack());
  861|       |	/* the loop below writes outside the local variables and the frame,
  862|       |	   which is detected e.g. by ASAN as stack-buffer-overflow */
  863|       |	printf("accessing all bytes...\n");
  864|       |	for(uintptr_t o = 0; o < R_CStackLimit; o++)
  865|       |	    /* with exact bounds, o==-1 and o==R_CStackLimit will segfault */
  866|       |	    /* +dummy to silence -Wunused-but-set-variable */
  867|       |	    dummy = *((char *)firstb - R_CStackDir * o) + dummy;
  868|       |    }
  869|       |#endif
  870|       |
  871|       |    /* In case this is a silly limit: 2^32 -3 has been seen and
  872|       |     * casting to intptr_r relies on this being smaller than 2^31 on a
  873|       |     * 32-bit platform. */
  874|      2|    if(R_CStackLimit > 100000000U)
  ------------------
  |  Branch (874:8): [True: 2, False: 0]
  ------------------
  875|      2|	R_CStackLimit = (uintptr_t)-1;
  876|       |    /* make sure we have enough head room to handle errors */
  877|      2|    if(R_CStackLimit != -1)
  ------------------
  |  Branch (877:8): [True: 0, False: 2]
  ------------------
  878|      0|	R_CStackLimit = (uintptr_t)(0.95 * R_CStackLimit);
  879|       |
  880|      2|    InitConnections(); /* needed to get any output at all */
  ------------------
  |  | 1911|      2|# define InitConnections	Rf_InitConnections
  ------------------
  881|       |
  882|       |    /* Initialize the interpreter's internal structures. */
  883|       |
  884|      2|#ifdef HAVE_LOCALE_H
  885|       |#ifdef Win32
  886|       |    {
  887|       |	char allbuf[1000]; /* Windows' locales can be very long */
  888|       |	char *p, *lcall;
  889|       |
  890|       |	p = getenv("LC_ALL");
  891|       |	if(p) {
  892|       |	    strncpy(allbuf, p, sizeof(allbuf));
  893|       |	    allbuf[1000 - 1] = '\0';
  894|       |	    lcall = allbuf;
  895|       |	} else
  896|       |	    lcall = NULL;
  897|       |
  898|       |	/* We'd like to use warning, but need to defer.
  899|       |	   Also cannot translate. */
  900|       |
  901|       |	p = lcall ? lcall : getenv("LC_COLLATE");
  902|       |	if(!setlocale(LC_COLLATE, p ? p : ""))
  903|       |	    snprintf(deferred_warnings[ndeferred_warnings++], 250,
  904|       |		     "Setting LC_COLLATE=%.200s failed\n", p);
  905|       |
  906|       |	p = lcall ? lcall : getenv("LC_CTYPE");
  907|       |	if(!setlocale(LC_CTYPE, p ? p : ""))
  908|       |	    snprintf(deferred_warnings[ndeferred_warnings++], 250,
  909|       |		     "Setting LC_CTYPE=%.200s failed\n", p);
  910|       |
  911|       |	p = lcall ? lcall : getenv("LC_MONETARY");
  912|       |	if(!setlocale(LC_MONETARY, p ? p : ""))
  913|       |	    snprintf(deferred_warnings[ndeferred_warnings++], 250,
  914|       |		     "Setting LC_MONETARY=%.200s failed\n", p);
  915|       |
  916|       |	p = lcall ? lcall : getenv("LC_TIME");
  917|       |	if(!setlocale(LC_TIME, p ? p : ""))
  918|       |	    snprintf(deferred_warnings[ndeferred_warnings++], 250,
  919|       |		     "Setting LC_TIME=%.200s failed\n", p);
  920|       |
  921|       |	/* We set R_ARCH here: Unix does it in the shell front-end */
  922|       |	char Rarch[30];
  923|       |	strcpy(Rarch, "R_ARCH=");
  924|       |# ifdef R_ARCH
  925|       |	if (strlen(R_ARCH) > 0) {
  926|       |	    strcat(Rarch, "/");
  927|       |	    strcat(Rarch, R_ARCH);
  928|       |	}
  929|       |# endif
  930|       |	putenv(Rarch);
  931|       |    }
  932|       |#else /* not Win32 */
  933|       |
  934|      2|{  /* Avoid annoying warnings if LANG and LC_ALL are unset or empty.
  935|       |      This happens e.g. on Mac when primary language clash with region,
  936|       |      like English in Denmark or Germany.
  937|       |
  938|       |      If LANG or LC_ALL has been set to a non-existing locale, we assume
  939|       |      that the user wants to ne informed. */
  940|       |
  941|      2|    const char *s;
  942|      2|    int quiet;
  943|       |
  944|      2|    quiet = !( ((s = getenv("LANG")) && *s) || ((s = getenv("LC_ALL")) && *s) );
  ------------------
  |  Branch (944:17): [True: 0, False: 2]
  |  Branch (944:41): [True: 0, False: 0]
  |  Branch (944:49): [True: 0, False: 2]
  |  Branch (944:75): [True: 0, False: 0]
  ------------------
  945|       |
  946|      2|    if(!setlocale(LC_CTYPE, "") && !quiet)
  ------------------
  |  Branch (946:8): [True: 0, False: 2]
  |  Branch (946:36): [True: 0, False: 0]
  ------------------
  947|      0|	snprintf(deferred_warnings[ndeferred_warnings++], 250,
  948|       |
  949|      0|		 "Setting LC_CTYPE failed, using \"C\"\n");
  950|      2|    if(!setlocale(LC_COLLATE, "") && !quiet)
  ------------------
  |  Branch (950:8): [True: 0, False: 2]
  |  Branch (950:38): [True: 0, False: 0]
  ------------------
  951|      0|	snprintf(deferred_warnings[ndeferred_warnings++], 250,
  952|      0|		 "Setting LC_COLLATE failed, using \"C\"\n");
  953|      2|    if(!setlocale(LC_TIME, "") && !quiet)
  ------------------
  |  Branch (953:8): [True: 0, False: 2]
  |  Branch (953:35): [True: 0, False: 0]
  ------------------
  954|      0|	snprintf(deferred_warnings[ndeferred_warnings++], 250,
  955|      0|		 "Setting LC_TIME failed, using \"C\"\n");
  956|      2|# if defined(ENABLE_NLS) && defined(LC_MESSAGES)
  957|      2|    if(!setlocale(LC_MESSAGES, "") && !quiet)
  ------------------
  |  Branch (957:8): [True: 0, False: 2]
  |  Branch (957:39): [True: 0, False: 0]
  ------------------
  958|      0|	snprintf(deferred_warnings[ndeferred_warnings++], 250,
  959|      0|		 "Setting LC_MESSAGES failed, using \"C\"\n");
  960|      2|# endif
  961|       |    /* NB: we do not set LC_NUMERIC */
  962|      2|# ifdef LC_MONETARY
  963|      2|    if(!setlocale(LC_MONETARY, "") && !quiet)
  ------------------
  |  Branch (963:8): [True: 0, False: 2]
  |  Branch (963:39): [True: 0, False: 0]
  ------------------
  964|      0|	snprintf(deferred_warnings[ndeferred_warnings++], 250,
  965|      0|		 "Setting LC_MONETARY failed, using \"C\"\n");
  966|      2|# endif
  967|      2|# ifdef LC_PAPER
  968|      2|    if(!setlocale(LC_PAPER, "") && !quiet)
  ------------------
  |  Branch (968:8): [True: 0, False: 2]
  |  Branch (968:36): [True: 0, False: 0]
  ------------------
  969|      0|	snprintf(deferred_warnings[ndeferred_warnings++], 250,
  970|      0|		 "Setting LC_PAPER failed, using \"C\"\n");
  971|      2|# endif
  972|      2|# ifdef LC_MEASUREMENT
  973|      2|    if(!setlocale(LC_MEASUREMENT, "") && !quiet)
  ------------------
  |  Branch (973:8): [True: 0, False: 2]
  |  Branch (973:42): [True: 0, False: 0]
  ------------------
  974|      0|	snprintf(deferred_warnings[ndeferred_warnings++], 250,
  975|      0|		 "Setting LC_MEASUREMENT failed, using \"C\"\n");
  976|      2|# endif
  977|      2|}
  978|      2|#endif /* not Win32 */
  979|      2|#endif
  980|       |
  981|       |    /* make sure srand is called before R_tmpnam, PR#14381 */
  982|      2|    srand(TimeToSeed());
  ------------------
  |  | 1997|      2|# define TimeToSeed		Rf_TimeToSeed
  ------------------
  983|       |
  984|      2|    InitArithmetic();
  ------------------
  |  | 1910|      2|# define InitArithmetic		Rf_InitArithmetic
  ------------------
  985|      2|    InitTempDir(); /* must be before InitEd */
  ------------------
  |  | 1922|      2|# define InitTempDir		Rf_InitTempDir
  ------------------
  986|      2|    InitMemory();
  ------------------
  |  | 1917|      2|# define InitMemory		Rf_InitMemory
  ------------------
  987|      2|    InitStringHash(); /* must be before InitNames */
  ------------------
  |  | 1920|      2|# define InitStringHash		Rf_InitStringHash
  ------------------
  988|      2|    InitBaseEnv();
  ------------------
  |  | 1914|      2|# define InitBaseEnv		Rf_InitBaseEnv
  ------------------
  989|      2|    InitNames(); /* must be after InitBaseEnv to use R_EmptyEnv */
  ------------------
  |  | 1918|      2|# define InitNames		Rf_InitNames
  ------------------
  990|      2|    InitParser();  /* must be after InitMemory, InitNames */
  991|      2|    InitGlobalEnv();
  ------------------
  |  | 1915|      2|# define InitGlobalEnv		Rf_InitGlobalEnv
  ------------------
  992|      2|    InitDynload();
  993|      2|    InitOptions();
  ------------------
  |  | 1919|      2|# define InitOptions		Rf_InitOptions
  ------------------
  994|      2|    InitEd();
  ------------------
  |  | 1912|      2|# define InitEd			Rf_InitEd
  ------------------
  995|      2|    InitGraphics();
  ------------------
  |  | 1916|      2|# define InitGraphics		Rf_InitGraphics
  ------------------
  996|      2|    InitTypeTables(); /* must be before InitS3DefaultTypes */
  ------------------
  |  | 1923|      2|# define InitTypeTables		Rf_InitTypeTables
  ------------------
  997|      2|    InitS3DefaultTypes();
  ------------------
  |  | 1921|      2|# define InitS3DefaultTypes	Rf_InitS3DefaultTypes
  ------------------
  998|      2|    PrintDefaults();
  ------------------
  |  | 1970|      2|# define PrintDefaults		Rf_PrintDefaults
  ------------------
  999|      2|    R_InitConditions();
 1000|       |
 1001|      2|    R_Is_Running = 1;
 1002|      2|    R_check_locale();
 1003|       |#ifdef Win32
 1004|       |    if (localeCP && systemCP != localeCP)
 1005|       |        /* For now, don't warn for localeCP == 0, but it can cause problems
 1006|       |           as well. Keep in step with do_setlocale. */
 1007|       |	snprintf(deferred_warnings[ndeferred_warnings++], 250,
 1008|       |	          "Using locale code page other than %d%s may cause problems.",
 1009|       |	          systemCP, systemCP == 65001 ? " (\"UTF-8\")" : "");
 1010|       |#endif
 1011|       |    /* Initialize the global context for error handling. */
 1012|       |    /* This provides a target for any non-local gotos */
 1013|       |    /* which occur during error handling */
 1014|       |
 1015|      2|    R_Toplevel.nextcontext = NULL;
 1016|      2|    R_Toplevel.callflag = CTXT_TOPLEVEL;
 1017|      2|    R_Toplevel.cstacktop = 0;
 1018|      2|    R_Toplevel.gcenabled = R_GCEnabled;
 1019|      2|    R_Toplevel.promargs = R_NilValue;
 1020|      2|    R_Toplevel.callfun = R_NilValue;
 1021|      2|    R_Toplevel.call = R_NilValue;
 1022|      2|    R_Toplevel.cloenv = R_BaseEnv;
 1023|      2|    R_Toplevel.sysparent = R_BaseEnv;
 1024|      2|    R_Toplevel.conexit = R_NilValue;
 1025|      2|    R_Toplevel.vmax = NULL;
 1026|      2|    R_Toplevel.nodestack = R_BCNodeStackTop;
 1027|      2|    R_Toplevel.bcprottop = R_BCProtTop;
 1028|      2|    R_Toplevel.cend = NULL;
 1029|      2|    R_Toplevel.cenddata = NULL;
 1030|      2|    R_Toplevel.intsusp = FALSE;
 1031|      2|    R_Toplevel.handlerstack = R_HandlerStack;
 1032|      2|    R_Toplevel.restartstack = R_RestartStack;
 1033|      2|    R_Toplevel.srcref = R_NilValue;
 1034|      2|    R_Toplevel.prstack = NULL;
 1035|      2|    R_Toplevel.returnValue = SEXP_TO_STACKVAL(NULL);
  ------------------
  |  | 2598|      2|#define SEXP_TO_STACKVAL(x) ((R_bcstack_t) { .tag = 0, .u.sxpval = (x) })
  ------------------
 1036|      2|    R_Toplevel.evaldepth = 0;
 1037|      2|    R_Toplevel.browserfinish = 0;
 1038|      2|    R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
 1039|      2|    R_ExitContext = NULL;
 1040|       |
 1041|      2|    R_Warnings = R_NilValue;
 1042|       |
 1043|       |    /* This is the same as R_BaseEnv, but this marks the environment
 1044|       |       of functions as the namespace and not the package. */
 1045|      2|    baseNSenv = R_BaseNamespace;
 1046|       |
 1047|       |    /* Set up some global variables */
 1048|      2|    Init_R_Variables(baseNSenv);
 1049|       |
 1050|       |    /* On initial entry we open the base language package and begin by
 1051|       |       running the repl on it.
 1052|       |       If there is an error we pass on to the repl.
 1053|       |       Perhaps it makes more sense to quit gracefully?
 1054|       |    */
 1055|       |
 1056|       |#ifdef RMIN_ONLY
 1057|       |    /* This is intended to support a minimal build for experimentation. */
 1058|       |    if (R_SignalHandlers) init_signal_handlers();
 1059|       |#else
 1060|      2|    FILE *fp = R_OpenLibraryFile("base");
 1061|      2|    if (fp == NULL)
  ------------------
  |  Branch (1061:9): [True: 0, False: 2]
  ------------------
 1062|      0|	R_Suicide(_("unable to open the base package\n"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1063|       |
 1064|      2|    doneit = 0;
 1065|      2|    if (SETJMP(R_Toplevel.cjmpbuf))
  ------------------
  |  | 1162|      2|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (1065:9): [True: 0, False: 2]
  ------------------
 1066|      0|	check_session_exit();
 1067|      2|    R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
 1068|      2|    if (R_SignalHandlers) init_signal_handlers();
  ------------------
  |  Branch (1068:9): [True: 0, False: 2]
  ------------------
 1069|      2|    if (!doneit) {
  ------------------
  |  Branch (1069:9): [True: 2, False: 0]
  ------------------
 1070|      2|	doneit = 1;
 1071|      2|	R_ReplFile(fp, baseNSenv);
 1072|      2|    }
 1073|      2|    fclose(fp);
 1074|      2|#endif
 1075|       |
 1076|       |    /* This is where we source the system-wide, the site's and the
 1077|       |       user's profile (in that order).  If there is an error, we
 1078|       |       drop through to further processing.
 1079|       |    */
 1080|      2|    R_IoBufferInit(&R_ConsoleIob);
 1081|      2|    R_LoadProfile(R_OpenSysInitFile(), baseNSenv);
 1082|       |    /* These are the same bindings, so only lock them once */
 1083|      2|    R_LockEnvironment(R_BaseNamespace, TRUE);
 1084|      2|    R_LockEnvironment(R_BaseEnv, FALSE);
 1085|       |    /* At least temporarily unlock some bindings used in graphics */
 1086|      2|    R_unLockBinding(R_DeviceSymbol, R_BaseEnv);
 1087|      2|    R_unLockBinding(R_DevicesSymbol, R_BaseEnv);
 1088|       |
 1089|       |    /* require(methods) if it is in the default packages */
 1090|      2|    doneit = 0;
 1091|      2|    if (SETJMP(R_Toplevel.cjmpbuf))
  ------------------
  |  | 1162|      2|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (1091:9): [True: 0, False: 2]
  ------------------
 1092|      0|	check_session_exit();
 1093|      2|    R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
 1094|      2|    if (!doneit) {
  ------------------
  |  Branch (1094:9): [True: 2, False: 0]
  ------------------
 1095|      2|	doneit = 1;
 1096|      2|	PROTECT(cmd = install(".OptRequireMethods"));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1097|      2|	R_CurrentExpr = R_findVar(cmd, R_GlobalEnv);
 1098|      2|	if (R_CurrentExpr != R_UnboundValue &&
  ------------------
  |  Branch (1098:6): [True: 2, False: 0]
  ------------------
 1099|      2|	    TYPEOF(R_CurrentExpr) == CLOSXP) {
  ------------------
  |  |  114|      2|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1099:6): [True: 2, False: 0]
  ------------------
 1100|      2|		PROTECT(R_CurrentExpr = lang1(cmd));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1101|      2|		R_CurrentExpr = eval(R_CurrentExpr, R_BaseEnv);
  ------------------
  |  |  913|      2|#define eval			Rf_eval
  ------------------
 1102|      2|		UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1103|      2|	}
 1104|      2|	UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1105|      2|    }
 1106|       |
 1107|      2|    if (strcmp(R_GUIType, "Tk") == 0) {
  ------------------
  |  Branch (1107:9): [True: 0, False: 2]
  ------------------
 1108|      0|	char *buf = NULL;
 1109|       |
 1110|      0|	Rasprintf_malloc(&buf, "%s/library/tcltk/exec/Tk-frontend.R", R_Home);
 1111|      0|	if (!buf)
  ------------------
  |  Branch (1111:6): [True: 0, False: 0]
  ------------------
 1112|      0|	    R_Suicide("allocation failure in setup_Rmainloop");
 1113|      0|	R_LoadProfile(R_fopen(buf, "r"), R_GlobalEnv);
 1114|      0|	free(buf);
 1115|      0|    }
 1116|       |
 1117|       |    /* Print a platform and version dependent greeting and a pointer to
 1118|       |     * the copyleft.
 1119|       |     */
 1120|      2|    if(!R_Quiet) PrintGreeting();
  ------------------
  |  | 1971|      0|# define PrintGreeting		Rf_PrintGreeting
  ------------------
  |  Branch (1120:8): [True: 0, False: 2]
  ------------------
 1121|       |
 1122|      2|    R_LoadProfile(R_OpenSiteFile(), R_GlobalEnv);
 1123|       |    /* The system profile creates an active binding in global environment
 1124|       |       to capture writes to .Library.site executed in the site profile. This
 1125|       |       effectively modifies .Library.site in the base environment to mimick
 1126|       |       previous behavior when the site profile was run in the base
 1127|       |       environment. */
 1128|      2|    R_removeVarFromFrame(install(".Library.site"), R_GlobalEnv);
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1129|      2|    R_LoadProfile(R_OpenInitFile(), R_GlobalEnv);
 1130|       |
 1131|       |    /* This is where we try to load a user's saved data.
 1132|       |       The right thing to do here is very platform dependent.
 1133|       |       E.g. under Unix we look in a special hidden file and on the Mac
 1134|       |       we look in any documents which might have been double clicked on
 1135|       |       or dropped on the application.
 1136|       |    */
 1137|      2|    doneit = 0;
 1138|      2|    if (SETJMP(R_Toplevel.cjmpbuf))
  ------------------
  |  | 1162|      2|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (1138:9): [True: 0, False: 2]
  ------------------
 1139|      0|	check_session_exit();
 1140|      2|    R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
 1141|      2|    if (!doneit) {
  ------------------
  |  Branch (1141:9): [True: 2, False: 0]
  ------------------
 1142|      2|	doneit = 1;
 1143|      2|	R_InitialData();
 1144|      2|    }
 1145|      0|    else {
 1146|      0|	if (SETJMP(R_Toplevel.cjmpbuf))
  ------------------
  |  | 1162|      0|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (1146:6): [True: 0, False: 0]
  ------------------
 1147|      0|	    check_session_exit();
 1148|      0|	else {
 1149|      0|    	    warning(_("unable to restore saved data in %s\n"), get_workspace_name());
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
                  	    warning(_("unable to restore saved data in %s\n"), get_workspace_name());
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1150|      0|	}
 1151|      0|    }
 1152|       |
 1153|       |    /* Initial Loading is done.
 1154|       |       At this point we try to invoke the .First Function.
 1155|       |       If there is an error we continue. */
 1156|       |
 1157|      2|    doneit = 0;
 1158|      2|    if (SETJMP(R_Toplevel.cjmpbuf))
  ------------------
  |  | 1162|      2|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (1158:9): [True: 0, False: 2]
  ------------------
 1159|      0|	check_session_exit();
 1160|      2|    R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
 1161|      2|    if (!doneit) {
  ------------------
  |  Branch (1161:9): [True: 2, False: 0]
  ------------------
 1162|      2|	doneit = 1;
 1163|      2|	PROTECT(cmd = install(".First"));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1164|      2|	R_CurrentExpr = R_findVar(cmd, R_GlobalEnv);
 1165|      2|	if (R_CurrentExpr != R_UnboundValue &&
  ------------------
  |  Branch (1165:6): [True: 0, False: 2]
  ------------------
 1166|      0|	    TYPEOF(R_CurrentExpr) == CLOSXP) {
  ------------------
  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1166:6): [True: 0, False: 0]
  ------------------
 1167|      0|		PROTECT(R_CurrentExpr = lang1(cmd));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1168|      0|		R_CurrentExpr = eval(R_CurrentExpr, R_GlobalEnv);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 1169|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1170|      0|	}
 1171|      2|	UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1172|      2|    }
 1173|       |    /* Try to invoke the .First.sys function, which loads the default packages.
 1174|       |       If there is an error we continue. */
 1175|       |
 1176|      2|    doneit = 0;
 1177|      2|    if (SETJMP(R_Toplevel.cjmpbuf))
  ------------------
  |  | 1162|      2|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (1177:9): [True: 0, False: 2]
  ------------------
 1178|      0|	check_session_exit();
 1179|      2|    R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
 1180|      2|    if (!doneit) {
  ------------------
  |  Branch (1180:9): [True: 2, False: 0]
  ------------------
 1181|      2|	doneit = 1;
 1182|      2|	PROTECT(cmd = install(".First.sys"));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1183|      2|	R_CurrentExpr = R_findVar(cmd, baseNSenv);
 1184|      2|	if (R_CurrentExpr != R_UnboundValue &&
  ------------------
  |  Branch (1184:6): [True: 2, False: 0]
  ------------------
 1185|      2|	    TYPEOF(R_CurrentExpr) == CLOSXP) {
  ------------------
  |  |  114|      2|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1185:6): [True: 2, False: 0]
  ------------------
 1186|      2|		PROTECT(R_CurrentExpr = lang1(cmd));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1187|      2|		R_CurrentExpr = eval(R_CurrentExpr, R_BaseEnv);
  ------------------
  |  |  913|      2|#define eval			Rf_eval
  ------------------
 1188|      2|		UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1189|      2|	}
 1190|      2|	UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1191|      2|    }
 1192|      2|    {
 1193|      2|	int i;
 1194|      2|	for(i = 0 ; i < ndeferred_warnings; i++)
  ------------------
  |  Branch (1194:14): [True: 0, False: 2]
  ------------------
 1195|      0|	    warning("%s", deferred_warnings[i]);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
 1196|      2|    }
 1197|      2|    if (R_CollectWarnings) {
  ------------------
  |  Branch (1197:9): [True: 0, False: 2]
  ------------------
 1198|      0|	REprintf(_("During startup - "));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1199|      0|	PrintWarnings();
  ------------------
  |  | 1977|      0|# define PrintWarnings		Rf_PrintWarnings
  ------------------
 1200|      0|    }
 1201|      2|    if(R_Verbose)
  ------------------
  |  Branch (1201:8): [True: 0, False: 2]
  ------------------
 1202|      0|	REprintf(" ending setup_Rmainloop(): R_Interactive = %d {main.c}\n",
 1203|      0|		 R_Interactive);
 1204|       |
 1205|       |    /* trying to do this earlier seems to run into bootstrapping issues. */
 1206|      2|#ifndef RMIN_ONLY
 1207|      2|    doneit = 0;
 1208|      2|    if (SETJMP(R_Toplevel.cjmpbuf))
  ------------------
  |  | 1162|      2|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (1208:9): [True: 0, False: 2]
  ------------------
 1209|      0|	check_session_exit();
 1210|      2|    R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
 1211|      2|    if (!doneit) {
  ------------------
  |  Branch (1211:9): [True: 2, False: 0]
  ------------------
 1212|      2|	doneit = 1;
 1213|      2|	R_init_jit_enabled();
 1214|      2|    } else
 1215|      0|	R_Suicide(_("unable to initialize the JIT\n"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1216|      2|#endif
 1217|      2|    R_Is_Running = 2;
 1218|      2|}
main.c:R_ReplFile:
   80|      4|{
   81|      4|    ParseStatus status;
   82|      4|    int savestack;
   83|      4|    RCNTXT cntxt;
   84|       |
   85|      4|    R_InitSrcRefState(&cntxt);
   86|      4|    savestack = R_PPStackTop;
   87|    268|    for(;;) {
   88|    268|	R_PPStackTop = savestack;
   89|    268|	R_CurrentExpr = R_Parse1File(fp, 1, &status);
   90|    268|	switch (status) {
  ------------------
  |  Branch (90:10): [True: 268, False: 0]
  ------------------
   91|    160|	case PARSE_NULL:
  ------------------
  |  Branch (91:2): [True: 160, False: 108]
  ------------------
   92|    160|	    break;
   93|    104|	case PARSE_OK:
  ------------------
  |  Branch (93:2): [True: 104, False: 164]
  ------------------
   94|    104|	    R_Visible = FALSE;
   95|    104|	    R_EvalDepth = 0;
   96|    104|	    resetTimeLimits();
   97|    104|	    PROTECT(R_CurrentExpr);
  ------------------
  |  |  357|    104|#define PROTECT(s)	Rf_protect(s)
  ------------------
   98|    104|	    R_CurrentExpr = eval(R_CurrentExpr, rho);
  ------------------
  |  |  913|    104|#define eval			Rf_eval
  ------------------
   99|    104|	    SET_SYMVALUE(R_LastvalueSymbol, R_CurrentExpr);
  100|    104|	    UNPROTECT(1);
  ------------------
  |  |  358|    104|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  101|    104|	    if (R_Visible)
  ------------------
  |  Branch (101:10): [True: 0, False: 104]
  ------------------
  102|      0|		PrintValueEnv(R_CurrentExpr, rho);
  ------------------
  |  | 1972|      0|# define PrintValueEnv		Rf_PrintValueEnv
  ------------------
  103|    104|	    if( R_CollectWarnings )
  ------------------
  |  Branch (103:10): [True: 0, False: 104]
  ------------------
  104|      0|		PrintWarnings();
  ------------------
  |  | 1977|      0|# define PrintWarnings		Rf_PrintWarnings
  ------------------
  105|    104|	    break;
  106|      0|	case PARSE_ERROR:
  ------------------
  |  Branch (106:2): [True: 0, False: 268]
  ------------------
  107|      0|	    R_FinalizeSrcRefState();
  108|      0|	    parseError(R_NilValue, R_ParseError);
  109|      0|	    break;
  110|      4|	case PARSE_EOF:
  ------------------
  |  Branch (110:2): [True: 4, False: 264]
  ------------------
  111|      4|	    endcontext(&cntxt);
  ------------------
  |  | 1895|      4|# define endcontext		Rf_endcontext
  ------------------
  112|      4|	    R_FinalizeSrcRefState();
  113|      4|	    return;
  114|      0|	    break;
  115|      0|	case PARSE_INCOMPLETE:
  ------------------
  |  Branch (115:2): [True: 0, False: 268]
  ------------------
  116|       |	    /* can't happen: just here to quieten -Wall */
  117|      0|	    break;
  118|    268|	}
  119|    268|    }
  120|      4|}
main.c:R_LoadProfile:
  721|      6|{
  722|      6|    FILE * volatile fp = fparg; /* is this needed? */
  723|      6|    if (fp != NULL) {
  ------------------
  |  Branch (723:9): [True: 2, False: 4]
  ------------------
  724|      2|	if (SETJMP(R_Toplevel.cjmpbuf))
  ------------------
  |  | 1162|      2|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (724:6): [True: 0, False: 2]
  ------------------
  725|      0|	    check_session_exit();
  726|      2|	else {
  727|      2|	    R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
  728|      2|	    R_ReplFile(fp, env);
  729|      2|	}
  730|      2|	fclose(fp);
  731|      2|    }
  732|      6|}

Rf_NonNullStringMatch:
   51|  1.16M|{
   52|       |    /* "" or NA string matches nothing */
   53|  1.16M|    if (s == NA_STRING || t == NA_STRING) return FALSE;
  ------------------
  |  |  433|  2.33M|#define NA_STRING	R_NaString
  ------------------
                  if (s == NA_STRING || t == NA_STRING) return FALSE;
  ------------------
  |  |  433|  1.16M|#define NA_STRING	R_NaString
  ------------------
  |  Branch (53:9): [True: 0, False: 1.16M]
  |  Branch (53:27): [True: 0, False: 1.16M]
  ------------------
   54|  1.16M|    if (CHAR(s)[0] && CHAR(t)[0] && Seql(s, t))
  ------------------
  |  |  203|  1.16M|#define CHAR(x) R_CHAR(x)
  ------------------
                  if (CHAR(s)[0] && CHAR(t)[0] && Seql(s, t))
  ------------------
  |  |  203|  1.16M|#define CHAR(x) R_CHAR(x)
  ------------------
                  if (CHAR(s)[0] && CHAR(t)[0] && Seql(s, t))
  ------------------
  |  | 1983|  1.16M|# define Seql			Rf_Seql
  ------------------
  |  Branch (54:9): [True: 1.16M, False: 0]
  |  Branch (54:23): [True: 1.16M, False: 0]
  |  Branch (54:37): [True: 771k, False: 398k]
  ------------------
   55|   771k|	return TRUE;
   56|   398k|    else
   57|   398k|	return FALSE;
   58|  1.16M|}
Rf_psmatch:
   62|  2.70M|{
   63|  2.70M|    if (exact)
  ------------------
  |  Branch (63:9): [True: 1.54M, False: 1.15M]
  ------------------
   64|  1.54M|	return (Rboolean)!strcmp(f, t);
   65|       |    /* else */
   66|  1.15M|    while (*t) {
  ------------------
  |  Branch (66:12): [True: 1.15M, False: 0]
  ------------------
   67|  1.15M|	if (*t != *f)   return FALSE;
  ------------------
  |  Branch (67:6): [True: 1.15M, False: 559]
  ------------------
   68|    559|	t++;
   69|    559|	f++;
   70|    559|    }
   71|      0|    return TRUE;
   72|  1.15M|}
Rf_pmatch:
   94|  1.15M|{
   95|  1.15M|    SEXP f = charFromSexp(formal);
   96|  1.15M|    SEXP t = charFromSexp(tag);
   97|  1.15M|    cetype_t fenc = getCharCE(f);
  ------------------
  |  |  925|  1.15M|#define getCharCE		Rf_getCharCE
  ------------------
   98|  1.15M|    cetype_t tenc = getCharCE(t);
  ------------------
  |  |  925|  1.15M|#define getCharCE		Rf_getCharCE
  ------------------
   99|       |
  100|  1.15M|    if (fenc == tenc)
  ------------------
  |  Branch (100:9): [True: 1.15M, False: 0]
  ------------------
  101|  1.15M|	return psmatch(CHAR(f), CHAR(t), exact);
  ------------------
  |  | 1012|  1.15M|#define psmatch			Rf_psmatch
  ------------------
              	return psmatch(CHAR(f), CHAR(t), exact);
  ------------------
  |  |  203|  1.15M|#define CHAR(x) R_CHAR(x)
  ------------------
              	return psmatch(CHAR(f), CHAR(t), exact);
  ------------------
  |  |  203|  1.15M|#define CHAR(x) R_CHAR(x)
  ------------------
  102|      0|    else {
  103|      0|	const void *vmax = vmaxget();
  104|      0|	Rboolean res = psmatch(translateCharUTF8(f), translateCharUTF8(t),
  ------------------
  |  | 1012|      0|#define psmatch			Rf_psmatch
  ------------------
              	Rboolean res = psmatch(translateCharUTF8(f), translateCharUTF8(t),
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
              	Rboolean res = psmatch(translateCharUTF8(f), translateCharUTF8(t),
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  105|      0|	                       exact);
  106|      0|	vmaxset(vmax);
  107|      0|	return res;
  108|      0|    }
  109|  1.15M|}
Rf_matchArgExact:
  167|  1.54M|{
  168|  1.54M|      return matchPar_int(CHAR(PRINTNAME(tag)), list, TRUE);
  ------------------
  |  |  203|  1.54M|#define CHAR(x) R_CHAR(x)
  ------------------
  169|  1.54M|}
Rf_matchArgs_NR:
  186|  3.91M|{
  187|  3.91M|    bool seendots;
  188|  3.91M|    int i, arg_i = 0;
  189|  3.91M|    SEXP f, a, b, dots, actuals;
  190|       |
  191|  3.91M|    actuals = R_NilValue;
  192|  12.1M|    for (f = formals ; f != R_NilValue ; f = CDR(f), arg_i++) {
  ------------------
  |  Branch (192:24): [True: 8.23M, False: 3.91M]
  ------------------
  193|       |	/* CONS_NR is used since argument lists created here are only
  194|       |	   used internally and so should not increment reference
  195|       |	   counts */
  196|  8.23M|	actuals = CONS_NR(R_MissingArg, actuals);
  197|  8.23M|	SET_MISSING(actuals, 1);
  198|  8.23M|    }
  199|       |    /* We use fargused instead of ARGUSED/SET_ARGUSED on elements of
  200|       |       formals to avoid modification of the formals SEXPs.  A gc can
  201|       |       cause matchArgs_NR to be called from finalizer code, resulting in
  202|       |       another matchArgs_NR call with the same formals.  In R-2.10.x, this
  203|       |       corrupted the ARGUSED data of the formals and resulted in an
  204|       |       incorrect "formal argument 'foo' matched by multiple actual
  205|       |       arguments" error.
  206|       |     */
  207|  3.91M|    int fargused[arg_i ? arg_i : 1]; // avoid undefined behaviour
  ------------------
  |  Branch (207:18): [True: 3.91M, False: 2.05k]
  ------------------
  208|  3.91M|    memset(fargused, 0, sizeof(fargused));
  209|       |
  210|  10.1M|    for(b = supplied; b != R_NilValue; b = CDR(b)) SET_ARGUSED(b, 0);
  ------------------
  |  |  176|  6.26M|#define SET_ARGUSED(x,v) SETLEVELS(x,v)
  ------------------
  |  Branch (210:23): [True: 6.26M, False: 3.91M]
  ------------------
  211|       |
  212|  3.91M|    PROTECT(actuals);
  ------------------
  |  |  357|  3.91M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  213|       |
  214|       |    /* First pass: exact matches by tag */
  215|       |    /* Grab matched arguments and check */
  216|       |    /* for multiple exact matches. */
  217|       |
  218|  3.91M|    f = formals;
  219|  3.91M|    a = actuals;
  220|  3.91M|    arg_i = 0;
  221|  12.1M|    while (f != R_NilValue) {
  ------------------
  |  Branch (221:12): [True: 8.23M, False: 3.91M]
  ------------------
  222|  8.23M|      SEXP ftag = TAG(f);
  223|  8.23M|      const char *ftag_name = CHAR(PRINTNAME(ftag));
  ------------------
  |  |  203|  8.23M|#define CHAR(x) R_CHAR(x)
  ------------------
  224|  8.23M|      if (ftag != R_DotsSymbol && ftag != R_NilValue) {
  ------------------
  |  Branch (224:11): [True: 6.69M, False: 1.54M]
  |  Branch (224:35): [True: 6.69M, False: 0]
  ------------------
  225|  17.3M|	    for (b = supplied, i = 1; b != R_NilValue; b = CDR(b), i++) {
  ------------------
  |  Branch (225:32): [True: 10.7M, False: 6.69M]
  ------------------
  226|  10.7M|	      SEXP btag = TAG(b);
  227|  10.7M|	      if (btag != R_NilValue) {
  ------------------
  |  Branch (227:12): [True: 3.14M, False: 7.56M]
  ------------------
  228|  3.14M|		  const char *btag_name = CHAR(PRINTNAME(btag));
  ------------------
  |  |  203|  3.14M|#define CHAR(x) R_CHAR(x)
  ------------------
  229|  3.14M|		  if (streql( ftag_name, btag_name )) {
  ------------------
  |  | 1498|  3.14M|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 396k, False: 2.74M]
  |  |  ------------------
  ------------------
  230|   396k|		      if (fargused[arg_i] == 2)
  ------------------
  |  Branch (230:13): [True: 0, False: 396k]
  ------------------
  231|      0|			  errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  232|      0|	                      _("formal argument \"%s\" matched by multiple actual arguments"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  233|      0|	                      CHAR(PRINTNAME(TAG(f))));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  234|   396k|		      if (ARGUSED(b) == 2)
  ------------------
  |  |  175|   396k|#define ARGUSED(x) LEVELS(x)
  ------------------
  |  Branch (234:13): [True: 0, False: 396k]
  ------------------
  235|      0|			  errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  236|      0|	                      _("argument %d matches multiple formal arguments"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  237|      0|                              i);
  238|   396k|		      SETCAR(a, CAR(b));
  239|   396k|		      if(CAR(b) != R_MissingArg) SET_MISSING(a, 0);
  ------------------
  |  Branch (239:12): [True: 396k, False: 0]
  ------------------
  240|   396k|		      SET_ARGUSED(b, 2);
  ------------------
  |  |  176|   396k|#define SET_ARGUSED(x,v) SETLEVELS(x,v)
  ------------------
  241|   396k|		      fargused[arg_i] = 2;
  242|   396k|		  }
  243|  3.14M|	      }
  244|  10.7M|	    }
  245|  6.69M|	}
  246|  8.23M|	f = CDR(f);
  247|  8.23M|	a = CDR(a);
  248|  8.23M|        arg_i++;
  249|  8.23M|    }
  250|       |
  251|       |    /* Second pass: partial matches based on tags */
  252|       |    /* An exact match is required after first ... */
  253|       |    /* The location of the first ... is saved in "dots" */
  254|       |
  255|  3.91M|    dots = R_NilValue;
  256|  3.91M|    seendots = FALSE;
  257|  3.91M|    f = formals;
  258|  3.91M|    a = actuals;
  259|  3.91M|    arg_i = 0;
  260|  12.1M|    while (f != R_NilValue) {
  ------------------
  |  Branch (260:12): [True: 8.23M, False: 3.91M]
  ------------------
  261|  8.23M|	if (fargused[arg_i] == 0) {
  ------------------
  |  Branch (261:6): [True: 7.84M, False: 396k]
  ------------------
  262|  7.84M|	    if (TAG(f) == R_DotsSymbol && !seendots) {
  ------------------
  |  Branch (262:10): [True: 1.54M, False: 6.29M]
  |  Branch (262:36): [True: 1.54M, False: 0]
  ------------------
  263|       |		/* Record where ... value goes */
  264|  1.54M|		dots = a;
  265|  1.54M|		seendots = TRUE;
  266|  6.29M|	    } else {
  267|  16.5M|		for (b = supplied, i = 1; b != R_NilValue; b = CDR(b), i++) {
  ------------------
  |  Branch (267:29): [True: 10.2M, False: 6.29M]
  ------------------
  268|  10.2M|		    if (ARGUSED(b) != 2 && TAG(b) != R_NilValue &&
  ------------------
  |  |  175|  10.2M|#define ARGUSED(x) LEVELS(x)
  ------------------
  |  Branch (268:11): [True: 8.70M, False: 1.57M]
  |  Branch (268:30): [True: 1.15M, False: 7.54M]
  ------------------
  269|  1.15M|			pmatch(TAG(f), TAG(b), seendots)) {
  ------------------
  |  | 1011|  1.15M|#define pmatch			Rf_pmatch
  ------------------
  |  Branch (269:4): [True: 0, False: 1.15M]
  ------------------
  270|      0|			if (ARGUSED(b))
  ------------------
  |  |  175|      0|#define ARGUSED(x) LEVELS(x)
  |  |  ------------------
  |  |  |  Branch (175:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  271|      0|			    errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  272|      0|				_("argument %d matches multiple formal arguments"), i);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  273|      0|			if (fargused[arg_i] == 1)
  ------------------
  |  Branch (273:8): [True: 0, False: 0]
  ------------------
  274|      0|			    errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  275|      0|				_("formal argument \"%s\" matched by multiple actual arguments"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  276|      0|				CHAR(PRINTNAME(TAG(f))));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  277|      0|			if (R_warn_partial_match_args) {
  ------------------
  |  Branch (277:8): [True: 0, False: 0]
  ------------------
  278|      0|			    SEXP cond =
  279|      0|				R_makePartialArgumentMatchWarningCondition(call,
  280|      0|									   TAG(b),
  281|      0|									   TAG(f));
  282|      0|			    PROTECT(cond);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  283|      0|			    R_signalWarningCondition(cond);
  284|      0|			    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  285|      0|			}
  286|      0|			SETCAR(a, CAR(b));
  287|      0|			if (CAR(b) != R_MissingArg) SET_MISSING(a, 0);
  ------------------
  |  Branch (287:8): [True: 0, False: 0]
  ------------------
  288|      0|			SET_ARGUSED(b, 1);
  ------------------
  |  |  176|      0|#define SET_ARGUSED(x,v) SETLEVELS(x,v)
  ------------------
  289|      0|			fargused[arg_i] = 1;
  290|      0|		    }
  291|  10.2M|		}
  292|  6.29M|	    }
  293|  7.84M|	}
  294|  8.23M|	f = CDR(f);
  295|  8.23M|	a = CDR(a);
  296|  8.23M|        arg_i++;
  297|  8.23M|    }
  298|       |
  299|       |    /* Third pass: matches based on order */
  300|       |    /* All args specified in tag=value form */
  301|       |    /* have now been matched.  If we find ... */
  302|       |    /* we gobble up all the remaining args. */
  303|       |    /* Otherwise we bind untagged values in */
  304|       |    /* order to any unmatched formals. */
  305|       |
  306|  3.91M|    f = formals;
  307|  3.91M|    a = actuals;
  308|  3.91M|    b = supplied;
  309|  3.91M|    seendots = FALSE;
  310|       |
  311|  10.1M|    while (f != R_NilValue && b != R_NilValue && !seendots) {
  ------------------
  |  Branch (311:12): [True: 7.07M, False: 3.11M]
  |  Branch (311:31): [True: 6.27M, False: 796k]
  |  Branch (311:50): [True: 6.27M, False: 2.80k]
  ------------------
  312|  6.27M|	if (TAG(f) == R_DotsSymbol) {
  ------------------
  |  Branch (312:6): [True: 1.54M, False: 4.72M]
  ------------------
  313|       |	    /* Skip ... matching until all tags done */
  314|  1.54M|	    seendots = TRUE;
  315|  1.54M|	    f = CDR(f);
  316|  1.54M|	    a = CDR(a);
  317|  4.72M|	} else if (CAR(a) != R_MissingArg) {
  ------------------
  |  Branch (317:13): [True: 5.90k, False: 4.71M]
  ------------------
  318|       |	    /* Already matched by tag */
  319|       |	    /* skip to next formal */
  320|  5.90k|	    f = CDR(f);
  321|  5.90k|	    a = CDR(a);
  322|  4.71M|	} else if (ARGUSED(b) || TAG(b) != R_NilValue) {
  ------------------
  |  |  175|  9.43M|#define ARGUSED(x) LEVELS(x)
  |  |  ------------------
  |  |  |  Branch (175:20): [True: 394k, False: 4.32M]
  |  |  ------------------
  ------------------
  |  Branch (322:27): [True: 12, False: 4.32M]
  ------------------
  323|       |	    /* This value used or tagged , skip to next value */
  324|       |	    /* The second test above is needed because we */
  325|       |	    /* shouldn't consider tagged values for positional */
  326|       |	    /* matches. */
  327|       |	    /* The formal being considered remains the same */
  328|   394k|	    b = CDR(b);
  329|  4.32M|	} else {
  330|       |	    /* We have a positional match */
  331|  4.32M|	    SETCAR(a, CAR(b));
  332|  4.32M|	    if(CAR(b) != R_MissingArg) SET_MISSING(a, 0);
  ------------------
  |  Branch (332:9): [True: 4.32M, False: 8]
  ------------------
  333|  4.32M|	    SET_ARGUSED(b, 1);
  ------------------
  |  |  176|  4.32M|#define SET_ARGUSED(x,v) SETLEVELS(x,v)
  ------------------
  334|  4.32M|	    b = CDR(b);
  335|  4.32M|	    f = CDR(f);
  336|  4.32M|	    a = CDR(a);
  337|  4.32M|	}
  338|  6.27M|    }
  339|       |
  340|  3.91M|    if (dots != R_NilValue) {
  ------------------
  |  Branch (340:9): [True: 1.54M, False: 2.36M]
  ------------------
  341|       |	/* Gobble up all unused actuals */
  342|  1.54M|	SET_MISSING(dots, 0);
  343|  1.54M|	i = 0;
  344|  4.26M|	for(a = supplied; a != R_NilValue ; a = CDR(a)) if(!ARGUSED(a)) i++;
  ------------------
  |  |  175|  2.71M|#define ARGUSED(x) LEVELS(x)
  ------------------
  |  Branch (344:20): [True: 2.71M, False: 1.54M]
  |  Branch (344:53): [True: 1.54M, False: 1.16M]
  ------------------
  345|       |
  346|  1.54M|	if (i) {
  ------------------
  |  Branch (346:6): [True: 1.54M, False: 3.23k]
  ------------------
  347|  1.54M|	    a = allocList(i);
  ------------------
  |  |  871|  1.54M|#define allocList		Rf_allocList
  ------------------
  348|  1.54M|	    SET_TYPEOF(a, DOTSXP);
  ------------------
  |  |  127|  1.54M|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  349|  1.54M|	    f = a;
  350|  4.25M|	    for(b = supplied; b != R_NilValue; b = CDR(b))
  ------------------
  |  Branch (350:24): [True: 2.70M, False: 1.54M]
  ------------------
  351|  2.70M|		if(!ARGUSED(b)) {
  ------------------
  |  |  175|  2.70M|#define ARGUSED(x) LEVELS(x)
  ------------------
  |  Branch (351:6): [True: 1.54M, False: 1.15M]
  ------------------
  352|  1.54M|		    SETCAR(f, CAR(b));
  353|  1.54M|		    SET_TAG(f, TAG(b));
  354|  1.54M|		    f = CDR(f);
  355|  1.54M|		}
  356|  1.54M|	    SETCAR(dots, a);
  357|  1.54M|	}
  358|  2.36M|    } else {
  359|       |	/* Check that all arguments are used */
  360|  5.92M|	for (b = supplied; b != R_NilValue && ARGUSED(b); b = CDR(b));
  ------------------
  |  |  175|  3.55M|#define ARGUSED(x) LEVELS(x)
  |  |  ------------------
  |  |  |  Branch (175:20): [True: 3.55M, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (360:21): [True: 3.55M, False: 2.36M]
  ------------------
  361|       |
  362|  2.36M|	if (b != R_NilValue) {
  ------------------
  |  Branch (362:6): [True: 0, False: 2.36M]
  ------------------
  363|       |            /* show bad arguments in call without evaluating them */
  364|      0|	    SEXP carB = CAR(b);
  365|      0|	    if (TYPEOF(carB) == PROMSXP) carB = PREXPR(carB);
  ------------------
  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
              	    if (TYPEOF(carB) == PROMSXP) carB = PREXPR(carB);
  ------------------
  |  |  720|      0|#define PREXPR(e) R_PromiseExpr(e)
  ------------------
  |  Branch (365:10): [True: 0, False: 0]
  ------------------
  366|      0|	    SEXP unused = PROTECT(CONS(carB, R_NilValue));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  367|      0|	    SET_TAG(unused, TAG(b));
  368|      0|	    SEXP last = unused;
  369|       |
  370|      0|            for(b = CDR(b) ; b != R_NilValue ; b = CDR(b))
  ------------------
  |  Branch (370:30): [True: 0, False: 0]
  ------------------
  371|      0|		if (!ARGUSED(b)) {
  ------------------
  |  |  175|      0|#define ARGUSED(x) LEVELS(x)
  ------------------
  |  Branch (371:7): [True: 0, False: 0]
  ------------------
  372|      0|		    SEXP carB = CAR(b);
  373|      0|		    if (TYPEOF(carB) == PROMSXP) carB = PREXPR(carB);
  ------------------
  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
              		    if (TYPEOF(carB) == PROMSXP) carB = PREXPR(carB);
  ------------------
  |  |  720|      0|#define PREXPR(e) R_PromiseExpr(e)
  ------------------
  |  Branch (373:11): [True: 0, False: 0]
  ------------------
  374|      0|		    SETCDR(last, CONS(carB, R_NilValue));
  ------------------
  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  375|      0|		    last = CDR(last);
  376|      0|		    SET_TAG(last, TAG(b));
  377|      0|		}
  378|      0|	    unsigned long len_u_args = (unsigned long) length(unused);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  379|      0|	    unused = PROTECT(deparse1line(unused, 0));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  380|      0|	    errorcall(call /* R_GlobalContext->call */,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  381|      0|		      ngettext("unused argument %s",
  382|      0|			       "unused arguments %s", len_u_args),
  383|      0|		      strchr(CHAR(asChar(unused)), '('));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  384|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  385|      0|	}
  386|  2.36M|    }
  387|  3.91M|    UNPROTECT(1);
  ------------------
  |  |  358|  3.91M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  388|  3.91M|    return(actuals);
  389|  3.91M|}
Rf_matchArgs_RC:
  393|  3.91M|{
  394|  3.91M|    SEXP args = matchArgs_NR(formals, supplied, call);
  ------------------
  |  | 1946|  3.91M|# define matchArgs_NR		Rf_matchArgs_NR
  ------------------
  395|       |    /* it would be better not to build this arglist with CONS_NR in
  396|       |       the first place */
  397|  12.1M|    for (SEXP a = args; a  != R_NilValue; a = CDR(a)) {
  ------------------
  |  Branch (397:25): [True: 8.23M, False: 3.91M]
  ------------------
  398|  8.23M|	if (! TRACKREFS(a)) {
  ------------------
  |  Branch (398:6): [True: 8.23M, False: 0]
  ------------------
  399|  8.23M|	    ENABLE_REFCNT(a);
  400|  8.23M|	    INCREMENT_REFCNT(CAR(a));
  401|  8.23M|	    INCREMENT_REFCNT(CDR(a));
  402|  8.23M|	}
  403|  8.23M|    }
  404|  3.91M|    return args;
  405|  3.91M|}
Rf_patchArgsByActuals:
  444|     16|{
  445|     16|    int i, farg_i;
  446|     16|    SEXP f, a, b, prsupplied;
  447|       |
  448|     16|    int nfarg = length(formals);
  ------------------
  |  |  987|     16|#define length(x)		Rf_length(x)
  ------------------
  449|     16|    if (!nfarg) nfarg = 1; // avoid undefined behaviour
  ------------------
  |  Branch (449:9): [True: 0, False: 16]
  ------------------
  450|     16|    fstype_t farg[nfarg];
  451|     64|    for(i = 0; i < nfarg; i++) farg[i] = FS_UNMATCHED;
  ------------------
  |  Branch (451:16): [True: 48, False: 16]
  ------------------
  452|       |
  453|       |    /* Shallow-duplicate supplied arguments */
  454|       |
  455|     16|    PROTECT(prsupplied = allocList(length(supplied)));
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
  456|     48|    for(b = supplied, a = prsupplied; b != R_NilValue; b = CDR(b), a = CDR(a)) {
  ------------------
  |  Branch (456:39): [True: 32, False: 16]
  ------------------
  457|     32|        SETCAR(a, CAR(b));
  458|     32|        SET_ARGUSED(a, 0);
  ------------------
  |  |  176|     32|#define SET_ARGUSED(x,v) SETLEVELS(x,v)
  ------------------
  459|     32|        SET_TAG(a, TAG(b));
  460|     32|    }
  461|       |
  462|       |    /* First pass: exact matches by tag */
  463|       |
  464|     16|    f = formals;
  465|     16|    farg_i = 0;
  466|     64|    while (f != R_NilValue) {
  ------------------
  |  Branch (466:12): [True: 48, False: 16]
  ------------------
  467|     48|	if (TAG(f) != R_DotsSymbol) {
  ------------------
  |  Branch (467:6): [True: 32, False: 16]
  ------------------
  468|     96|	    for (b = prsupplied; b != R_NilValue; b = CDR(b)) {
  ------------------
  |  Branch (468:27): [True: 64, False: 32]
  ------------------
  469|     64|		if (TAG(b) != R_NilValue && pmatch(TAG(f), TAG(b), 1)) {
  ------------------
  |  | 1011|      0|#define pmatch			Rf_pmatch
  ------------------
  |  Branch (469:7): [True: 0, False: 64]
  |  Branch (469:31): [True: 0, False: 0]
  ------------------
  470|      0|		    patchArgument(b, TAG(f), &farg[farg_i], cloenv);
  471|      0|		    SET_ARGUSED(b, 2);
  ------------------
  |  |  176|      0|#define SET_ARGUSED(x,v) SETLEVELS(x,v)
  ------------------
  472|      0|		    break; /* Previous invocation of matchArgs_NR */
  473|       |		           /* ensured unique matches */
  474|      0|		}
  475|     64|	    }
  476|     32|	}
  477|     48|	f = CDR(f);
  478|     48|	farg_i++;
  479|     48|    }
  480|       |
  481|       |    /* Second pass: partial matches based on tags */
  482|       |    /* An exact match is required after first ... */
  483|       |    /* The location of the first ... is saved in "dots" */
  484|       |
  485|     16|    Rboolean seendots = FALSE;
  486|     16|    f = formals;
  487|     16|    farg_i = 0;
  488|     64|    while (f != R_NilValue) {
  ------------------
  |  Branch (488:12): [True: 48, False: 16]
  ------------------
  489|     48|	if (farg[farg_i] == FS_UNMATCHED) {
  ------------------
  |  Branch (489:6): [True: 48, False: 0]
  ------------------
  490|     48|	    if (TAG(f) == R_DotsSymbol && !seendots) {
  ------------------
  |  Branch (490:10): [True: 16, False: 32]
  |  Branch (490:36): [True: 16, False: 0]
  ------------------
  491|     16|		seendots = TRUE;
  492|     32|	    } else {
  493|     96|		for (b = prsupplied; b != R_NilValue; b = CDR(b)) {
  ------------------
  |  Branch (493:24): [True: 64, False: 32]
  ------------------
  494|     64|		    if (!ARGUSED(b) && TAG(b) != R_NilValue &&
  ------------------
  |  |  175|    128|#define ARGUSED(x) LEVELS(x)
  ------------------
  |  Branch (494:11): [True: 64, False: 0]
  |  Branch (494:26): [True: 0, False: 64]
  ------------------
  495|      0|			pmatch(TAG(f), TAG(b), seendots)) {
  ------------------
  |  | 1011|      0|#define pmatch			Rf_pmatch
  ------------------
  |  Branch (495:4): [True: 0, False: 0]
  ------------------
  496|       |
  497|      0|			patchArgument(b, TAG(f), &farg[farg_i], cloenv);
  498|      0|			SET_ARGUSED(b, 1);
  ------------------
  |  |  176|      0|#define SET_ARGUSED(x,v) SETLEVELS(x,v)
  ------------------
  499|      0|			break; /* Previous invocation of matchArgs_NR */
  500|       |			       /* ensured unique matches */
  501|      0|		    }
  502|     64|		}
  503|     32|	    }
  504|     48|	}
  505|     48|	f = CDR(f);
  506|     48|	farg_i++;
  507|     48|    }
  508|       |
  509|       |    /* Third pass: matches based on order */
  510|       |    /* All args specified in tag=value form */
  511|       |    /* have now been matched.  If we find ... */
  512|       |    /* we gobble up all the remaining args. */
  513|       |    /* Otherwise we bind untagged values in */
  514|       |    /* order to any unmatched formals. */
  515|       |
  516|     16|    f = formals;
  517|     16|    b = prsupplied;
  518|     16|    farg_i = 0;
  519|     48|    while (f != R_NilValue && b != R_NilValue) {
  ------------------
  |  Branch (519:12): [True: 48, False: 0]
  |  Branch (519:31): [True: 32, False: 16]
  ------------------
  520|     32|	if (TAG(f) == R_DotsSymbol) {
  ------------------
  |  Branch (520:6): [True: 0, False: 32]
  ------------------
  521|       |	    /* Done, ... and following args cannot be patched */
  522|      0|	    break;
  523|     32|	} else if (farg[farg_i] == FS_MATCHED_PRESENT) {
  ------------------
  |  Branch (523:13): [True: 0, False: 32]
  ------------------
  524|       |	    /* Note that this check corresponds to CAR(b) == R_MissingArg */
  525|       |	    /* in matchArgs_NR */
  526|       |
  527|       |	    /* Already matched by tag */
  528|       |	    /* skip to next formal */
  529|      0|	    f = CDR(f);
  530|      0|	    farg_i++;
  531|     32|	} else if (ARGUSED(b) || TAG(b) != R_NilValue) {
  ------------------
  |  |  175|     64|#define ARGUSED(x) LEVELS(x)
  |  |  ------------------
  |  |  |  Branch (175:20): [True: 0, False: 32]
  |  |  ------------------
  ------------------
  |  Branch (531:27): [True: 0, False: 32]
  ------------------
  532|       |	    /* This value is used or tagged, skip to next value */
  533|       |	    /* The second test above is needed because we */
  534|       |	    /* shouldn't consider tagged values for positional */
  535|       |	    /* matches. */
  536|       |	    /* The formal being considered remains the same */
  537|      0|	    b = CDR(b);
  538|     32|	} else {
  539|       |	    /* We have a positional match */
  540|     32|	    if (farg[farg_i] == FS_MATCHED_LOCAL)
  ------------------
  |  Branch (540:10): [True: 0, False: 32]
  ------------------
  541|       |	        /* Another supplied argument, a missing with a tag, has */
  542|       |	        /* been patched to a promise reading this formal, because */
  543|       |	        /* there was a local variable of that name. Hence, we have */
  544|       |	        /* to turn this supplied argument into a missing. */
  545|       |	        /* Otherwise, we would supply a value twice, confusing */
  546|       |	        /* argument matching in subsequently called functions. */
  547|      0|	        SETCAR(b, R_MissingArg);
  548|     32|	    else
  549|     32|	        patchArgument(b, TAG(f), NULL, cloenv);
  550|       |
  551|     32|	    SET_ARGUSED(b, 1);
  ------------------
  |  |  176|     32|#define SET_ARGUSED(x,v) SETLEVELS(x,v)
  ------------------
  552|     32|	    b = CDR(b);
  553|     32|	    f = CDR(f);
  554|     32|	    farg_i++;
  555|     32|	}
  556|     32|    }
  557|       |
  558|       |    /* Previous invocation of matchArgs_NR ensured all args are used */
  559|     16|    UNPROTECT(1);
  ------------------
  |  |  358|     16|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  560|     16|    return(prsupplied);
  561|     16|}
match.c:charFromSexp:
   78|  2.31M|{
   79|  2.31M|    switch (TYPEOF(s)) {
   80|  2.31M|    case SYMSXP:
  ------------------
  |  |  112|  2.31M|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (80:5): [True: 2.31M, False: 1.37k]
  ------------------
   81|  2.31M|	return PRINTNAME(s);
   82|  1.37k|    case CHARSXP:
  ------------------
  |  |  120|  1.37k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (82:5): [True: 1.37k, False: 2.31M]
  ------------------
   83|  1.37k|	return s;
   84|      0|    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (84:5): [True: 0, False: 2.31M]
  ------------------
   85|      0|	if (LENGTH(s) == 1)
  ------------------
  |  Branch (85:6): [True: 0, False: 0]
  ------------------
   86|      0|	    return STRING_ELT(s, 0);
   87|       |	/* fall back to error */
   88|      0|    default:
  ------------------
  |  Branch (88:5): [True: 0, False: 2.31M]
  ------------------
   89|      0|	error(_("invalid partial string match"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid partial string match"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   90|  2.31M|    }
   91|  2.31M|}
match.c:matchPar_int:
  117|  1.54M|{
  118|  1.54M|    if (*list == R_NilValue)
  ------------------
  |  Branch (118:9): [True: 0, False: 1.54M]
  ------------------
  119|      0|	return R_MissingArg;
  120|  1.54M|    else if (TAG(*list) != R_NilValue &&
  ------------------
  |  Branch (120:14): [True: 0, False: 1.54M]
  ------------------
  121|      0|	     psmatch(tag, CHAR(PRINTNAME(TAG(*list))), exact)) {
  ------------------
  |  | 1012|      0|#define psmatch			Rf_psmatch
  ------------------
              	     psmatch(tag, CHAR(PRINTNAME(TAG(*list))), exact)) {
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (121:7): [True: 0, False: 0]
  ------------------
  122|      0|	SEXP s = *list;
  123|      0|	*list = CDR(*list);
  124|      0|	return CAR(s);
  125|      0|    }
  126|  1.54M|    else {
  127|  1.54M|	SEXP last = *list;
  128|  1.54M|	SEXP next = CDR(*list);
  129|  1.54M|	while (next != R_NilValue) {
  ------------------
  |  Branch (129:9): [True: 1.54M, False: 0]
  ------------------
  130|  1.54M|	    if (TAG(next) != R_NilValue &&
  ------------------
  |  Branch (130:10): [True: 1.54M, False: 1.00k]
  ------------------
  131|  1.54M|		psmatch(tag, CHAR(PRINTNAME(TAG(next))), exact)) {
  ------------------
  |  | 1012|  1.54M|#define psmatch			Rf_psmatch
  ------------------
              		psmatch(tag, CHAR(PRINTNAME(TAG(next))), exact)) {
  ------------------
  |  |  203|  1.54M|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (131:3): [True: 1.54M, False: 0]
  ------------------
  132|  1.54M|		SETCDR(last, CDR(next));
  133|  1.54M|		return CAR(next);
  134|  1.54M|	    }
  135|  1.00k|	    else {
  136|  1.00k|		last = next;
  137|  1.00k|		next = CDR(next);
  138|  1.00k|	    }
  139|  1.54M|	}
  140|      0|	return R_MissingArg;
  141|  1.54M|    }
  142|  1.54M|}
match.c:patchArgument:
  427|     32|void patchArgument(SEXP suppliedSlot, SEXP name, fstype_t *farg, SEXP cloenv) {
  428|     32|    SEXP value = CAR(suppliedSlot);
  429|     32|    if (value == R_MissingArg) {
  ------------------
  |  Branch (429:9): [True: 0, False: 32]
  ------------------
  430|      0|        value = R_findVarInFrame(cloenv, name);
  431|      0|        if (value == R_MissingArg) {
  ------------------
  |  Branch (431:13): [True: 0, False: 0]
  ------------------
  432|      0|            if (farg) *farg = FS_MATCHED_MISSING;
  ------------------
  |  Branch (432:17): [True: 0, False: 0]
  ------------------
  433|      0|            return;
  434|      0|        }
  435|      0|        if (farg) *farg = FS_MATCHED_LOCAL;
  ------------------
  |  Branch (435:13): [True: 0, False: 0]
  ------------------
  436|      0|    } else
  437|     32|        if (farg) *farg = FS_MATCHED_PRESENT;
  ------------------
  |  Branch (437:13): [True: 0, False: 32]
  ------------------
  438|       |
  439|     32|    SETCAR(suppliedSlot, mkPROMISE(name, cloenv));
  ------------------
  |  | 1957|     32|# define mkPROMISE		Rf_mkPROMISE
  ------------------
  440|     32|}

R_SetMaxVSize:
  430|      2|{
  431|      2|    if (size == R_SIZE_T_MAX) {
  ------------------
  |  | 1044|      2|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  |  Branch (431:9): [True: 0, False: 2]
  ------------------
  432|      0|	R_MaxVSize = R_SIZE_T_MAX;
  ------------------
  |  | 1044|      0|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  433|      0|	return TRUE;
  434|      0|    }
  435|      2|    if (vsfac == 1) {
  ------------------
  |  Branch (435:9): [True: 2, False: 0]
  ------------------
  436|      2|	if (size >= R_VSize) {
  ------------------
  |  Branch (436:6): [True: 2, False: 0]
  ------------------
  437|      2|	    R_MaxVSize = size;
  438|      2|	    return TRUE;
  439|      2|	}
  440|      2|    } else 
  441|      0|	if (size / vsfac >= R_VSize) {
  ------------------
  |  Branch (441:6): [True: 0, False: 0]
  ------------------
  442|      0|	    R_MaxVSize = (size + 1) / vsfac;
  443|      0|	    return TRUE;
  444|      0|	}
  445|      0|    return FALSE;
  446|      2|}
R_SetMaxNSize:
  454|      2|{
  455|      2|    if (size >= R_NSize) {
  ------------------
  |  Branch (455:9): [True: 2, False: 0]
  ------------------
  456|      2|	R_MaxNSize = size;
  457|      2|	return TRUE;
  458|      2|    }
  459|      0|    return FALSE;
  460|      2|}
R_SetPPSize:
  463|      2|{
  464|      2|    R_PPStackSize = (int) size;
  465|      2|}
R_MakeWeakRef:
 1464|  1.56k|{
 1465|  1.56k|    switch (TYPEOF(fin)) {
  ------------------
  |  |  233|  1.56k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
 1466|  1.56k|    case NILSXP:
  ------------------
  |  |  111|  1.56k|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1466:5): [True: 1.56k, False: 0]
  ------------------
 1467|  1.56k|    case CLOSXP:
  ------------------
  |  |  114|  1.56k|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1467:5): [True: 0, False: 1.56k]
  ------------------
 1468|  1.56k|    case BUILTINSXP:
  ------------------
  |  |  119|  1.56k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (1468:5): [True: 0, False: 1.56k]
  ------------------
 1469|  1.56k|    case SPECIALSXP:
  ------------------
  |  |  118|  1.56k|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (1469:5): [True: 0, False: 1.56k]
  ------------------
 1470|  1.56k|	break;
 1471|      0|    default: error(_("finalizer must be a function or NULL"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  default: error(_("finalizer must be a function or NULL"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (1471:5): [True: 0, False: 1.56k]
  ------------------
 1472|  1.56k|    }
 1473|  1.56k|    return NewWeakRef(key, val, fin, onexit);
 1474|  1.56k|}
R_MakeWeakRefC:
 1477|    866|{
 1478|    866|    SEXP w;
 1479|    866|    PROTECT(key);
  ------------------
  |  |  357|    866|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1480|    866|    PROTECT(val);
  ------------------
  |  |  357|    866|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1481|    866|    w = NewWeakRef(key, val, MakeCFinalizer(fin), onexit);
 1482|    866|    UNPROTECT(2);
  ------------------
  |  |  358|    866|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1483|    866|    return w;
 1484|    866|}
R_WeakRefKey:
 1525|  61.3k|{
 1526|  61.3k|    if (TYPEOF(w) != WEAKREFSXP)
  ------------------
  |  |  233|  61.3k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if (TYPEOF(w) != WEAKREFSXP)
  ------------------
  |  |  135|  61.3k|#define WEAKREFSXP  23    /* weak reference */
  ------------------
  |  Branch (1526:9): [True: 0, False: 61.3k]
  ------------------
 1527|      0|	error(_("not a weak reference"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not a weak reference"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1528|  61.3k|    return WEAKREF_KEY(w);
  ------------------
  |  | 1414|  61.3k|#define WEAKREF_KEY(w) VECTOR_ELT_0(w, 0)
  |  |  ------------------
  |  |  |  |   80|  61.3k|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  |  |  ------------------
  |  |  |  |  |  |  420|  61.3k|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1529|  61.3k|}
R_RunWeakRefFinalizer:
 1543|     65|{
 1544|     65|    SEXP key, fun, e;
 1545|     65|    if (TYPEOF(w) != WEAKREFSXP)
  ------------------
  |  |  233|     65|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if (TYPEOF(w) != WEAKREFSXP)
  ------------------
  |  |  135|     65|#define WEAKREFSXP  23    /* weak reference */
  ------------------
  |  Branch (1545:9): [True: 0, False: 65]
  ------------------
 1546|      0|	error(_("not a weak reference"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not a weak reference"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1547|     65|    key = WEAKREF_KEY(w);
  ------------------
  |  | 1414|     65|#define WEAKREF_KEY(w) VECTOR_ELT_0(w, 0)
  |  |  ------------------
  |  |  |  |   80|     65|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  |  |  ------------------
  |  |  |  |  |  |  420|     65|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1548|     65|    fun = WEAKREF_FINALIZER(w);
  ------------------
  |  | 1418|     65|#define WEAKREF_FINALIZER(w) VECTOR_ELT_0(w, 2)
  |  |  ------------------
  |  |  |  |   80|     65|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  |  |  ------------------
  |  |  |  |  |  |  420|     65|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1549|     65|    SET_WEAKREF_KEY(w, R_NilValue);
  ------------------
  |  | 1415|     65|#define SET_WEAKREF_KEY(w, k) SET_VECTOR_ELT(w, 0, k)
  ------------------
 1550|     65|    SET_WEAKREF_VALUE(w, R_NilValue);
  ------------------
  |  | 1417|     65|#define SET_WEAKREF_VALUE(w, v) SET_VECTOR_ELT(w, 1, v)
  ------------------
 1551|     65|    SET_WEAKREF_FINALIZER(w, R_NilValue);
  ------------------
  |  | 1419|     65|#define SET_WEAKREF_FINALIZER(w, f) SET_VECTOR_ELT(w, 2, f)
  ------------------
 1552|     65|    if (! IS_READY_TO_FINALIZE(w))
  ------------------
  |  | 1405|     65|#define IS_READY_TO_FINALIZE(s) ((s)->sxpinfo.gp & READY_TO_FINALIZE_MASK)
  |  |  ------------------
  |  |  |  | 1401|     65|#define READY_TO_FINALIZE_MASK 1
  |  |  ------------------
  ------------------
  |  Branch (1552:9): [True: 0, False: 65]
  ------------------
 1553|      0|	SET_READY_TO_FINALIZE(w); /* insures removal from list on next gc */
  ------------------
  |  | 1403|      0|#define SET_READY_TO_FINALIZE(s) ((s)->sxpinfo.gp |= READY_TO_FINALIZE_MASK)
  |  |  ------------------
  |  |  |  | 1401|      0|#define READY_TO_FINALIZE_MASK 1
  |  |  ------------------
  ------------------
 1554|     65|    PROTECT(key);
  ------------------
  |  |  357|     65|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1555|     65|    PROTECT(fun);
  ------------------
  |  |  357|     65|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1556|     65|    Rboolean oldintrsusp = R_interrupts_suspended;
 1557|     65|    R_interrupts_suspended = TRUE;
 1558|     65|    if (isCFinalizer(fun)) {
  ------------------
  |  Branch (1558:9): [True: 63, False: 2]
  ------------------
 1559|       |	/* Must be a C finalizer. */
 1560|     63|	R_CFinalizer_t cfun = GetCFinalizer(fun);
 1561|     63|	cfun(key);
 1562|     63|    }
 1563|      2|    else if (fun != R_NilValue) {
  ------------------
  |  Branch (1563:14): [True: 0, False: 2]
  ------------------
 1564|       |	/* An R finalizer. */
 1565|      0|	PROTECT(e = LCONS(fun, LCONS(key, R_NilValue)));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1566|      0|	eval(e, R_GlobalEnv);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 1567|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1568|      0|    }
 1569|     65|    R_interrupts_suspended = oldintrsusp;
 1570|     65|    UNPROTECT(2);
  ------------------
  |  |  358|     65|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1571|     65|}
R_RunPendingFinalizers:
 1662|  1.24M|{
 1663|  1.24M|    if (R_finalizers_pending)
  ------------------
  |  Branch (1663:9): [True: 3, False: 1.24M]
  ------------------
 1664|      3|	RunFinalizers();
 1665|  1.24M|}
R_RegisterCFinalizerEx:
 1678|    866|{
 1679|    866|    R_MakeWeakRefC(s, R_NilValue, fun, onexit);
 1680|    866|}
R_RegisterCFinalizer:
 1683|    778|{
 1684|    778|    R_RegisterCFinalizerEx(s, fun, FALSE);
 1685|    778|}
Rf_InitMemory:
 2248|      2|{
 2249|      2|    int i;
 2250|      2|    int gen;
 2251|      2|    char *arg;
 2252|       |
 2253|      2|    init_gctorture();
 2254|      2|    init_gc_grow_settings();
 2255|       |
 2256|      2|    arg = getenv("_R_GC_FAIL_ON_ERROR_");
 2257|      2|    if (arg != NULL && StringTrue(arg))
  ------------------
  |  |   52|      2|#define StringTrue    Rf_StringTrue
  ------------------
  |  Branch (2257:9): [True: 2, False: 0]
  |  Branch (2257:24): [True: 0, False: 2]
  ------------------
 2258|      0|	gc_fail_on_error = TRUE;
 2259|      2|    else if (arg != NULL && StringFalse(arg))
  ------------------
  |  |   51|      2|#define StringFalse   Rf_StringFalse
  ------------------
  |  Branch (2259:14): [True: 2, False: 0]
  |  Branch (2259:29): [True: 0, False: 2]
  ------------------
 2260|      0|	gc_fail_on_error = FALSE;
 2261|       |
 2262|      2|    gc_reporting = R_Verbose;
 2263|       |    //R_StandardPPStackSize = R_PPStackSize;
 2264|      2|    R_RealPPStackSize = R_PPStackSize + PP_REDZONE_SIZE;
  ------------------
  |  | 2243|      2|#define PP_REDZONE_SIZE 1000L
  ------------------
 2265|      2|    if (!(R_PPStack = (SEXP *) malloc(R_RealPPStackSize * sizeof(SEXP))))
  ------------------
  |  Branch (2265:9): [True: 0, False: 2]
  ------------------
 2266|      0|	R_Suicide("couldn't allocate memory for pointer stack");
 2267|      2|    R_PPStackTop = 0;
 2268|       |#if VALGRIND_LEVEL > 1
 2269|       |    VALGRIND_MAKE_MEM_NOACCESS(R_PPStack+R_PPStackSize, PP_REDZONE_SIZE);
 2270|       |#endif
 2271|      2|    vsfac = sizeof(VECREC);
 2272|      2|    R_VSize = (R_VSize + 1)/vsfac;
 2273|      2|    if (R_MaxVSize < R_SIZE_T_MAX) R_MaxVSize = (R_MaxVSize + 1)/vsfac;
  ------------------
  |  | 1044|      2|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  |  Branch (2273:9): [True: 2, False: 0]
  ------------------
 2274|       |
 2275|      2|    UNMARK_NODE(&UnmarkedNodeTemplate);
  ------------------
  |  |  270|      2|#define UNMARK_NODE(s) (MARK(s)=0)
  |  |  ------------------
  |  |  |  |  232|      2|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  ------------------
  ------------------
 2276|       |
 2277|     18|    for (i = 0; i < NUM_NODE_CLASSES; i++) {
  ------------------
  |  |  531|     18|#define NUM_NODE_CLASSES 8
  ------------------
  |  Branch (2277:17): [True: 16, False: 2]
  ------------------
 2278|     48|      for (gen = 0; gen < NUM_OLD_GENERATIONS; gen++) {
  ------------------
  |  |  551|     48|#define NUM_OLD_GENERATIONS 2
  ------------------
  |  Branch (2278:21): [True: 32, False: 16]
  ------------------
 2279|     32|	R_GenHeap[i].Old[gen] = &R_GenHeap[i].OldPeg[gen];
 2280|     32|	SET_PREV_NODE(R_GenHeap[i].Old[gen], R_GenHeap[i].Old[gen]);
  ------------------
  |  |  642|     32|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  ------------------
  |  |  |  |  640|     32|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  ------------------
 2281|     32|	SET_NEXT_NODE(R_GenHeap[i].Old[gen], R_GenHeap[i].Old[gen]);
  ------------------
  |  |  641|     32|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  ------------------
  |  |  |  |  639|     32|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  ------------------
 2282|       |
 2283|     32|#ifndef EXPEL_OLD_TO_NEW
 2284|     32|	R_GenHeap[i].OldToNew[gen] = &R_GenHeap[i].OldToNewPeg[gen];
 2285|     32|	SET_PREV_NODE(R_GenHeap[i].OldToNew[gen], R_GenHeap[i].OldToNew[gen]);
  ------------------
  |  |  642|     32|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  ------------------
  |  |  |  |  640|     32|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  ------------------
 2286|     32|	SET_NEXT_NODE(R_GenHeap[i].OldToNew[gen], R_GenHeap[i].OldToNew[gen]);
  ------------------
  |  |  641|     32|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  ------------------
  |  |  |  |  639|     32|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  ------------------
 2287|     32|#endif
 2288|       |
 2289|     32|	R_GenHeap[i].OldCount[gen] = 0;
 2290|     32|      }
 2291|     16|      R_GenHeap[i].New = &R_GenHeap[i].NewPeg;
 2292|     16|      SET_PREV_NODE(R_GenHeap[i].New, R_GenHeap[i].New);
  ------------------
  |  |  642|     16|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  ------------------
  |  |  |  |  640|     16|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  ------------------
 2293|     16|      SET_NEXT_NODE(R_GenHeap[i].New, R_GenHeap[i].New);
  ------------------
  |  |  641|     16|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  ------------------
  |  |  |  |  639|     16|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  ------------------
 2294|     16|    }
 2295|       |
 2296|     18|    for (i = 0; i < NUM_NODE_CLASSES; i++)
  ------------------
  |  |  531|     18|#define NUM_NODE_CLASSES 8
  ------------------
  |  Branch (2296:17): [True: 16, False: 2]
  ------------------
 2297|     16|	R_GenHeap[i].Free = NEXT_NODE(R_GenHeap[i].New);
  ------------------
  |  |  639|     16|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 2298|       |
 2299|      2|    SET_NODE_CLASS(&UnmarkedNodeTemplate, 0);
  ------------------
  |  |  546|      2|#define SET_NODE_CLASS(s,v) (((s)->sxpinfo.gccls) = (v))
  ------------------
 2300|      2|    orig_R_NSize = R_NSize;
 2301|      2|    orig_R_VSize = R_VSize;
 2302|       |
 2303|       |    /* R_NilValue */
 2304|       |    /* THIS MUST BE THE FIRST CONS CELL ALLOCATED */
 2305|       |    /* OR ARMAGEDDON HAPPENS. */
 2306|       |    /* Field assignments for R_NilValue must not go through write barrier
 2307|       |       since the write barrier prevents assignments to R_NilValue's fields.
 2308|       |       because of checks for nil */
 2309|      2|    GET_FREE_NODE(R_NilValue);
  ------------------
  |  |  858|      2|#define GET_FREE_NODE(s) CLASS_GET_FREE_NODE(0,s)
  |  |  ------------------
  |  |  |  |  846|      2|#define CLASS_GET_FREE_NODE(c,s) do { \
  |  |  |  |  847|      2|  SEXP __n__ = R_GenHeap[c].Free; \
  |  |  |  |  848|      2|  if (__n__ == R_GenHeap[c].New) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (848:7): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  849|      2|    GetNewPage(c); \
  |  |  |  |  850|      2|    __n__ = R_GenHeap[c].Free; \
  |  |  |  |  851|      2|  } \
  |  |  |  |  852|      2|  R_GenHeap[c].Free = NEXT_NODE(__n__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      2|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  |  |  853|      2|  R_NodesInUse++; \
  |  |  |  |  854|      2|  (s) = __n__; \
  |  |  |  |  855|      2|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (855:10): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2310|      2|    R_NilValue->sxpinfo = UnmarkedNodeTemplate.sxpinfo;
 2311|      2|    INIT_REFCNT(R_NilValue);
  ------------------
  |  |  982|      2|#define INIT_REFCNT(x) do {			\
  |  |  983|      2|	SEXP __x__ = (x);			\
  |  |  984|      2|	SET_REFCNT(__x__, 0);			\
  |  |  ------------------
  |  |  |  |  256|      2|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|      2|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  985|      2|	SET_TRACKREFS(__x__, TRUE);		\
  |  |  ------------------
  |  |  |  |  260|      2|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  |  |  986|      2|    } while (0)
  |  |  ------------------
  |  |  |  Branch (986:14): [Folded, False: 2]
  |  |  ------------------
  ------------------
 2312|      2|    SET_REFCNT(R_NilValue, REFCNTMAX);
  ------------------
  |  |  256|      2|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  ------------------
  |  |  |  |  248|      2|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  ------------------
 2313|      2|    SET_TYPEOF(R_NilValue, NILSXP);
  ------------------
  |  |  238|      2|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 2314|      2|    CAR0(R_NilValue) = R_NilValue;
  ------------------
  |  |  441|      2|#define CAR0(e)		((e)->u.listsxp.carval)
  ------------------
 2315|      2|    CDR(R_NilValue) = R_NilValue;
  ------------------
  |  |  445|      2|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
 2316|      2|    TAG(R_NilValue) = R_NilValue;
  ------------------
  |  |  440|      2|#define TAG(e)		((e)->u.listsxp.tagval)
  ------------------
 2317|      2|    ATTRIB(R_NilValue) = R_NilValue;
  ------------------
  |  |  230|      2|#define ATTRIB(x)	((x)->attrib)
  ------------------
 2318|      2|    MARK_NOT_MUTABLE(R_NilValue);
  ------------------
  |  |  283|      2|# define MARK_NOT_MUTABLE(x) SET_REFCNT(x, REFCNTMAX)
  |  |  ------------------
  |  |  |  |  256|      2|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|      2|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2319|       |
 2320|      2|    R_BCNodeStackBase =
 2321|      2|	(R_bcstack_t *) malloc(R_BCNODESTACKSIZE * sizeof(R_bcstack_t));
  ------------------
  |  | 1712|      2|#define R_BCNODESTACKSIZE 300000
  ------------------
 2322|      2|    if (R_BCNodeStackBase == NULL)
  ------------------
  |  Branch (2322:9): [True: 0, False: 2]
  ------------------
 2323|      0|	R_Suicide("couldn't allocate node stack");
 2324|      2|    R_BCNodeStackTop = R_BCNodeStackBase;
 2325|      2|    R_BCNodeStackEnd = R_BCNodeStackBase + R_BCNODESTACKSIZE;
  ------------------
  |  | 1712|      2|#define R_BCNODESTACKSIZE 300000
  ------------------
 2326|      2|    R_BCProtTop = R_BCNodeStackTop;
 2327|       |
 2328|      2|    R_weak_refs = R_NilValue;
 2329|       |
 2330|      2|    R_HandlerStack = R_RestartStack = R_NilValue;
 2331|       |
 2332|       |    /*  Unbound values which are to be preserved through GCs */
 2333|      2|    R_PreciousList = R_NilValue;
 2334|       |
 2335|       |    /*  The current source line */
 2336|      2|    R_Srcref = R_NilValue;
 2337|       |
 2338|       |    /* R_TrueValue and R_FalseValue */
 2339|      2|    R_TrueValue = mkTrue();
  ------------------
  |  | 1960|      2|# define mkTrue			Rf_mkTrue
  ------------------
 2340|      2|    MARK_NOT_MUTABLE(R_TrueValue);
  ------------------
  |  |  283|      2|# define MARK_NOT_MUTABLE(x) SET_REFCNT(x, REFCNTMAX)
  |  |  ------------------
  |  |  |  |  256|      2|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|      2|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2341|      2|    R_FalseValue = mkFalse();
  ------------------
  |  | 1956|      2|# define mkFalse		Rf_mkFalse
  ------------------
 2342|      2|    MARK_NOT_MUTABLE(R_FalseValue);
  ------------------
  |  |  283|      2|# define MARK_NOT_MUTABLE(x) SET_REFCNT(x, REFCNTMAX)
  |  |  ------------------
  |  |  |  |  256|      2|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|      2|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2343|      2|    R_LogicalNAValue = allocVector(LGLSXP, 1);
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
                  R_LogicalNAValue = allocVector(LGLSXP, 1);
  ------------------
  |  |  121|      2|#define LGLSXP	    10	  /* logical vectors */
  ------------------
 2344|      2|    LOGICAL(R_LogicalNAValue)[0] = NA_LOGICAL;
  ------------------
  |  |  423|      2|#define LOGICAL(x)	((int *) DATAPTR(x))
  ------------------
                  LOGICAL(R_LogicalNAValue)[0] = NA_LOGICAL;
  ------------------
  |  |   55|      2|#define NA_LOGICAL	R_NaInt
  ------------------
 2345|      2|    MARK_NOT_MUTABLE(R_LogicalNAValue);
  ------------------
  |  |  283|      2|# define MARK_NOT_MUTABLE(x) SET_REFCNT(x, REFCNTMAX)
  |  |  ------------------
  |  |  |  |  256|      2|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|      2|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2346|      2|}
vmaxget:
 2353|  19.1M|{
 2354|  19.1M|    return (void *) R_VStack;
 2355|  19.1M|}
vmaxset:
 2358|  14.8M|{
 2359|  14.8M|    R_VStack = (SEXP) ovmax;
 2360|  14.8M|}
R_alloc:
 2363|  4.07k|{
 2364|  4.07k|    R_size_t size = nelem * eltsize;
 2365|       |    /* doubles are a precaution against integer overflow on 32-bit */
 2366|  4.07k|    double dsize = (double) nelem * eltsize;
 2367|  4.07k|    if (dsize > 0) {
  ------------------
  |  Branch (2367:9): [True: 4.07k, False: 0]
  ------------------
 2368|  4.07k|	SEXP s;
 2369|  4.07k|#ifdef LONG_VECTOR_SUPPORT
 2370|       |	/* 64-bit platform: previous version used REALSXPs */
 2371|  4.07k|	if(dsize > R_XLEN_T_MAX)  /* currently 4096 TB */
  ------------------
  |  |   76|  4.07k|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (2371:5): [True: 0, False: 4.07k]
  ------------------
 2372|      0|	    error(_("cannot allocate memory block of size %0.f %s"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("cannot allocate memory block of size %0.f %s"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2373|      0|		  dsize/R_pow_di(1024.0, 4), "Tb");
 2374|  4.07k|	s = allocVector(RAWSXP, size + 1);
  ------------------
  |  |  875|  4.07k|#define allocVector		Rf_allocVector
  ------------------
              	s = allocVector(RAWSXP, size + 1);
  ------------------
  |  |  136|  4.07k|#define RAWSXP      24    /* raw bytes */
  ------------------
 2375|       |#else
 2376|       |	if(dsize > R_LEN_T_MAX) /* must be in the Gb range */
 2377|       |	    error(_("cannot allocate memory block of size %0.1f %s"),
 2378|       |		  dsize/R_pow_di(1024.0, 3), "Gb");
 2379|       |	s = allocVector(RAWSXP, size + 1);
 2380|       |#endif
 2381|  4.07k|	ATTRIB(s) = R_VStack;
  ------------------
  |  |  230|  4.07k|#define ATTRIB(x)	((x)->attrib)
  ------------------
 2382|  4.07k|	R_VStack = s;
 2383|  4.07k|	return (char *) STDVEC_DATAPTR(s);
  ------------------
  |  |  420|  4.07k|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  ------------------
 2384|  4.07k|    }
 2385|       |    /* One programmer has relied on this, but it is undocumented! */
 2386|      0|    else return NULL;
 2387|  4.07k|}
Rf_allocSExp:
 2484|  3.44M|{
 2485|  3.44M|    if (t == NILSXP)
  ------------------
  |  |  111|  3.44M|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (2485:9): [True: 0, False: 3.44M]
  ------------------
 2486|       |	/* R_NilValue should be the only NILSXP object */
 2487|      0|	return R_NilValue;
 2488|  3.44M|    SEXP s;
 2489|  3.44M|    if (FORCE_GC || NO_FREE_NODES()) {
  ------------------
  |  |  241|  6.89M|#define FORCE_GC (gc_pending || (gc_force_wait > 0 ? (--gc_force_wait > 0 ? 0 : (gc_force_wait = gc_force_gap, 1)) : 0))
  |  |  ------------------
  |  |  |  Branch (241:19): [True: 0, False: 3.44M]
  |  |  |  Branch (241:33): [True: 0, False: 3.44M]
  |  |  |  Branch (241:34): [True: 0, False: 3.44M]
  |  |  |  Branch (241:55): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  if (FORCE_GC || NO_FREE_NODES()) {
  ------------------
  |  |  857|  3.44M|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 9, False: 3.44M]
  |  |  ------------------
  ------------------
 2490|      9|	R_gc_internal(0);
 2491|      9|	if (NO_FREE_NODES())
  ------------------
  |  |  857|      9|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 0, False: 9]
  |  |  ------------------
  ------------------
 2492|      0|	    mem_err_cons();
 2493|      9|    }
 2494|  3.44M|    GET_FREE_NODE(s);
  ------------------
  |  |  858|  3.44M|#define GET_FREE_NODE(s) CLASS_GET_FREE_NODE(0,s)
  |  |  ------------------
  |  |  |  |  846|  3.44M|#define CLASS_GET_FREE_NODE(c,s) do { \
  |  |  |  |  847|  3.44M|  SEXP __n__ = R_GenHeap[c].Free; \
  |  |  |  |  848|  3.44M|  if (__n__ == R_GenHeap[c].New) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (848:7): [True: 7.66k, False: 3.44M]
  |  |  |  |  ------------------
  |  |  |  |  849|  7.66k|    GetNewPage(c); \
  |  |  |  |  850|  7.66k|    __n__ = R_GenHeap[c].Free; \
  |  |  |  |  851|  7.66k|  } \
  |  |  |  |  852|  3.44M|  R_GenHeap[c].Free = NEXT_NODE(__n__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  3.44M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  |  |  853|  3.44M|  R_NodesInUse++; \
  |  |  |  |  854|  3.44M|  (s) = __n__; \
  |  |  |  |  855|  3.44M|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (855:10): [Folded, False: 3.44M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2495|  3.44M|    s->sxpinfo = UnmarkedNodeTemplate.sxpinfo;
 2496|  3.44M|    INIT_REFCNT(s);
  ------------------
  |  |  982|  3.44M|#define INIT_REFCNT(x) do {			\
  |  |  983|  3.44M|	SEXP __x__ = (x);			\
  |  |  984|  3.44M|	SET_REFCNT(__x__, 0);			\
  |  |  ------------------
  |  |  |  |  256|  3.44M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  3.44M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  985|  3.44M|	SET_TRACKREFS(__x__, TRUE);		\
  |  |  ------------------
  |  |  |  |  260|  3.44M|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  |  |  986|  3.44M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (986:14): [Folded, False: 3.44M]
  |  |  ------------------
  ------------------
 2497|  3.44M|    SET_TYPEOF(s, t);
  ------------------
  |  |  238|  3.44M|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 2498|  3.44M|    CAR0(s) = R_NilValue;
  ------------------
  |  |  441|  3.44M|#define CAR0(e)		((e)->u.listsxp.carval)
  ------------------
 2499|  3.44M|    CDR(s) = R_NilValue;
  ------------------
  |  |  445|  3.44M|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
 2500|  3.44M|    TAG(s) = R_NilValue;
  ------------------
  |  |  440|  3.44M|#define TAG(e)		((e)->u.listsxp.tagval)
  ------------------
 2501|  3.44M|    ATTRIB(s) = R_NilValue;
  ------------------
  |  |  230|  3.44M|#define ATTRIB(x)	((x)->attrib)
  ------------------
 2502|  3.44M|    return s;
 2503|  3.44M|}
Rf_cons:
 2525|  33.4M|{
 2526|  33.4M|    SEXP s;
 2527|  33.4M|    if (FORCE_GC || NO_FREE_NODES()) {
  ------------------
  |  |  241|  66.8M|#define FORCE_GC (gc_pending || (gc_force_wait > 0 ? (--gc_force_wait > 0 ? 0 : (gc_force_wait = gc_force_gap, 1)) : 0))
  |  |  ------------------
  |  |  |  Branch (241:19): [True: 0, False: 33.4M]
  |  |  |  Branch (241:33): [True: 0, False: 33.4M]
  |  |  |  Branch (241:34): [True: 0, False: 33.4M]
  |  |  |  Branch (241:55): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  if (FORCE_GC || NO_FREE_NODES()) {
  ------------------
  |  |  857|  33.4M|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 108, False: 33.4M]
  |  |  ------------------
  ------------------
 2528|    108|	PROTECT(car);
  ------------------
  |  |  357|    108|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2529|    108|	PROTECT(cdr);
  ------------------
  |  |  357|    108|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2530|    108|	R_gc_internal(0);
 2531|    108|	UNPROTECT(2);
  ------------------
  |  |  358|    108|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2532|    108|	if (NO_FREE_NODES())
  ------------------
  |  |  857|    108|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 0, False: 108]
  |  |  ------------------
  ------------------
 2533|      0|	    mem_err_cons();
 2534|    108|    }
 2535|       |
 2536|  33.4M|    if (NEED_NEW_PAGE()) {
  ------------------
  |  |  874|  33.4M|#define NEED_NEW_PAGE() CLASS_NEED_NEW_PAGE(0)
  |  |  ------------------
  |  |  |  |  873|  33.4M|#define CLASS_NEED_NEW_PAGE(c) (R_GenHeap[c].Free == R_GenHeap[c].New)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (873:32): [True: 58.4k, False: 33.3M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2537|  58.4k|	PROTECT(car);
  ------------------
  |  |  357|  58.4k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2538|  58.4k|	PROTECT(cdr);
  ------------------
  |  |  357|  58.4k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2539|  58.4k|	GET_FREE_NODE(s);
  ------------------
  |  |  858|  58.4k|#define GET_FREE_NODE(s) CLASS_GET_FREE_NODE(0,s)
  |  |  ------------------
  |  |  |  |  846|  58.4k|#define CLASS_GET_FREE_NODE(c,s) do { \
  |  |  |  |  847|  58.4k|  SEXP __n__ = R_GenHeap[c].Free; \
  |  |  |  |  848|  58.4k|  if (__n__ == R_GenHeap[c].New) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (848:7): [True: 58.4k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  849|  58.4k|    GetNewPage(c); \
  |  |  |  |  850|  58.4k|    __n__ = R_GenHeap[c].Free; \
  |  |  |  |  851|  58.4k|  } \
  |  |  |  |  852|  58.4k|  R_GenHeap[c].Free = NEXT_NODE(__n__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  58.4k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  |  |  853|  58.4k|  R_NodesInUse++; \
  |  |  |  |  854|  58.4k|  (s) = __n__; \
  |  |  |  |  855|  58.4k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (855:10): [Folded, False: 58.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2540|  58.4k|	UNPROTECT(2);
  ------------------
  |  |  358|  58.4k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2541|  58.4k|    }
 2542|  33.3M|    else
 2543|  33.4M|	QUICK_GET_FREE_NODE(s);
  ------------------
  |  |  870|  33.3M|#define QUICK_GET_FREE_NODE(s) CLASS_QUICK_GET_FREE_NODE(0,s)
  |  |  ------------------
  |  |  |  |  861|  33.3M|#define CLASS_QUICK_GET_FREE_NODE(c,s) do {		\
  |  |  |  |  862|  33.3M|	SEXP __n__ = R_GenHeap[c].Free;			\
  |  |  |  |  863|  33.3M|	if (__n__ == R_GenHeap[c].New)			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (863:6): [True: 0, False: 33.3M]
  |  |  |  |  ------------------
  |  |  |  |  864|  33.3M|	    error("need new page - should not happen");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  865|  33.3M|	R_GenHeap[c].Free = NEXT_NODE(__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  33.3M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  |  |  866|  33.3M|	R_NodesInUse++;					\
  |  |  |  |  867|  33.3M|	(s) = __n__;					\
  |  |  |  |  868|  33.3M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (868:14): [Folded, False: 33.3M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2544|       |
 2545|  33.4M|    s->sxpinfo = UnmarkedNodeTemplate.sxpinfo;
 2546|  33.4M|    INIT_REFCNT(s);
  ------------------
  |  |  982|  33.4M|#define INIT_REFCNT(x) do {			\
  |  |  983|  33.4M|	SEXP __x__ = (x);			\
  |  |  984|  33.4M|	SET_REFCNT(__x__, 0);			\
  |  |  ------------------
  |  |  |  |  256|  33.4M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  33.4M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  985|  33.4M|	SET_TRACKREFS(__x__, TRUE);		\
  |  |  ------------------
  |  |  |  |  260|  33.4M|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  |  |  986|  33.4M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (986:14): [Folded, False: 33.4M]
  |  |  ------------------
  ------------------
 2547|  33.4M|    SET_TYPEOF(s, LISTSXP);
  ------------------
  |  |  238|  33.4M|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 2548|  33.4M|    CAR0(s) = CHK(car); if (car) INCREMENT_REFCNT(car);
  ------------------
  |  |  441|  33.4M|#define CAR0(e)		((e)->u.listsxp.carval)
  ------------------
                  CAR0(s) = CHK(car); if (car) INCREMENT_REFCNT(car);
  ------------------
  |  |  267|  33.4M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  268|  33.4M|	SEXP irc__x__ = (x);				      \
  |  |  269|  33.4M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  248|  33.4M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  195|  33.4M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  33.4M|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (269:6): [True: 14.2M, False: 19.1M]
  |  |  ------------------
  |  |  270|  33.4M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  ------------------
  |  |  |  |  256|  14.2M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  14.2M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  271|  33.4M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (271:14): [Folded, False: 33.4M]
  |  |  ------------------
  ------------------
  |  Branch (2548:29): [True: 33.4M, False: 0]
  ------------------
 2549|  33.4M|    CDR(s) = CHK(cdr); if (cdr) INCREMENT_REFCNT(cdr);
  ------------------
  |  |  445|  33.4M|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
                  CDR(s) = CHK(cdr); if (cdr) INCREMENT_REFCNT(cdr);
  ------------------
  |  |  267|  33.4M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  268|  33.4M|	SEXP irc__x__ = (x);				      \
  |  |  269|  33.4M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  248|  33.4M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  195|  33.4M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  33.4M|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (269:6): [True: 15.5M, False: 17.8M]
  |  |  ------------------
  |  |  270|  33.4M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  ------------------
  |  |  |  |  256|  15.5M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  15.5M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  271|  33.4M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (271:14): [Folded, False: 33.4M]
  |  |  ------------------
  ------------------
  |  Branch (2549:28): [True: 33.4M, False: 0]
  ------------------
 2550|  33.4M|    TAG(s) = R_NilValue;
  ------------------
  |  |  440|  33.4M|#define TAG(e)		((e)->u.listsxp.tagval)
  ------------------
 2551|  33.4M|    ATTRIB(s) = R_NilValue;
  ------------------
  |  |  230|  33.4M|#define ATTRIB(x)	((x)->attrib)
  ------------------
 2552|  33.4M|    return s;
 2553|  33.4M|}
CONS_NR:
 2556|  38.6M|{
 2557|  38.6M|    SEXP s;
 2558|  38.6M|    if (FORCE_GC || NO_FREE_NODES()) {
  ------------------
  |  |  241|  77.2M|#define FORCE_GC (gc_pending || (gc_force_wait > 0 ? (--gc_force_wait > 0 ? 0 : (gc_force_wait = gc_force_gap, 1)) : 0))
  |  |  ------------------
  |  |  |  Branch (241:19): [True: 0, False: 38.6M]
  |  |  |  Branch (241:33): [True: 0, False: 38.6M]
  |  |  |  Branch (241:34): [True: 0, False: 38.6M]
  |  |  |  Branch (241:55): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  if (FORCE_GC || NO_FREE_NODES()) {
  ------------------
  |  |  857|  38.6M|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 116, False: 38.6M]
  |  |  ------------------
  ------------------
 2559|    116|	PROTECT(car);
  ------------------
  |  |  357|    116|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2560|    116|	PROTECT(cdr);
  ------------------
  |  |  357|    116|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2561|    116|	R_gc_internal(0);
 2562|    116|	UNPROTECT(2);
  ------------------
  |  |  358|    116|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2563|    116|	if (NO_FREE_NODES())
  ------------------
  |  |  857|    116|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 0, False: 116]
  |  |  ------------------
  ------------------
 2564|      0|	    mem_err_cons();
 2565|    116|    }
 2566|       |
 2567|  38.6M|    if (NEED_NEW_PAGE()) {
  ------------------
  |  |  874|  38.6M|#define NEED_NEW_PAGE() CLASS_NEED_NEW_PAGE(0)
  |  |  ------------------
  |  |  |  |  873|  38.6M|#define CLASS_NEED_NEW_PAGE(c) (R_GenHeap[c].Free == R_GenHeap[c].New)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (873:32): [True: 67.7k, False: 38.5M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2568|  67.7k|	PROTECT(car);
  ------------------
  |  |  357|  67.7k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2569|  67.7k|	PROTECT(cdr);
  ------------------
  |  |  357|  67.7k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2570|  67.7k|	GET_FREE_NODE(s);
  ------------------
  |  |  858|  67.7k|#define GET_FREE_NODE(s) CLASS_GET_FREE_NODE(0,s)
  |  |  ------------------
  |  |  |  |  846|  67.7k|#define CLASS_GET_FREE_NODE(c,s) do { \
  |  |  |  |  847|  67.7k|  SEXP __n__ = R_GenHeap[c].Free; \
  |  |  |  |  848|  67.7k|  if (__n__ == R_GenHeap[c].New) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (848:7): [True: 67.7k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  849|  67.7k|    GetNewPage(c); \
  |  |  |  |  850|  67.7k|    __n__ = R_GenHeap[c].Free; \
  |  |  |  |  851|  67.7k|  } \
  |  |  |  |  852|  67.7k|  R_GenHeap[c].Free = NEXT_NODE(__n__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  67.7k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  |  |  853|  67.7k|  R_NodesInUse++; \
  |  |  |  |  854|  67.7k|  (s) = __n__; \
  |  |  |  |  855|  67.7k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (855:10): [Folded, False: 67.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2571|  67.7k|	UNPROTECT(2);
  ------------------
  |  |  358|  67.7k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2572|  67.7k|    }
 2573|  38.5M|    else
 2574|  38.6M|	QUICK_GET_FREE_NODE(s);
  ------------------
  |  |  870|  38.5M|#define QUICK_GET_FREE_NODE(s) CLASS_QUICK_GET_FREE_NODE(0,s)
  |  |  ------------------
  |  |  |  |  861|  38.5M|#define CLASS_QUICK_GET_FREE_NODE(c,s) do {		\
  |  |  |  |  862|  38.5M|	SEXP __n__ = R_GenHeap[c].Free;			\
  |  |  |  |  863|  38.5M|	if (__n__ == R_GenHeap[c].New)			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (863:6): [True: 0, False: 38.5M]
  |  |  |  |  ------------------
  |  |  |  |  864|  38.5M|	    error("need new page - should not happen");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  865|  38.5M|	R_GenHeap[c].Free = NEXT_NODE(__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  38.5M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  |  |  866|  38.5M|	R_NodesInUse++;					\
  |  |  |  |  867|  38.5M|	(s) = __n__;					\
  |  |  |  |  868|  38.5M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (868:14): [Folded, False: 38.5M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2575|       |
 2576|  38.6M|    s->sxpinfo = UnmarkedNodeTemplate.sxpinfo;
 2577|  38.6M|    INIT_REFCNT(s);
  ------------------
  |  |  982|  38.6M|#define INIT_REFCNT(x) do {			\
  |  |  983|  38.6M|	SEXP __x__ = (x);			\
  |  |  984|  38.6M|	SET_REFCNT(__x__, 0);			\
  |  |  ------------------
  |  |  |  |  256|  38.6M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  38.6M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  985|  38.6M|	SET_TRACKREFS(__x__, TRUE);		\
  |  |  ------------------
  |  |  |  |  260|  38.6M|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  |  |  986|  38.6M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (986:14): [Folded, False: 38.6M]
  |  |  ------------------
  ------------------
 2578|  38.6M|    DISABLE_REFCNT(s);
  ------------------
  |  |  280|  38.6M|#define DISABLE_REFCNT(x) SET_TRACKREFS(x, FALSE)
  |  |  ------------------
  |  |  |  |  260|  38.6M|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  ------------------
 2579|  38.6M|    SET_TYPEOF(s, LISTSXP);
  ------------------
  |  |  238|  38.6M|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 2580|  38.6M|    CAR0(s) = CHK(car);
  ------------------
  |  |  441|  38.6M|#define CAR0(e)		((e)->u.listsxp.carval)
  ------------------
 2581|  38.6M|    CDR(s) = CHK(cdr);
  ------------------
  |  |  445|  38.6M|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
 2582|  38.6M|    TAG(s) = R_NilValue;
  ------------------
  |  |  440|  38.6M|#define TAG(e)		((e)->u.listsxp.tagval)
  ------------------
 2583|  38.6M|    ATTRIB(s) = R_NilValue;
  ------------------
  |  |  230|  38.6M|#define ATTRIB(x)	((x)->attrib)
  ------------------
 2584|  38.6M|    return s;
 2585|  38.6M|}
Rf_NewEnvironment:
 2606|  4.69M|{
 2607|  4.69M|    SEXP v, n, newrho;
 2608|       |
 2609|  4.69M|    if (FORCE_GC || NO_FREE_NODES()) {
  ------------------
  |  |  241|  9.38M|#define FORCE_GC (gc_pending || (gc_force_wait > 0 ? (--gc_force_wait > 0 ? 0 : (gc_force_wait = gc_force_gap, 1)) : 0))
  |  |  ------------------
  |  |  |  Branch (241:19): [True: 0, False: 4.69M]
  |  |  |  Branch (241:33): [True: 0, False: 4.69M]
  |  |  |  Branch (241:34): [True: 0, False: 4.69M]
  |  |  |  Branch (241:55): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  if (FORCE_GC || NO_FREE_NODES()) {
  ------------------
  |  |  857|  4.69M|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 7, False: 4.69M]
  |  |  ------------------
  ------------------
 2610|      7|	PROTECT(namelist);
  ------------------
  |  |  357|      7|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2611|      7|	PROTECT(valuelist);
  ------------------
  |  |  357|      7|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2612|      7|	PROTECT(rho);
  ------------------
  |  |  357|      7|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2613|      7|	R_gc_internal(0);
 2614|      7|	UNPROTECT(3);
  ------------------
  |  |  358|      7|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2615|      7|	if (NO_FREE_NODES())
  ------------------
  |  |  857|      7|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 0, False: 7]
  |  |  ------------------
  ------------------
 2616|      0|	    mem_err_cons();
 2617|      7|    }
 2618|       |
 2619|  4.69M|    if (NEED_NEW_PAGE()) {
  ------------------
  |  |  874|  4.69M|#define NEED_NEW_PAGE() CLASS_NEED_NEW_PAGE(0)
  |  |  ------------------
  |  |  |  |  873|  4.69M|#define CLASS_NEED_NEW_PAGE(c) (R_GenHeap[c].Free == R_GenHeap[c].New)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (873:32): [True: 8.26k, False: 4.68M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2620|  8.26k|	PROTECT(namelist);
  ------------------
  |  |  357|  8.26k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2621|  8.26k|	PROTECT(valuelist);
  ------------------
  |  |  357|  8.26k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2622|  8.26k|	PROTECT(rho);
  ------------------
  |  |  357|  8.26k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2623|  8.26k|	GET_FREE_NODE(newrho);
  ------------------
  |  |  858|  8.26k|#define GET_FREE_NODE(s) CLASS_GET_FREE_NODE(0,s)
  |  |  ------------------
  |  |  |  |  846|  8.26k|#define CLASS_GET_FREE_NODE(c,s) do { \
  |  |  |  |  847|  8.26k|  SEXP __n__ = R_GenHeap[c].Free; \
  |  |  |  |  848|  8.26k|  if (__n__ == R_GenHeap[c].New) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (848:7): [True: 8.26k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  849|  8.26k|    GetNewPage(c); \
  |  |  |  |  850|  8.26k|    __n__ = R_GenHeap[c].Free; \
  |  |  |  |  851|  8.26k|  } \
  |  |  |  |  852|  8.26k|  R_GenHeap[c].Free = NEXT_NODE(__n__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  8.26k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  |  |  853|  8.26k|  R_NodesInUse++; \
  |  |  |  |  854|  8.26k|  (s) = __n__; \
  |  |  |  |  855|  8.26k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (855:10): [Folded, False: 8.26k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2624|  8.26k|	UNPROTECT(3);
  ------------------
  |  |  358|  8.26k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2625|  8.26k|    }
 2626|  4.68M|    else
 2627|  4.69M|	QUICK_GET_FREE_NODE(newrho);
  ------------------
  |  |  870|  4.68M|#define QUICK_GET_FREE_NODE(s) CLASS_QUICK_GET_FREE_NODE(0,s)
  |  |  ------------------
  |  |  |  |  861|  4.68M|#define CLASS_QUICK_GET_FREE_NODE(c,s) do {		\
  |  |  |  |  862|  4.68M|	SEXP __n__ = R_GenHeap[c].Free;			\
  |  |  |  |  863|  4.68M|	if (__n__ == R_GenHeap[c].New)			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (863:6): [True: 0, False: 4.68M]
  |  |  |  |  ------------------
  |  |  |  |  864|  4.68M|	    error("need new page - should not happen");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  865|  4.68M|	R_GenHeap[c].Free = NEXT_NODE(__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  4.68M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  |  |  866|  4.68M|	R_NodesInUse++;					\
  |  |  |  |  867|  4.68M|	(s) = __n__;					\
  |  |  |  |  868|  4.68M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (868:14): [Folded, False: 4.68M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2628|       |
 2629|  4.69M|    newrho->sxpinfo = UnmarkedNodeTemplate.sxpinfo;
 2630|  4.69M|    INIT_REFCNT(newrho);
  ------------------
  |  |  982|  4.69M|#define INIT_REFCNT(x) do {			\
  |  |  983|  4.69M|	SEXP __x__ = (x);			\
  |  |  984|  4.69M|	SET_REFCNT(__x__, 0);			\
  |  |  ------------------
  |  |  |  |  256|  4.69M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  4.69M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  985|  4.69M|	SET_TRACKREFS(__x__, TRUE);		\
  |  |  ------------------
  |  |  |  |  260|  4.69M|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  |  |  986|  4.69M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (986:14): [Folded, False: 4.69M]
  |  |  ------------------
  ------------------
 2631|  4.69M|    SET_TYPEOF(newrho, ENVSXP);
  ------------------
  |  |  238|  4.69M|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 2632|  4.69M|    FRAME(newrho) = valuelist; INCREMENT_REFCNT(valuelist);
  ------------------
  |  |  532|  4.69M|#define FRAME(x)	((x)->u.envsxp.frame)
  ------------------
                  FRAME(newrho) = valuelist; INCREMENT_REFCNT(valuelist);
  ------------------
  |  |  267|  4.69M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  268|  4.69M|	SEXP irc__x__ = (x);				      \
  |  |  269|  4.69M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  248|  4.69M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  195|  4.69M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  4.69M|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (269:6): [True: 3.91M, False: 779k]
  |  |  ------------------
  |  |  270|  4.69M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  ------------------
  |  |  |  |  256|  3.91M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  3.91M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  271|  4.69M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (271:14): [Folded, False: 4.69M]
  |  |  ------------------
  ------------------
 2633|  4.69M|    ENCLOS(newrho) = CHK(rho); if (rho != NULL) INCREMENT_REFCNT(rho);
  ------------------
  |  |  533|  4.69M|#define ENCLOS(x)	((x)->u.envsxp.enclos)
  ------------------
                  ENCLOS(newrho) = CHK(rho); if (rho != NULL) INCREMENT_REFCNT(rho);
  ------------------
  |  |  267|  4.69M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  268|  4.69M|	SEXP irc__x__ = (x);				      \
  |  |  269|  4.69M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  248|  4.69M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  195|  4.69M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  4.69M|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (269:6): [True: 2.33M, False: 2.35M]
  |  |  ------------------
  |  |  270|  4.69M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  ------------------
  |  |  |  |  256|  2.33M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  2.33M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  271|  4.69M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (271:14): [Folded, False: 4.69M]
  |  |  ------------------
  ------------------
  |  Branch (2633:36): [True: 4.69M, False: 0]
  ------------------
 2634|  4.69M|    HASHTAB(newrho) = R_NilValue;
  ------------------
  |  |  534|  4.69M|#define HASHTAB(x)	((x)->u.envsxp.hashtab)
  ------------------
 2635|  4.69M|    ATTRIB(newrho) = R_NilValue;
  ------------------
  |  |  230|  4.69M|#define ATTRIB(x)	((x)->attrib)
  ------------------
 2636|       |
 2637|  4.69M|    v = CHK(valuelist);
 2638|  4.69M|    n = CHK(namelist);
 2639|  12.9M|    while (v != R_NilValue && n != R_NilValue) {
  ------------------
  |  Branch (2639:12): [True: 8.23M, False: 4.69M]
  |  Branch (2639:31): [True: 8.23M, False: 0]
  ------------------
 2640|  8.23M|	SET_TAG(v, TAG(n));
  ------------------
  |  |  440|  8.23M|#define TAG(e)		((e)->u.listsxp.tagval)
  ------------------
 2641|  8.23M|	v = CDR(v);
  ------------------
  |  |  445|  8.23M|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
 2642|  8.23M|	n = CDR(n);
  ------------------
  |  |  445|  8.23M|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
 2643|  8.23M|    }
 2644|  4.69M|    return (newrho);
 2645|  4.69M|}
Rf_mkPROMISE:
 2650|  10.9M|{
 2651|  10.9M|    SEXP s;
 2652|  10.9M|    if (FORCE_GC || NO_FREE_NODES()) {
  ------------------
  |  |  241|  21.8M|#define FORCE_GC (gc_pending || (gc_force_wait > 0 ? (--gc_force_wait > 0 ? 0 : (gc_force_wait = gc_force_gap, 1)) : 0))
  |  |  ------------------
  |  |  |  Branch (241:19): [True: 0, False: 10.9M]
  |  |  |  Branch (241:33): [True: 0, False: 10.9M]
  |  |  |  Branch (241:34): [True: 0, False: 10.9M]
  |  |  |  Branch (241:55): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  if (FORCE_GC || NO_FREE_NODES()) {
  ------------------
  |  |  857|  10.9M|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 27, False: 10.9M]
  |  |  ------------------
  ------------------
 2653|     27|	PROTECT(expr);
  ------------------
  |  |  357|     27|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2654|     27|	PROTECT(rho);
  ------------------
  |  |  357|     27|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2655|     27|	R_gc_internal(0);
 2656|     27|	UNPROTECT(2);
  ------------------
  |  |  358|     27|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2657|     27|	if (NO_FREE_NODES())
  ------------------
  |  |  857|     27|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 0, False: 27]
  |  |  ------------------
  ------------------
 2658|      0|	    mem_err_cons();
 2659|     27|    }
 2660|       |
 2661|  10.9M|    if (NEED_NEW_PAGE()) {
  ------------------
  |  |  874|  10.9M|#define NEED_NEW_PAGE() CLASS_NEED_NEW_PAGE(0)
  |  |  ------------------
  |  |  |  |  873|  10.9M|#define CLASS_NEED_NEW_PAGE(c) (R_GenHeap[c].Free == R_GenHeap[c].New)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (873:32): [True: 19.3k, False: 10.9M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2662|  19.3k|	PROTECT(expr);
  ------------------
  |  |  357|  19.3k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2663|  19.3k|	PROTECT(rho);
  ------------------
  |  |  357|  19.3k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2664|  19.3k|	GET_FREE_NODE(s);
  ------------------
  |  |  858|  19.3k|#define GET_FREE_NODE(s) CLASS_GET_FREE_NODE(0,s)
  |  |  ------------------
  |  |  |  |  846|  19.3k|#define CLASS_GET_FREE_NODE(c,s) do { \
  |  |  |  |  847|  19.3k|  SEXP __n__ = R_GenHeap[c].Free; \
  |  |  |  |  848|  19.3k|  if (__n__ == R_GenHeap[c].New) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (848:7): [True: 19.3k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  849|  19.3k|    GetNewPage(c); \
  |  |  |  |  850|  19.3k|    __n__ = R_GenHeap[c].Free; \
  |  |  |  |  851|  19.3k|  } \
  |  |  |  |  852|  19.3k|  R_GenHeap[c].Free = NEXT_NODE(__n__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  19.3k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  |  |  853|  19.3k|  R_NodesInUse++; \
  |  |  |  |  854|  19.3k|  (s) = __n__; \
  |  |  |  |  855|  19.3k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (855:10): [Folded, False: 19.3k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2665|  19.3k|	UNPROTECT(2);
  ------------------
  |  |  358|  19.3k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2666|  19.3k|    }
 2667|  10.9M|    else
 2668|  10.9M|	QUICK_GET_FREE_NODE(s);
  ------------------
  |  |  870|  10.9M|#define QUICK_GET_FREE_NODE(s) CLASS_QUICK_GET_FREE_NODE(0,s)
  |  |  ------------------
  |  |  |  |  861|  10.9M|#define CLASS_QUICK_GET_FREE_NODE(c,s) do {		\
  |  |  |  |  862|  10.9M|	SEXP __n__ = R_GenHeap[c].Free;			\
  |  |  |  |  863|  10.9M|	if (__n__ == R_GenHeap[c].New)			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (863:6): [True: 0, False: 10.9M]
  |  |  |  |  ------------------
  |  |  |  |  864|  10.9M|	    error("need new page - should not happen");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  865|  10.9M|	R_GenHeap[c].Free = NEXT_NODE(__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  10.9M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  |  |  866|  10.9M|	R_NodesInUse++;					\
  |  |  |  |  867|  10.9M|	(s) = __n__;					\
  |  |  |  |  868|  10.9M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (868:14): [Folded, False: 10.9M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2669|       |
 2670|       |    /* precaution to ensure code does not get modified via
 2671|       |       substitute() and the like */
 2672|  10.9M|    ENSURE_NAMEDMAX(expr);
  ------------------
  |  |  339|  10.9M|# define ENSURE_NAMEDMAX(v) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (339:43): [Folded, False: 10.9M]
  |  |  ------------------
  ------------------
 2673|       |
 2674|  10.9M|    s->sxpinfo = UnmarkedNodeTemplate.sxpinfo;
 2675|  10.9M|    INIT_REFCNT(s);
  ------------------
  |  |  982|  10.9M|#define INIT_REFCNT(x) do {			\
  |  |  983|  10.9M|	SEXP __x__ = (x);			\
  |  |  984|  10.9M|	SET_REFCNT(__x__, 0);			\
  |  |  ------------------
  |  |  |  |  256|  10.9M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  10.9M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  985|  10.9M|	SET_TRACKREFS(__x__, TRUE);		\
  |  |  ------------------
  |  |  |  |  260|  10.9M|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  |  |  986|  10.9M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (986:14): [Folded, False: 10.9M]
  |  |  ------------------
  ------------------
 2676|  10.9M|    SET_TYPEOF(s, PROMSXP);
  ------------------
  |  |  238|  10.9M|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 2677|  10.9M|    PRCODE(s) = CHK(expr); INCREMENT_REFCNT(expr);
  ------------------
  |  | 1264|  10.9M|#define PRCODE(x)	((x)->u.promsxp.expr)
  ------------------
                  PRCODE(s) = CHK(expr); INCREMENT_REFCNT(expr);
  ------------------
  |  |  267|  10.9M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  268|  10.9M|	SEXP irc__x__ = (x);				      \
  |  |  269|  10.9M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  248|  10.9M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  195|  10.9M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  10.9M|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (269:6): [True: 5.77M, False: 5.16M]
  |  |  ------------------
  |  |  270|  10.9M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  ------------------
  |  |  |  |  256|  5.77M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  5.77M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  271|  10.9M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (271:14): [Folded, False: 10.9M]
  |  |  ------------------
  ------------------
 2678|  10.9M|    PRENV(s) = CHK(rho); INCREMENT_REFCNT(rho);
  ------------------
  |  | 1265|  10.9M|#define PRENV(x)	((x)->u.promsxp.env)
  ------------------
                  PRENV(s) = CHK(rho); INCREMENT_REFCNT(rho);
  ------------------
  |  |  267|  10.9M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  268|  10.9M|	SEXP irc__x__ = (x);				      \
  |  |  269|  10.9M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  248|  10.9M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  195|  10.9M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  10.9M|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (269:6): [True: 10.1M, False: 777k]
  |  |  ------------------
  |  |  270|  10.9M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  ------------------
  |  |  |  |  256|  10.1M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  10.1M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  271|  10.9M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (271:14): [Folded, False: 10.9M]
  |  |  ------------------
  ------------------
 2679|  10.9M|    PRVALUE0(s) = R_UnboundValue;
  ------------------
  |  | 1269|  10.9M|# define PRVALUE0(x) ((x)->u.promsxp.value)
  ------------------
 2680|  10.9M|    PRSEEN(s) = 0;
  ------------------
  |  | 1266|  10.9M|#define PRSEEN(x)	((x)->sxpinfo.gp)
  ------------------
 2681|  10.9M|    ATTRIB(s) = R_NilValue;
  ------------------
  |  |  230|  10.9M|#define ATTRIB(x)	((x)->attrib)
  ------------------
 2682|  10.9M|    return s;
 2683|  10.9M|}
R_mkEVPROMISE:
 2687|  1.12k|{
 2688|  1.12k|    SEXP prom = mkPROMISE(expr, R_NilValue);
  ------------------
  |  | 1957|  1.12k|# define mkPROMISE		Rf_mkPROMISE
  ------------------
 2689|  1.12k|    SET_PRVALUE(prom, val);
 2690|  1.12k|    return prom;
 2691|  1.12k|}
R_mkEVPROMISE_NR:
 2694|   771k|{
 2695|   771k|    SEXP prom = mkPROMISE(expr, R_NilValue);
  ------------------
  |  | 1957|   771k|# define mkPROMISE		Rf_mkPROMISE
  ------------------
 2696|   771k|    DISABLE_REFCNT(prom);
  ------------------
  |  |  280|   771k|#define DISABLE_REFCNT(x) SET_TRACKREFS(x, FALSE)
  |  |  ------------------
  |  |  |  |  260|   771k|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  ------------------
 2697|   771k|    SET_PRVALUE(prom, val);
 2698|   771k|    return prom;
 2699|   771k|}
Rf_allocVector3:
 2733|  18.1M|{
 2734|  18.1M|    SEXP s;     /* For the generational collector it would be safer to
 2735|       |		   work in terms of a VECSXP here, but that would
 2736|       |		   require several casts below... */
 2737|  18.1M|    R_size_t size = 0, alloc_size, old_R_VSize;
 2738|  18.1M|    int node_class;
 2739|       |#if VALGRIND_LEVEL > 0
 2740|       |    R_size_t actual_size = 0;
 2741|       |#endif
 2742|       |
 2743|       |    /* Handle some scalars directly to improve speed. */
 2744|  18.1M|    if (length == 1) {
  ------------------
  |  Branch (2744:9): [True: 11.7M, False: 6.37M]
  ------------------
 2745|  11.7M|	switch(type) {
  ------------------
  |  Branch (2745:9): [True: 5.08M, False: 6.67M]
  ------------------
 2746|  7.56k|	case REALSXP:
  ------------------
  |  |  124|  7.56k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (2746:2): [True: 7.56k, False: 11.7M]
  ------------------
 2747|  3.50M|	case INTSXP:
  ------------------
  |  |  123|  3.50M|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2747:2): [True: 3.49M, False: 8.26M]
  ------------------
 2748|  5.08M|	case LGLSXP:
  ------------------
  |  |  121|  5.08M|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2748:2): [True: 1.57M, False: 10.1M]
  ------------------
 2749|  5.08M|	    node_class = 1;
 2750|  5.08M|	    alloc_size = NodeClassSize[1];
 2751|  5.08M|	    if (FORCE_GC || NO_FREE_NODES() || VHEAP_FREE() < alloc_size) {
  ------------------
  |  |  241|  10.1M|#define FORCE_GC (gc_pending || (gc_force_wait > 0 ? (--gc_force_wait > 0 ? 0 : (gc_force_wait = gc_force_gap, 1)) : 0))
  |  |  ------------------
  |  |  |  Branch (241:19): [True: 0, False: 5.08M]
  |  |  |  Branch (241:33): [True: 0, False: 5.08M]
  |  |  |  Branch (241:34): [True: 0, False: 5.08M]
  |  |  |  Branch (241:55): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	    if (FORCE_GC || NO_FREE_NODES() || VHEAP_FREE() < alloc_size) {
  ------------------
  |  |  857|  10.1M|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 14, False: 5.08M]
  |  |  ------------------
  ------------------
              	    if (FORCE_GC || NO_FREE_NODES() || VHEAP_FREE() < alloc_size) {
  ------------------
  |  |  596|  5.08M|#define VHEAP_FREE() (R_VSize - R_LargeVallocSize - R_SmallVallocSize)
  ------------------
  |  Branch (2751:41): [True: 0, False: 5.08M]
  ------------------
 2752|     14|		R_gc_internal(alloc_size);
 2753|     14|		if (NO_FREE_NODES())
  ------------------
  |  |  857|     14|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 0, False: 14]
  |  |  ------------------
  ------------------
 2754|      0|		    mem_err_cons();
 2755|     14|		if (VHEAP_FREE() < alloc_size)
  ------------------
  |  |  596|     14|#define VHEAP_FREE() (R_VSize - R_LargeVallocSize - R_SmallVallocSize)
  ------------------
  |  Branch (2755:7): [True: 0, False: 14]
  ------------------
 2756|      0|		    mem_err_heap(size);
 2757|     14|	    }
 2758|       |
 2759|  5.08M|	    CLASS_GET_FREE_NODE(node_class, s);
  ------------------
  |  |  846|  5.08M|#define CLASS_GET_FREE_NODE(c,s) do { \
  |  |  847|  5.08M|  SEXP __n__ = R_GenHeap[c].Free; \
  |  |  848|  5.08M|  if (__n__ == R_GenHeap[c].New) { \
  |  |  ------------------
  |  |  |  Branch (848:7): [True: 3.41k, False: 5.08M]
  |  |  ------------------
  |  |  849|  3.41k|    GetNewPage(c); \
  |  |  850|  3.41k|    __n__ = R_GenHeap[c].Free; \
  |  |  851|  3.41k|  } \
  |  |  852|  5.08M|  R_GenHeap[c].Free = NEXT_NODE(__n__); \
  |  |  ------------------
  |  |  |  |  639|  5.08M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  |  |  853|  5.08M|  R_NodesInUse++; \
  |  |  854|  5.08M|  (s) = __n__; \
  |  |  855|  5.08M|} while (0)
  |  |  ------------------
  |  |  |  Branch (855:10): [Folded, False: 5.08M]
  |  |  ------------------
  ------------------
 2760|       |#if VALGRIND_LEVEL > 1
 2761|       |	    switch(type) {
 2762|       |	    case REALSXP: actual_size = sizeof(double); break;
 2763|       |	    case INTSXP: actual_size = sizeof(int); break;
 2764|       |	    case LGLSXP: actual_size = sizeof(int); break;
 2765|       |	    }
 2766|       |	    VALGRIND_MAKE_MEM_UNDEFINED(STDVEC_DATAPTR(s), actual_size);
 2767|       |#endif
 2768|  5.08M|	    s->sxpinfo = UnmarkedNodeTemplate.sxpinfo;
 2769|  5.08M|	    SETSCALAR(s, 1);
  ------------------
  |  |  244|  5.08M|#define SETSCALAR(x, v) (((x)->sxpinfo.scalar) = (v))
  ------------------
 2770|  5.08M|	    SET_NODE_CLASS(s, node_class);
  ------------------
  |  |  546|  5.08M|#define SET_NODE_CLASS(s,v) (((s)->sxpinfo.gccls) = (v))
  ------------------
 2771|  5.08M|	    R_SmallVallocSize += alloc_size;
 2772|       |	    /* Note that we do not include the header size into VallocSize,
 2773|       |	       but it is counted into memory usage via R_NodesInUse. */
 2774|  5.08M|	    ATTRIB(s) = R_NilValue;
  ------------------
  |  |  230|  5.08M|#define ATTRIB(x)	((x)->attrib)
  ------------------
 2775|  5.08M|	    SET_TYPEOF(s, type);
  ------------------
  |  |  238|  5.08M|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 2776|  5.08M|	    SET_STDVEC_LENGTH(s, (R_len_t) length); // is 1
  ------------------
  |  |  410|  5.08M|#define SET_STDVEC_LENGTH(x,v) do {		\
  |  |  411|  5.08M|	SEXP __x__ = (x);			\
  |  |  412|  5.08M|	R_xlen_t __v__ = (v);			\
  |  |  413|  5.08M|	STDVEC_LENGTH(__x__) = __v__;		\
  |  |  ------------------
  |  |  |  |  392|  5.08M|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |  414|  5.08M|	SETSCALAR(__x__, __v__ == 1 ? 1 : 0);	\
  |  |  ------------------
  |  |  |  |  244|  10.1M|#define SETSCALAR(x, v) (((x)->sxpinfo.scalar) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (244:51): [True: 5.08M, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  415|  5.08M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (415:14): [Folded, False: 5.08M]
  |  |  ------------------
  ------------------
 2777|  5.08M|	    SET_STDVEC_TRUELENGTH(s, 0);
  ------------------
  |  |  394|  5.08M|#define SET_STDVEC_TRUELENGTH(x, v) (STDVEC_TRUELENGTH(x)=(v))
  |  |  ------------------
  |  |  |  |  393|  5.08M|#define STDVEC_TRUELENGTH(x) (((VECSEXP) (x))->vecsxp.truelength)
  |  |  ------------------
  ------------------
 2778|  5.08M|	    INIT_REFCNT(s);
  ------------------
  |  |  982|  5.08M|#define INIT_REFCNT(x) do {			\
  |  |  983|  5.08M|	SEXP __x__ = (x);			\
  |  |  984|  5.08M|	SET_REFCNT(__x__, 0);			\
  |  |  ------------------
  |  |  |  |  256|  5.08M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  5.08M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  985|  5.08M|	SET_TRACKREFS(__x__, TRUE);		\
  |  |  ------------------
  |  |  |  |  260|  5.08M|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  |  |  986|  5.08M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (986:14): [Folded, False: 5.08M]
  |  |  ------------------
  ------------------
 2779|  5.08M|	    return(s);
 2780|  11.7M|	}
 2781|  11.7M|    }
 2782|       |
 2783|  13.0M|    if (length > R_XLEN_T_MAX)
  ------------------
  |  |   76|  13.0M|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (2783:9): [True: 0, False: 13.0M]
  ------------------
 2784|      0|	error(_("cannot allocate vector of length %lld"), (long long)length);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot allocate vector of length %lld"), (long long)length);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2785|  13.0M|    else if (length < 0 )
  ------------------
  |  Branch (2785:14): [True: 0, False: 13.0M]
  ------------------
 2786|      0|	error(_("negative length vectors are not allowed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("negative length vectors are not allowed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2787|       |    /* number of vector cells to allocate */
 2788|  13.0M|    switch (type) {
 2789|     34|    case NILSXP:
  ------------------
  |  |  111|     34|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (2789:5): [True: 34, False: 13.0M]
  ------------------
 2790|     34|	return R_NilValue;
 2791|   394k|    case RAWSXP:
  ------------------
  |  |  136|   394k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (2791:5): [True: 394k, False: 12.6M]
  ------------------
 2792|   394k|	size = BYTE2VEC(length);
  ------------------
  |  | 1300|   394k|#define BYTE2VEC(n)	(((n)>0)?(((n)-1)/sizeof(VECREC)+1):0)
  |  |  ------------------
  |  |  |  Branch (1300:22): [True: 394k, False: 2]
  |  |  ------------------
  ------------------
 2793|       |#if VALGRIND_LEVEL > 0
 2794|       |	actual_size = length;
 2795|       |#endif
 2796|   394k|	break;
 2797|      0|    case CHARSXP:
  ------------------
  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (2797:5): [True: 0, False: 13.0M]
  ------------------
 2798|      0|	error("use of allocVector(CHARSXP ...) is defunct\n");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 2799|  35.7k|    case intCHARSXP:
  ------------------
  |  | 2730|  35.7k|#define intCHARSXP 73
  ------------------
  |  Branch (2799:5): [True: 35.7k, False: 13.0M]
  ------------------
 2800|  35.7k|	type = CHARSXP;
  ------------------
  |  |  120|  35.7k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
 2801|  35.7k|	size = BYTE2VEC(length + 1);
  ------------------
  |  | 1300|  35.7k|#define BYTE2VEC(n)	(((n)>0)?(((n)-1)/sizeof(VECREC)+1):0)
  |  |  ------------------
  |  |  |  Branch (1300:22): [True: 35.7k, False: 0]
  |  |  ------------------
  ------------------
 2802|       |#if VALGRIND_LEVEL > 0
 2803|       |	actual_size = length + 1;
 2804|       |#endif
 2805|  35.7k|	break;
 2806|   387k|    case LGLSXP:
  ------------------
  |  |  121|   387k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2806:5): [True: 387k, False: 12.6M]
  ------------------
 2807|   856k|    case INTSXP:
  ------------------
  |  |  123|   856k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2807:5): [True: 469k, False: 12.5M]
  ------------------
 2808|   856k|	if (length <= 0)
  ------------------
  |  Branch (2808:6): [True: 944, False: 855k]
  ------------------
 2809|    944|	    size = 0;
 2810|   855k|	else {
 2811|   855k|	    if (length > R_SIZE_T_MAX / sizeof(int))
  ------------------
  |  | 1044|   855k|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  |  Branch (2811:10): [True: 0, False: 855k]
  ------------------
 2812|      0|		error(_("cannot allocate vector of length %lld"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("cannot allocate vector of length %lld"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2813|      0|		      (long long)length);
 2814|   855k|	    size = INT2VEC(length);
  ------------------
  |  | 1301|   855k|#define INT2VEC(n)	(((n)>0)?(((n)*sizeof(int)-1)/sizeof(VECREC)+1):0)
  |  |  ------------------
  |  |  |  Branch (1301:21): [True: 855k, False: 0]
  |  |  ------------------
  ------------------
 2815|       |#if VALGRIND_LEVEL > 0
 2816|       |	    actual_size = length*sizeof(int);
 2817|       |#endif
 2818|   855k|	}
 2819|   856k|	break;
 2820|  6.17k|    case REALSXP:
  ------------------
  |  |  124|  6.17k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (2820:5): [True: 6.17k, False: 13.0M]
  ------------------
 2821|  6.17k|	if (length <= 0)
  ------------------
  |  Branch (2821:6): [True: 684, False: 5.48k]
  ------------------
 2822|    684|	    size = 0;
 2823|  5.48k|	else {
 2824|  5.48k|	    if (length > R_SIZE_T_MAX / sizeof(double))
  ------------------
  |  | 1044|  5.48k|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  |  Branch (2824:10): [True: 0, False: 5.48k]
  ------------------
 2825|      0|		error(_("cannot allocate vector of length %lld"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("cannot allocate vector of length %lld"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2826|      0|		      (long long)length);
 2827|  5.48k|	    size = FLOAT2VEC(length);
  ------------------
  |  | 1302|  5.48k|#define FLOAT2VEC(n)	(((n)>0)?(((n)*sizeof(double)-1)/sizeof(VECREC)+1):0)
  |  |  ------------------
  |  |  |  Branch (1302:23): [True: 5.48k, False: 0]
  |  |  ------------------
  ------------------
 2828|       |#if VALGRIND_LEVEL > 0
 2829|       |	    actual_size = length * sizeof(double);
 2830|       |#endif
 2831|  5.48k|	}
 2832|  6.17k|	break;
 2833|      2|    case CPLXSXP:
  ------------------
  |  |  125|      2|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (2833:5): [True: 2, False: 13.0M]
  ------------------
 2834|      2|	if (length <= 0)
  ------------------
  |  Branch (2834:6): [True: 2, False: 0]
  ------------------
 2835|      2|	    size = 0;
 2836|      0|	else {
 2837|      0|	    if (length > R_SIZE_T_MAX / sizeof(Rcomplex))
  ------------------
  |  | 1044|      0|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  |  Branch (2837:10): [True: 0, False: 0]
  ------------------
 2838|      0|		error(_("cannot allocate vector of length %lld"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("cannot allocate vector of length %lld"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2839|      0|		      (long long)length);
 2840|      0|	    size = COMPLEX2VEC(length);
  ------------------
  |  | 1303|      0|#define COMPLEX2VEC(n)	(((n)>0)?(((n)*sizeof(Rcomplex)-1)/sizeof(VECREC)+1):0)
  |  |  ------------------
  |  |  |  Branch (1303:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2841|       |#if VALGRIND_LEVEL > 0
 2842|       |	    actual_size = length * sizeof(Rcomplex);
 2843|       |#endif
 2844|      0|	}
 2845|      2|	break;
 2846|  6.68M|    case STRSXP:
  ------------------
  |  |  126|  6.68M|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2846:5): [True: 6.68M, False: 6.36M]
  ------------------
 2847|  6.68M|    case EXPRSXP:
  ------------------
  |  |  132|  6.68M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (2847:5): [True: 58, False: 13.0M]
  ------------------
 2848|  11.7M|    case VECSXP:
  ------------------
  |  |  131|  11.7M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2848:5): [True: 5.06M, False: 7.97M]
  ------------------
 2849|  11.7M|	if (length <= 0)
  ------------------
  |  Branch (2849:6): [True: 5.16k, False: 11.7M]
  ------------------
 2850|  5.16k|	    size = 0;
 2851|  11.7M|	else {
 2852|  11.7M|	    if (length > R_SIZE_T_MAX / sizeof(SEXP))
  ------------------
  |  | 1044|  11.7M|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  |  Branch (2852:10): [True: 0, False: 11.7M]
  ------------------
 2853|      0|		error(_("cannot allocate vector of length %lld"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("cannot allocate vector of length %lld"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2854|      0|		      (long long)length);
 2855|  11.7M|	    size = PTR2VEC(length);
  ------------------
  |  | 1304|  11.7M|#define PTR2VEC(n)	(((n)>0)?(((n)*sizeof(SEXP)-1)/sizeof(VECREC)+1):0)
  |  |  ------------------
  |  |  |  Branch (1304:21): [True: 11.7M, False: 0]
  |  |  ------------------
  ------------------
 2856|       |#if VALGRIND_LEVEL > 0
 2857|       |	    actual_size = length * sizeof(SEXP);
 2858|       |#endif
 2859|  11.7M|	}
 2860|  11.7M|	break;
 2861|      0|    case LANGSXP:
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (2861:5): [True: 0, False: 13.0M]
  ------------------
 2862|      0|	if(length == 0) return R_NilValue;
  ------------------
  |  Branch (2862:5): [True: 0, False: 0]
  ------------------
 2863|      0|#ifdef LONG_VECTOR_SUPPORT
 2864|      0|	if (length > R_SHORT_LEN_MAX) error("invalid length for pairlist");
  ------------------
  |  |   77|      0|# define R_SHORT_LEN_MAX 2147483647
  ------------------
              	if (length > R_SHORT_LEN_MAX) error("invalid length for pairlist");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (2864:6): [True: 0, False: 0]
  ------------------
 2865|      0|#endif
 2866|      0|	s = allocList((int) length);
  ------------------
  |  |  871|      0|#define allocList		Rf_allocList
  ------------------
 2867|      0|	SET_TYPEOF(s, LANGSXP);
  ------------------
  |  |  238|      0|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 2868|      0|	return s;
 2869|      0|    case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2869:5): [True: 0, False: 13.0M]
  ------------------
 2870|      0|#ifdef LONG_VECTOR_SUPPORT
 2871|      0|	if (length > R_SHORT_LEN_MAX) error("invalid length for pairlist");
  ------------------
  |  |   77|      0|# define R_SHORT_LEN_MAX 2147483647
  ------------------
              	if (length > R_SHORT_LEN_MAX) error("invalid length for pairlist");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (2871:6): [True: 0, False: 0]
  ------------------
 2872|      0|#endif
 2873|      0|	return allocList((int) length);
  ------------------
  |  |  871|      0|#define allocList		Rf_allocList
  ------------------
 2874|      0|    default:
  ------------------
  |  Branch (2874:5): [True: 0, False: 13.0M]
  ------------------
 2875|      0|	error(_("invalid type/length (%s/%lld) in vector allocation"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid type/length (%s/%lld) in vector allocation"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2876|      0|	      type2char(type), (long long)length);
  ------------------
  |  | 1040|      0|#define type2char		Rf_type2char
  ------------------
 2877|  13.0M|    }
 2878|       |
 2879|  13.0M|    if (allocator) {
  ------------------
  |  Branch (2879:9): [True: 0, False: 13.0M]
  ------------------
 2880|      0|	node_class = CUSTOM_NODE_CLASS;
  ------------------
  |  |  539|      0|#define CUSTOM_NODE_CLASS (NUM_NODE_CLASSES - 2)
  |  |  ------------------
  |  |  |  |  531|      0|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
 2881|      0|	alloc_size = size;
 2882|  13.0M|    } else {
 2883|  13.0M|	if (size <= NodeClassSize[1]) {
  ------------------
  |  Branch (2883:6): [True: 7.09M, False: 5.94M]
  ------------------
 2884|  7.09M|	    node_class = 1;
 2885|  7.09M|	    alloc_size = NodeClassSize[1];
 2886|  7.09M|	}
 2887|  5.94M|	else {
 2888|  5.94M|	    node_class = LARGE_NODE_CLASS;
  ------------------
  |  |  538|  5.94M|#define LARGE_NODE_CLASS  (NUM_NODE_CLASSES - 1)
  |  |  ------------------
  |  |  |  |  531|  5.94M|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
 2889|  5.94M|	    alloc_size = size;
 2890|  11.1M|	    for (int i = 2; i < NUM_SMALL_NODE_CLASSES; i++) {
  ------------------
  |  |  540|  11.1M|#define NUM_SMALL_NODE_CLASSES (NUM_NODE_CLASSES - 2)
  |  |  ------------------
  |  |  |  |  531|  11.1M|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
  |  Branch (2890:22): [True: 11.1M, False: 27.7k]
  ------------------
 2891|  11.1M|		if (size <= NodeClassSize[i]) {
  ------------------
  |  Branch (2891:7): [True: 5.92M, False: 5.24M]
  ------------------
 2892|  5.92M|		    node_class = i;
 2893|  5.92M|		    alloc_size = NodeClassSize[i];
 2894|  5.92M|		    break;
 2895|  5.92M|		}
 2896|  11.1M|	    }
 2897|  5.94M|	}
 2898|  13.0M|    }
 2899|       |
 2900|       |    /* save current R_VSize to roll back adjustment if malloc fails */
 2901|  13.0M|    old_R_VSize = R_VSize;
 2902|       |
 2903|       |    /* we need to do the gc here so allocSExp doesn't! */
 2904|  13.0M|    if (FORCE_GC || NO_FREE_NODES() || VHEAP_FREE() < alloc_size) {
  ------------------
  |  |  241|  26.0M|#define FORCE_GC (gc_pending || (gc_force_wait > 0 ? (--gc_force_wait > 0 ? 0 : (gc_force_wait = gc_force_gap, 1)) : 0))
  |  |  ------------------
  |  |  |  Branch (241:19): [True: 0, False: 13.0M]
  |  |  |  Branch (241:33): [True: 0, False: 13.0M]
  |  |  |  Branch (241:34): [True: 0, False: 13.0M]
  |  |  |  Branch (241:55): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  if (FORCE_GC || NO_FREE_NODES() || VHEAP_FREE() < alloc_size) {
  ------------------
  |  |  857|  26.0M|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 37, False: 13.0M]
  |  |  ------------------
  ------------------
                  if (FORCE_GC || NO_FREE_NODES() || VHEAP_FREE() < alloc_size) {
  ------------------
  |  |  596|  13.0M|#define VHEAP_FREE() (R_VSize - R_LargeVallocSize - R_SmallVallocSize)
  ------------------
  |  Branch (2904:40): [True: 0, False: 13.0M]
  ------------------
 2905|     37|	R_gc_internal(alloc_size);
 2906|     37|	if (NO_FREE_NODES())
  ------------------
  |  |  857|     37|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 0, False: 37]
  |  |  ------------------
  ------------------
 2907|      0|	    mem_err_cons();
 2908|     37|	if (VHEAP_FREE() < alloc_size)
  ------------------
  |  |  596|     37|#define VHEAP_FREE() (R_VSize - R_LargeVallocSize - R_SmallVallocSize)
  ------------------
  |  Branch (2908:6): [True: 0, False: 37]
  ------------------
 2909|      0|	    mem_err_heap(size);
 2910|     37|    }
 2911|       |
 2912|  13.0M|    if (size > 0) {
  ------------------
  |  Branch (2912:9): [True: 13.0M, False: 6.79k]
  ------------------
 2913|  13.0M|	if (node_class < NUM_SMALL_NODE_CLASSES) {
  ------------------
  |  |  540|  13.0M|#define NUM_SMALL_NODE_CLASSES (NUM_NODE_CLASSES - 2)
  |  |  ------------------
  |  |  |  |  531|  13.0M|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
  |  Branch (2913:6): [True: 13.0M, False: 27.7k]
  ------------------
 2914|  13.0M|	    CLASS_GET_FREE_NODE(node_class, s);
  ------------------
  |  |  846|  13.0M|#define CLASS_GET_FREE_NODE(c,s) do { \
  |  |  847|  13.0M|  SEXP __n__ = R_GenHeap[c].Free; \
  |  |  848|  13.0M|  if (__n__ == R_GenHeap[c].New) { \
  |  |  ------------------
  |  |  |  Branch (848:7): [True: 19.0k, False: 12.9M]
  |  |  ------------------
  |  |  849|  19.0k|    GetNewPage(c); \
  |  |  850|  19.0k|    __n__ = R_GenHeap[c].Free; \
  |  |  851|  19.0k|  } \
  |  |  852|  13.0M|  R_GenHeap[c].Free = NEXT_NODE(__n__); \
  |  |  ------------------
  |  |  |  |  639|  13.0M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  |  |  853|  13.0M|  R_NodesInUse++; \
  |  |  854|  13.0M|  (s) = __n__; \
  |  |  855|  13.0M|} while (0)
  |  |  ------------------
  |  |  |  Branch (855:10): [Folded, False: 13.0M]
  |  |  ------------------
  ------------------
 2915|       |#if VALGRIND_LEVEL > 1
 2916|       |	    VALGRIND_MAKE_MEM_UNDEFINED(STDVEC_DATAPTR(s), actual_size);
 2917|       |#endif
 2918|  13.0M|	    s->sxpinfo = UnmarkedNodeTemplate.sxpinfo;
 2919|  13.0M|	    INIT_REFCNT(s);
  ------------------
  |  |  982|  13.0M|#define INIT_REFCNT(x) do {			\
  |  |  983|  13.0M|	SEXP __x__ = (x);			\
  |  |  984|  13.0M|	SET_REFCNT(__x__, 0);			\
  |  |  ------------------
  |  |  |  |  256|  13.0M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  13.0M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  985|  13.0M|	SET_TRACKREFS(__x__, TRUE);		\
  |  |  ------------------
  |  |  |  |  260|  13.0M|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  |  |  986|  13.0M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (986:14): [Folded, False: 13.0M]
  |  |  ------------------
  ------------------
 2920|  13.0M|	    SET_NODE_CLASS(s, node_class);
  ------------------
  |  |  546|  13.0M|#define SET_NODE_CLASS(s,v) (((s)->sxpinfo.gccls) = (v))
  ------------------
 2921|  13.0M|	    R_SmallVallocSize += alloc_size;
 2922|  13.0M|	    SET_STDVEC_LENGTH(s, (R_len_t) length);
  ------------------
  |  |  410|  13.0M|#define SET_STDVEC_LENGTH(x,v) do {		\
  |  |  411|  13.0M|	SEXP __x__ = (x);			\
  |  |  412|  13.0M|	R_xlen_t __v__ = (v);			\
  |  |  413|  13.0M|	STDVEC_LENGTH(__x__) = __v__;		\
  |  |  ------------------
  |  |  |  |  392|  13.0M|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |  414|  13.0M|	SETSCALAR(__x__, __v__ == 1 ? 1 : 0);	\
  |  |  ------------------
  |  |  |  |  244|  26.0M|#define SETSCALAR(x, v) (((x)->sxpinfo.scalar) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (244:51): [True: 6.67M, False: 6.33M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  415|  13.0M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (415:14): [Folded, False: 13.0M]
  |  |  ------------------
  ------------------
 2923|  13.0M|	}
 2924|  27.7k|	else {
 2925|  27.7k|	    Rboolean success = FALSE;
 2926|  27.7k|	    R_size_t hdrsize = sizeof(SEXPREC_ALIGN);
 2927|  27.7k|	    void *mem = NULL; /* initialize to suppress warning */
 2928|  27.7k|	    if (size < (R_SIZE_T_MAX / sizeof(VECREC)) - hdrsize) { /*** not sure this test is quite right -- why subtract the header? LT */
  ------------------
  |  | 1044|  27.7k|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  |  Branch (2928:10): [True: 27.7k, False: 0]
  ------------------
 2929|       |		/* I think subtracting the header is fine, "size" (*VSize)
 2930|       |		   variables do not count the header, but the header is
 2931|       |		   included into memory usage via NodesInUse, instead.
 2932|       |		   We want the whole object including the header to be
 2933|       |		   indexable by size_t. - TK */
 2934|  27.7k|		mem = allocator ?
  ------------------
  |  Branch (2934:9): [True: 0, False: 27.7k]
  ------------------
 2935|      0|		    custom_node_alloc(allocator, hdrsize + size * sizeof(VECREC)) :
 2936|  27.7k|		    malloc(hdrsize + size * sizeof(VECREC));
 2937|  27.7k|		if (mem == NULL) {
  ------------------
  |  Branch (2937:7): [True: 0, False: 27.7k]
  ------------------
 2938|       |		    /* If we are near the address space limit, we
 2939|       |		       might be short of address space.  So return
 2940|       |		       all unused objects to malloc and try again. */
 2941|      0|		    R_gc_no_finalizers(alloc_size);
 2942|      0|		    mem = allocator ?
  ------------------
  |  Branch (2942:13): [True: 0, False: 0]
  ------------------
 2943|      0|			custom_node_alloc(allocator, hdrsize + size * sizeof(VECREC)) :
 2944|      0|			malloc(hdrsize + size * sizeof(VECREC));
 2945|      0|		}
 2946|  27.7k|		if (mem != NULL) {
  ------------------
  |  Branch (2946:7): [True: 27.7k, False: 0]
  ------------------
 2947|  27.7k|		    s = mem;
 2948|  27.7k|		    SET_STDVEC_LENGTH(s, length);
  ------------------
  |  |  410|  27.7k|#define SET_STDVEC_LENGTH(x,v) do {		\
  |  |  411|  27.7k|	SEXP __x__ = (x);			\
  |  |  412|  27.7k|	R_xlen_t __v__ = (v);			\
  |  |  413|  27.7k|	STDVEC_LENGTH(__x__) = __v__;		\
  |  |  ------------------
  |  |  |  |  392|  27.7k|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |  414|  27.7k|	SETSCALAR(__x__, __v__ == 1 ? 1 : 0);	\
  |  |  ------------------
  |  |  |  |  244|  55.5k|#define SETSCALAR(x, v) (((x)->sxpinfo.scalar) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (244:51): [True: 0, False: 27.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  415|  27.7k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (415:14): [Folded, False: 27.7k]
  |  |  ------------------
  ------------------
 2949|  27.7k|		    success = TRUE;
 2950|  27.7k|		}
 2951|      0|		else s = NULL;
 2952|       |#ifdef R_MEMORY_PROFILING
 2953|       |		R_ReportAllocation(hdrsize + size * sizeof(VECREC));
 2954|       |#endif
 2955|  27.7k|	    } else s = NULL; /* suppress warning */
 2956|  27.7k|	    if (! success) {
  ------------------
  |  Branch (2956:10): [True: 0, False: 27.7k]
  ------------------
 2957|      0|		double dsize = (double)size * sizeof(VECREC)/1024.0;
 2958|       |		/* reset the vector heap limit */
 2959|      0|		R_VSize = old_R_VSize;
 2960|      0|		if(dsize > 1024.0*1024.0)
  ------------------
  |  Branch (2960:6): [True: 0, False: 0]
  ------------------
 2961|      0|		    errorcall(R_NilValue,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 2962|      0|			      _("cannot allocate vector of size %0.1f %s"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2963|      0|			      dsize/1024.0/1024.0, "Gb");
 2964|      0|		if(dsize > 1024.0)
  ------------------
  |  Branch (2964:6): [True: 0, False: 0]
  ------------------
 2965|      0|		    errorcall(R_NilValue,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 2966|      0|			      _("cannot allocate vector of size %0.1f %s"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2967|      0|			      dsize/1024.0, "Mb");
 2968|      0|		else
 2969|      0|		    errorcall(R_NilValue,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 2970|      0|			      _("cannot allocate vector of size %0.f %s"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2971|      0|			      dsize, "Kb");
 2972|      0|	    }
 2973|  27.7k|	    s->sxpinfo = UnmarkedNodeTemplate.sxpinfo;
 2974|  27.7k|	    INIT_REFCNT(s);
  ------------------
  |  |  982|  27.7k|#define INIT_REFCNT(x) do {			\
  |  |  983|  27.7k|	SEXP __x__ = (x);			\
  |  |  984|  27.7k|	SET_REFCNT(__x__, 0);			\
  |  |  ------------------
  |  |  |  |  256|  27.7k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  27.7k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  985|  27.7k|	SET_TRACKREFS(__x__, TRUE);		\
  |  |  ------------------
  |  |  |  |  260|  27.7k|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  |  |  986|  27.7k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (986:14): [Folded, False: 27.7k]
  |  |  ------------------
  ------------------
 2975|  27.7k|	    SET_NODE_CLASS(s, node_class);
  ------------------
  |  |  546|  27.7k|#define SET_NODE_CLASS(s,v) (((s)->sxpinfo.gccls) = (v))
  ------------------
 2976|  27.7k|	    if (!allocator) R_LargeVallocSize += size;
  ------------------
  |  Branch (2976:10): [True: 27.7k, False: 0]
  ------------------
 2977|  27.7k|	    R_GenHeap[node_class].AllocCount++;
 2978|  27.7k|	    R_NodesInUse++;
 2979|  27.7k|	    SNAP_NODE(s, R_GenHeap[node_class].New);
  ------------------
  |  |  657|  27.7k|#define SNAP_NODE(s,t) do { \
  |  |  658|  27.7k|  SEXP sn__n__ = (s); \
  |  |  659|  27.7k|  SEXP next = (t); \
  |  |  660|  27.7k|  SEXP prev = PREV_NODE(next); \
  |  |  ------------------
  |  |  |  |  640|  27.7k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  |  |  661|  27.7k|  SET_NEXT_NODE(sn__n__, next); \
  |  |  ------------------
  |  |  |  |  641|  27.7k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  27.7k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  662|  27.7k|  SET_PREV_NODE(next, sn__n__); \
  |  |  ------------------
  |  |  |  |  642|  27.7k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  27.7k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  663|  27.7k|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  ------------------
  |  |  |  |  641|  27.7k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  27.7k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  664|  27.7k|  SET_PREV_NODE(sn__n__, prev); \
  |  |  ------------------
  |  |  |  |  642|  27.7k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  27.7k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  665|  27.7k|} while (0)
  |  |  ------------------
  |  |  |  Branch (665:10): [Folded, False: 27.7k]
  |  |  ------------------
  ------------------
 2980|  27.7k|	}
 2981|  13.0M|	ATTRIB(s) = R_NilValue;
  ------------------
  |  |  230|  13.0M|#define ATTRIB(x)	((x)->attrib)
  ------------------
 2982|  13.0M|	SET_TYPEOF(s, type);
  ------------------
  |  |  238|  13.0M|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 2983|  13.0M|    }
 2984|  6.79k|    else {
 2985|  6.79k|	GC_PROT(s = allocSExpNonCons(type));
  ------------------
  |  |  251|  6.79k|#define GC_PROT(X) do { \
  |  |  252|  6.79k|    int __wait__ = gc_force_wait; \
  |  |  253|  6.79k|    int __gap__ = gc_force_gap;			   \
  |  |  254|  6.79k|    Rboolean __release__ = gc_inhibit_release;	   \
  |  |  255|  6.79k|    X;						   \
  |  |  256|  6.79k|    gc_force_wait = __wait__;			   \
  |  |  257|  6.79k|    gc_force_gap = __gap__;			   \
  |  |  258|  6.79k|    gc_inhibit_release = __release__;		   \
  |  |  259|  6.79k|}  while(0)
  |  |  ------------------
  |  |  |  Branch (259:10): [Folded, False: 6.79k]
  |  |  ------------------
  ------------------
 2986|  6.79k|	SET_STDVEC_LENGTH(s, (R_len_t) length);
  ------------------
  |  |  410|  6.79k|#define SET_STDVEC_LENGTH(x,v) do {		\
  |  |  411|  6.79k|	SEXP __x__ = (x);			\
  |  |  412|  6.79k|	R_xlen_t __v__ = (v);			\
  |  |  413|  6.79k|	STDVEC_LENGTH(__x__) = __v__;		\
  |  |  ------------------
  |  |  |  |  392|  6.79k|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |  414|  6.79k|	SETSCALAR(__x__, __v__ == 1 ? 1 : 0);	\
  |  |  ------------------
  |  |  |  |  244|  13.5k|#define SETSCALAR(x, v) (((x)->sxpinfo.scalar) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (244:51): [True: 0, False: 6.79k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  415|  6.79k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (415:14): [Folded, False: 6.79k]
  |  |  ------------------
  ------------------
 2987|  6.79k|    }
 2988|  13.0M|    SETALTREP(s, 0);
  ------------------
  |  |  243|  13.0M|#define SETALTREP(x, v) (((x)->sxpinfo.alt) = (v))
  ------------------
 2989|  13.0M|    SET_STDVEC_TRUELENGTH(s, 0);
  ------------------
  |  |  394|  13.0M|#define SET_STDVEC_TRUELENGTH(x, v) (STDVEC_TRUELENGTH(x)=(v))
  |  |  ------------------
  |  |  |  |  393|  13.0M|#define STDVEC_TRUELENGTH(x) (((VECSEXP) (x))->vecsxp.truelength)
  |  |  ------------------
  ------------------
 2990|  13.0M|    INIT_REFCNT(s);
  ------------------
  |  |  982|  13.0M|#define INIT_REFCNT(x) do {			\
  |  |  983|  13.0M|	SEXP __x__ = (x);			\
  |  |  984|  13.0M|	SET_REFCNT(__x__, 0);			\
  |  |  ------------------
  |  |  |  |  256|  13.0M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  13.0M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  985|  13.0M|	SET_TRACKREFS(__x__, TRUE);		\
  |  |  ------------------
  |  |  |  |  260|  13.0M|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  |  |  986|  13.0M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (986:14): [Folded, False: 13.0M]
  |  |  ------------------
  ------------------
 2991|       |
 2992|       |    /* The following prevents disaster in the case */
 2993|       |    /* that an uninitialised string vector is marked */
 2994|       |    /* Direct assignment is OK since the node was just allocated and */
 2995|       |    /* so is at least as new as R_NilValue and R_BlankString */
 2996|  13.0M|    if (type == EXPRSXP || type == VECSXP) {
  ------------------
  |  |  132|  26.0M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
                  if (type == EXPRSXP || type == VECSXP) {
  ------------------
  |  |  131|  13.0M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2996:9): [True: 58, False: 13.0M]
  |  Branch (2996:28): [True: 5.06M, False: 7.97M]
  ------------------
 2997|  5.06M|	SEXP *data = STRING_PTR(s);
  ------------------
  |  |  428|  5.06M|#define STRING_PTR(x)	((SEXP *) DATAPTR(x))
  ------------------
 2998|       |#if VALGRIND_LEVEL > 1
 2999|       |	VALGRIND_MAKE_MEM_DEFINED(STRING_PTR(s), actual_size);
 3000|       |#endif
 3001|  18.1M|	for (R_xlen_t i = 0; i < length; i++)
  ------------------
  |  Branch (3001:23): [True: 13.1M, False: 5.06M]
  ------------------
 3002|  13.1M|	    data[i] = R_NilValue;
 3003|  5.06M|    }
 3004|  7.97M|    else if(type == STRSXP) {
  ------------------
  |  |  126|  7.97M|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (3004:13): [True: 6.68M, False: 1.29M]
  ------------------
 3005|  6.68M|	SEXP *data = STRING_PTR(s);
  ------------------
  |  |  428|  6.68M|#define STRING_PTR(x)	((SEXP *) DATAPTR(x))
  ------------------
 3006|       |#if VALGRIND_LEVEL > 1
 3007|       |	VALGRIND_MAKE_MEM_DEFINED(STRING_PTR(s), actual_size);
 3008|       |#endif
 3009|  20.5M|	for (R_xlen_t i = 0; i < length; i++)
  ------------------
  |  Branch (3009:23): [True: 13.8M, False: 6.68M]
  ------------------
 3010|  13.8M|	    data[i] = R_BlankString;
 3011|  6.68M|    }
 3012|  1.29M|    else if (type == CHARSXP || type == intCHARSXP) {
  ------------------
  |  |  120|  2.58M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
                  else if (type == CHARSXP || type == intCHARSXP) {
  ------------------
  |  | 2730|  1.25M|#define intCHARSXP 73
  ------------------
  |  Branch (3012:14): [True: 35.7k, False: 1.25M]
  |  Branch (3012:33): [True: 0, False: 1.25M]
  ------------------
 3013|       |#if VALGRIND_LEVEL > 0
 3014|       |	VALGRIND_MAKE_MEM_UNDEFINED(CHAR(s), actual_size);
 3015|       |#endif
 3016|  35.7k|	CHAR_RW(s)[length] = 0;
  ------------------
  |  |  930|  35.7k|#define CHAR_RW(x)	((char *) CHAR(x))
  |  |  ------------------
  |  |  |  |  422|  35.7k|#define CHAR(x)		((const char *) STDVEC_DATAPTR(x))
  |  |  |  |  ------------------
  |  |  |  |  |  |  420|  35.7k|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3017|  35.7k|    }
 3018|       |#if VALGRIND_LEVEL > 0
 3019|       |    else if (type == REALSXP)
 3020|       |	VALGRIND_MAKE_MEM_UNDEFINED(REAL(s), actual_size);
 3021|       |    else if (type == INTSXP)
 3022|       |	VALGRIND_MAKE_MEM_UNDEFINED(INTEGER(s), actual_size);
 3023|       |    else if (type == LGLSXP)
 3024|       |	VALGRIND_MAKE_MEM_UNDEFINED(LOGICAL(s), actual_size);
 3025|       |    else if (type == CPLXSXP)
 3026|       |	VALGRIND_MAKE_MEM_UNDEFINED(COMPLEX(s), actual_size);
 3027|       |    else if (type == RAWSXP)
 3028|       |	VALGRIND_MAKE_MEM_UNDEFINED(RAW(s), actual_size);
 3029|       |#endif
 3030|  13.0M|    return s;
 3031|  13.0M|}
Rf_allocCharsxp:
 3035|  35.7k|{
 3036|  35.7k|    return allocVector(intCHARSXP, len);
  ------------------
  |  |  875|  35.7k|#define allocVector		Rf_allocVector
  ------------------
                  return allocVector(intCHARSXP, len);
  ------------------
  |  | 2730|  35.7k|#define intCHARSXP 73
  ------------------
 3037|  35.7k|}
Rf_allocList:
 3040|  1.54M|{
 3041|  1.54M|    int i;
 3042|  1.54M|    SEXP result;
 3043|  1.54M|    result = R_NilValue;
 3044|  3.10M|    for (i = 0; i < n; i++)
  ------------------
  |  Branch (3044:17): [True: 1.55M, False: 1.54M]
  ------------------
 3045|  1.55M|	result = CONS(R_NilValue, result);
  ------------------
  |  |  309|  1.55M|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3046|  1.54M|    return result;
 3047|  1.54M|}
Rf_allocLang:
 3050|  1.31k|{
 3051|  1.31k|    if (n > 0)
  ------------------
  |  Branch (3051:9): [True: 1.31k, False: 0]
  ------------------
 3052|  1.31k|	return LCONS(R_NilValue, allocList(n - 1));
  ------------------
  |  |  310|  1.31k|#define LCONS(a, b)	Rf_lcons((a), (b))		/* language lists */
  ------------------
 3053|      0|    else
 3054|      0|	return R_NilValue;
 3055|  1.31k|}
R_allocObject:
 3066|  1.88k|{
 3067|  1.88k|   SEXP s;
 3068|  1.88k|   GC_PROT(s = allocSExpNonCons(OBJSXP));
  ------------------
  |  |  251|  1.88k|#define GC_PROT(X) do { \
  |  |  252|  1.88k|    int __wait__ = gc_force_wait; \
  |  |  253|  1.88k|    int __gap__ = gc_force_gap;			   \
  |  |  254|  1.88k|    Rboolean __release__ = gc_inhibit_release;	   \
  |  |  255|  1.88k|    X;						   \
  |  |  256|  1.88k|    gc_force_wait = __wait__;			   \
  |  |  257|  1.88k|    gc_force_gap = __gap__;			   \
  |  |  258|  1.88k|    gc_inhibit_release = __release__;		   \
  |  |  259|  1.88k|}  while(0)
  |  |  ------------------
  |  |  |  Branch (259:10): [Folded, False: 1.88k]
  |  |  ------------------
  ------------------
 3069|  1.88k|   return s;
 3070|  1.88k|}
Rf_allocFormalsList2:
 3099|      4|{
 3100|      4|    return allocFormalsList(2, sym1, sym2);
 3101|      4|}
Rf_allocFormalsList3:
 3105|      6|{
 3106|      6|    return allocFormalsList(3, sym1, sym2, sym3);
 3107|      6|}
Rf_allocFormalsList5:
 3117|      1|{
 3118|      1|    return allocFormalsList(5, sym1, sym2, sym3, sym4, sym5);
 3119|      1|}
R_check_thread:
 3210|   275M|{
 3211|   275M|    static Rboolean main_thread_inited = FALSE;
 3212|   275M|    static pthread_t main_thread;
 3213|   275M|    if (! main_thread_inited) {
  ------------------
  |  Branch (3213:9): [True: 2, False: 275M]
  ------------------
 3214|      2|        main_thread = pthread_self();
 3215|      2|        main_thread_inited = TRUE;
 3216|      2|    }
 3217|   275M|    if (! pthread_equal(main_thread, pthread_self())) {
  ------------------
  |  Branch (3217:9): [True: 0, False: 275M]
  ------------------
 3218|      0|        char buf[1024];
 3219|      0|	size_t bsize = sizeof buf;
 3220|      0|	memset(buf, 0, bsize);
 3221|      0|        snprintf(buf, bsize - 1, "Wrong thread calling '%s'", s);
 3222|      0|        R_Suicide(buf);
 3223|      0|    }
 3224|   275M|}
Rf_protect:
 3469|   163M|{
 3470|   163M|    R_CHECK_THREAD;
  ------------------
  |  |  566|   163M|# define R_CHECK_THREAD R_check_thread(__func__)
  ------------------
 3471|   163M|    if (R_PPStackTop >= R_PPStackSize)
  ------------------
  |  Branch (3471:9): [True: 0, False: 163M]
  ------------------
 3472|      0|	R_signal_protect_error();
 3473|   163M|    R_PPStack[R_PPStackTop++] = CHK(s);
 3474|   163M|    return s;
 3475|   163M|}
Rf_unprotect:
 3481|   104M|{
 3482|   104M|    R_CHECK_THREAD;
  ------------------
  |  |  566|   104M|# define R_CHECK_THREAD R_check_thread(__func__)
  ------------------
 3483|   104M|    if (R_PPStackTop >=  l)
  ------------------
  |  Branch (3483:9): [True: 104M, False: 0]
  ------------------
 3484|   104M|	R_PPStackTop -= l;
 3485|      0|    else R_signal_unprotect_error();
 3486|   104M|}
R_ProtectWithIndex:
 3531|  6.20M|{
 3532|  6.20M|    protect(s);
  ------------------
  |  | 1015|  6.20M|#define protect			Rf_protect
  ------------------
 3533|  6.20M|    *pi = R_PPStackTop - 1;
 3534|  6.20M|}
R_Reprotect:
 3547|  6.58M|{
 3548|  6.58M|    R_CHECK_THREAD;
  ------------------
  |  |  566|  6.58M|# define R_CHECK_THREAD R_check_thread(__func__)
  ------------------
 3549|  6.58M|    if (i >= R_PPStackTop || i < 0)
  ------------------
  |  Branch (3549:9): [True: 0, False: 6.58M]
  |  Branch (3549:30): [True: 0, False: 6.58M]
  ------------------
 3550|      0|	R_signal_reprotect_error(i);
 3551|  6.58M|    R_PPStack[i] = s;
 3552|  6.58M|}
R_chk_calloc:
 3585|     96|{
 3586|     96|    void *p;
 3587|       |#ifndef HAVE_WORKING_CALLOC
 3588|       |    if(nelem == 0)
 3589|       |	return(NULL);
 3590|       |#endif
 3591|     96|    p = calloc(nelem, elsize);
 3592|     96|    if(!p)
  ------------------
  |  Branch (3592:8): [True: 0, False: 96]
  ------------------
 3593|      0|	error(_("'R_Calloc' could not allocate memory (%llu of %llu bytes)"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'R_Calloc' could not allocate memory (%llu of %llu bytes)"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3594|      0|	      (unsigned long long)nelem, (unsigned long long)elsize);
 3595|     96|    return(p);
 3596|     96|}
R_chk_realloc:
 3599|  1.92k|{
 3600|  1.92k|    void *p;
 3601|       |    /* Protect against broken realloc */
 3602|  1.92k|    if(ptr) p = realloc(ptr, size); else p = malloc(size);
  ------------------
  |  Branch (3602:8): [True: 0, False: 1.92k]
  ------------------
 3603|  1.92k|    if(!p)
  ------------------
  |  Branch (3603:8): [True: 0, False: 1.92k]
  ------------------
 3604|      0|	error(_("'R_Realloc' could not re-allocate memory (%llu bytes)"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'R_Realloc' could not re-allocate memory (%llu bytes)"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3605|      0|	      (unsigned long long)size);
 3606|  1.92k|    return(p);
 3607|  1.92k|}
R_chk_free:
 3610|  3.93k|{
 3611|       |    /* S-PLUS warns here, but there seems no reason to do so */
 3612|       |    /* if(!ptr) warning("attempt to free NULL pointer by Free"); */
 3613|  3.93k|    if(ptr) free(ptr); /* ANSI C says free has no effect on NULL, but
  ------------------
  |  Branch (3613:8): [True: 2.01k, False: 1.92k]
  ------------------
 3614|       |			  better to be safe here */
 3615|  3.93k|}
R_chk_memset:
 3625|     90|{
 3626|     90|    if (n >= PTRDIFF_MAX)
  ------------------
  |  Branch (3626:9): [True: 0, False: 90]
  ------------------
 3627|      0|	error(_("object is too large (%llu bytes)"), (unsigned long long)n);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("object is too large (%llu bytes)"), (unsigned long long)n);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3628|     90|    return n ? memset(s, c, n) : s;
  ------------------
  |  Branch (3628:12): [True: 42, False: 48]
  ------------------
 3629|     90|}
R_PreserveObject:
 3672|    279|{
 3673|    279|    R_CHECK_THREAD;
  ------------------
  |  |  566|    279|# define R_CHECK_THREAD R_check_thread(__func__)
  ------------------
 3674|    279|    if (! precious_inited) {
  ------------------
  |  Branch (3674:9): [True: 2, False: 277]
  ------------------
 3675|      2|	precious_inited = TRUE;
 3676|      2|	if (getenv("R_HASH_PRECIOUS"))
  ------------------
  |  Branch (3676:6): [True: 0, False: 2]
  ------------------
 3677|      0|	    use_precious_hash = TRUE;
 3678|      2|    }
 3679|    279|    if (use_precious_hash) {
  ------------------
  |  Branch (3679:9): [True: 0, False: 279]
  ------------------
 3680|      0|	if (R_PreciousList == R_NilValue)
  ------------------
  |  Branch (3680:6): [True: 0, False: 0]
  ------------------
 3681|      0|	    R_PreciousList = allocVector(VECSXP, PHASH_SIZE);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	    R_PreciousList = allocVector(VECSXP, PHASH_SIZE);
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
              	    R_PreciousList = allocVector(VECSXP, PHASH_SIZE);
  ------------------
  |  | 3665|      0|#define PHASH_SIZE 1069
  ------------------
 3682|      0|	int bin = PTRHASH(object) % PHASH_SIZE;
  ------------------
  |  | 3666|      0|#define PTRHASH(obj) (((R_size_t) (obj)) >> 3)
  ------------------
              	int bin = PTRHASH(object) % PHASH_SIZE;
  ------------------
  |  | 3665|      0|#define PHASH_SIZE 1069
  ------------------
 3683|      0|	SET_VECTOR_ELT(R_PreciousList, bin,
 3684|      0|		       CONS(object, VECTOR_ELT_0(R_PreciousList, bin)));
  ------------------
  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3685|      0|    }
 3686|    279|    else
 3687|    279|	R_PreciousList = CONS(object, R_PreciousList);
  ------------------
  |  |  309|    279|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3688|    279|}
R_ReleaseObject:
 3691|      2|{
 3692|      2|    R_CHECK_THREAD;
  ------------------
  |  |  566|      2|# define R_CHECK_THREAD R_check_thread(__func__)
  ------------------
 3693|      2|    if (! precious_inited)
  ------------------
  |  Branch (3693:9): [True: 0, False: 2]
  ------------------
 3694|      0|	return; /* can't be anything to delete yet */
 3695|      2|    if (use_precious_hash) {
  ------------------
  |  Branch (3695:9): [True: 0, False: 2]
  ------------------
 3696|      0|	int bin = PTRHASH(object) % PHASH_SIZE;
  ------------------
  |  | 3666|      0|#define PTRHASH(obj) (((R_size_t) (obj)) >> 3)
  ------------------
              	int bin = PTRHASH(object) % PHASH_SIZE;
  ------------------
  |  | 3665|      0|#define PHASH_SIZE 1069
  ------------------
 3697|      0|	SET_VECTOR_ELT(R_PreciousList, bin,
 3698|      0|		       DeleteFromList(object,
 3699|      0|				      VECTOR_ELT_0(R_PreciousList, bin)));
  ------------------
  |  |   80|      0|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  ------------------
  |  |  |  |  420|      0|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  ------------------
  ------------------
 3700|      0|    }
 3701|      2|    else
 3702|      2|	R_PreciousList =  DeleteFromList(object, R_PreciousList);
 3703|      2|}
R_NewPreciousMSet:
 3742|      2|{
 3743|      2|    SEXP npreserved, mset, isize;
 3744|       |
 3745|       |    /* npreserved is modified in place */
 3746|      2|    npreserved = allocVector(INTSXP, 1);
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
                  npreserved = allocVector(INTSXP, 1);
  ------------------
  |  |  123|      2|#define INTSXP	    13	  /* integer vectors */
  ------------------
 3747|      2|    SET_INTEGER_ELT(npreserved, 0, 0);
 3748|      2|    PROTECT(mset = CONS(R_NilValue, npreserved));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3749|       |    /* isize is not modified in place */
 3750|      2|    if (initialSize < 0)
  ------------------
  |  Branch (3750:9): [True: 0, False: 2]
  ------------------
 3751|      0|	error("'initialSize' must be non-negative");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 3752|      2|    isize = ScalarInteger(initialSize);
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
 3753|      2|    SET_TAG(mset, isize);
 3754|      2|    UNPROTECT(1); /* mset */
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3755|      2|    return mset;
 3756|      2|}
R_PreserveInMSet:
 3776|  7.02k|{
 3777|  7.02k|    if (x == R_NilValue || isSymbol(x))
  ------------------
  |  |  862|  6.99k|#define isSymbol(s)	(TYPEOF(s) == SYMSXP)
  |  |  ------------------
  |  |  |  |  233|  6.99k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               #define isSymbol(s)	(TYPEOF(s) == SYMSXP)
  |  |  ------------------
  |  |  |  |  112|  6.99k|#define SYMSXP	     1	  /* symbols */
  |  |  ------------------
  |  |  |  Branch (862:21): [True: 2.13k, False: 4.85k]
  |  |  ------------------
  ------------------
  |  Branch (3777:9): [True: 32, False: 6.99k]
  ------------------
 3778|  2.17k|	return; /* no need to preserve */
 3779|  4.85k|    PROTECT(x);
  ------------------
  |  |  357|  4.85k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3780|  4.85k|    checkMSet(mset);
 3781|  4.85k|    SEXP store = CAR(mset);
 3782|  4.85k|    int *n = INTEGER(CDR(mset));
  ------------------
  |  |  424|  4.85k|#define INTEGER(x)	((int *) DATAPTR(x))
  ------------------
 3783|  4.85k|    if (store == R_NilValue) {
  ------------------
  |  Branch (3783:9): [True: 2, False: 4.85k]
  ------------------
 3784|      2|	R_xlen_t newsize = INTEGER_ELT(TAG(mset), 0);
  ------------------
  |  |  440|      2|#define TAG(e)		((e)->u.listsxp.tagval)
  ------------------
 3785|      2|	if (newsize == 0)
  ------------------
  |  Branch (3785:6): [True: 0, False: 2]
  ------------------
 3786|      0|	    newsize = 4; /* default minimum size */
 3787|      2|	store = allocVector(VECSXP, newsize);
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
              	store = allocVector(VECSXP, newsize);
  ------------------
  |  |  131|      2|#define VECSXP	    19	  /* generic vectors */
  ------------------
 3788|      2|	SETCAR(mset, store);
 3789|      2|    }
 3790|  4.85k|    R_xlen_t size = XLENGTH(store);
  ------------------
  |  |  407|  4.85k|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
 3791|  4.85k|    if (*n == size) {
  ------------------
  |  Branch (3791:9): [True: 0, False: 4.85k]
  ------------------
 3792|      0|	R_xlen_t newsize = 2 * size;
 3793|      0|	if (newsize >= INT_MAX || newsize < size)
  ------------------
  |  Branch (3793:6): [True: 0, False: 0]
  |  Branch (3793:28): [True: 0, False: 0]
  ------------------
 3794|      0|	    error("Multi-set overflow");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 3795|      0|	SEXP newstore = PROTECT(allocVector(VECSXP, newsize));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3796|      0|	for(R_xlen_t i = 0; i < size; i++)
  ------------------
  |  Branch (3796:22): [True: 0, False: 0]
  ------------------
 3797|      0|	    SET_VECTOR_ELT(newstore, i, VECTOR_ELT_0(store, i));
  ------------------
  |  |   80|      0|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  ------------------
  |  |  |  |  420|      0|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  ------------------
  ------------------
 3798|      0|	SETCAR(mset, newstore);
 3799|      0|	UNPROTECT(1); /* newstore */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3800|      0|	store = newstore;
 3801|      0|    }
 3802|  4.85k|    UNPROTECT(1); /* x */
  ------------------
  |  |  358|  4.85k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3803|  4.85k|    SET_VECTOR_ELT(store, (*n)++, x);
 3804|  4.85k|}
R_ReleaseFromMSet:
 3810|  7.02k|{
 3811|  7.02k|    if (x == R_NilValue || isSymbol(x))
  ------------------
  |  |  862|  6.99k|#define isSymbol(s)	(TYPEOF(s) == SYMSXP)
  |  |  ------------------
  |  |  |  |  233|  6.99k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               #define isSymbol(s)	(TYPEOF(s) == SYMSXP)
  |  |  ------------------
  |  |  |  |  112|  6.99k|#define SYMSXP	     1	  /* symbols */
  |  |  ------------------
  |  |  |  Branch (862:21): [True: 2.13k, False: 4.85k]
  |  |  ------------------
  ------------------
  |  Branch (3811:9): [True: 32, False: 6.99k]
  ------------------
 3812|  2.17k|	return; /* not preserved */
 3813|  4.85k|    checkMSet(mset);
 3814|  4.85k|    SEXP store = CAR(mset);
 3815|  4.85k|    if (store == R_NilValue)
  ------------------
  |  Branch (3815:9): [True: 0, False: 4.85k]
  ------------------
 3816|      0|	return; /* not preserved */
 3817|  4.85k|    int *n = INTEGER(CDR(mset));
  ------------------
  |  |  424|  4.85k|#define INTEGER(x)	((int *) DATAPTR(x))
  ------------------
 3818|  8.61k|    for(R_xlen_t i = (*n) - 1; i >= 0; i--) {
  ------------------
  |  Branch (3818:32): [True: 8.61k, False: 0]
  ------------------
 3819|  8.61k|	if (VECTOR_ELT_0(store, i) == x) {
  ------------------
  |  |   80|  8.61k|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  ------------------
  |  |  |  |  420|  8.61k|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  ------------------
  ------------------
  |  Branch (3819:6): [True: 4.85k, False: 3.76k]
  ------------------
 3820|  8.61k|	    for(;i < (*n) - 1; i++)
  ------------------
  |  Branch (3820:11): [True: 3.76k, False: 4.85k]
  ------------------
 3821|  3.76k|		SET_VECTOR_ELT(store, i, VECTOR_ELT_0(store, i + 1));
  ------------------
  |  |   80|  3.76k|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  ------------------
  |  |  |  |  420|  3.76k|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  ------------------
  ------------------
 3822|  4.85k|	    SET_VECTOR_ELT(store, i, R_NilValue);
 3823|  4.85k|	    (*n)--;
 3824|  4.85k|	    return;
 3825|  4.85k|	}
 3826|  8.61k|    }
 3827|       |    /* not preserved */
 3828|  4.85k|}
R_ReleaseMSet:
 3833|    316|{
 3834|    316|    checkMSet(mset);
 3835|    316|    SEXP store = CAR(mset);
 3836|    316|    if (store == R_NilValue)
  ------------------
  |  Branch (3836:9): [True: 42, False: 274]
  ------------------
 3837|     42|	return; /* already empty */
 3838|    274|    int *n = INTEGER(CDR(mset));
  ------------------
  |  |  424|    274|#define INTEGER(x)	((int *) DATAPTR(x))
  ------------------
 3839|    274|    if (XLENGTH(store) <= keepSize) {
  ------------------
  |  |  407|    274|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
  |  Branch (3839:9): [True: 274, False: 0]
  ------------------
 3840|       |	/* just free the entries */
 3841|    274|	for(R_xlen_t i = 0; i < *n; i++)
  ------------------
  |  Branch (3841:22): [True: 0, False: 274]
  ------------------
 3842|      0|	    SET_VECTOR_ELT(store, i, R_NilValue);
 3843|    274|    } else
 3844|      0|	SETCAR(mset, R_NilValue);
 3845|    274|    *n = 0;
 3846|    274|}
R_MakeExternalPtr:
 3850|  1.69k|{
 3851|  1.69k|    SEXP s = allocSExp(EXTPTRSXP);
  ------------------
  |  |  874|  1.69k|#define allocSExp		Rf_allocSExp
  ------------------
                  SEXP s = allocSExp(EXTPTRSXP);
  ------------------
  |  |  134|  1.69k|#define EXTPTRSXP   22    /* external pointer */
  ------------------
 3852|  1.69k|    EXTPTR_PTR(s) = p;
  ------------------
  |  |  444|  1.69k|#define EXTPTR_PTR(e)	((e)->u.listsxp.carval)
  ------------------
 3853|  1.69k|    EXTPTR_PROT(s) = CHK(prot); if (prot) INCREMENT_REFCNT(prot);
  ------------------
  |  |  442|  1.69k|#define EXTPTR_PROT(x)	CDR(x)
  |  |  ------------------
  |  |  |  |  445|  1.69k|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  ------------------
  ------------------
                  EXTPTR_PROT(s) = CHK(prot); if (prot) INCREMENT_REFCNT(prot);
  ------------------
  |  |  267|  1.69k|# define INCREMENT_REFCNT(x) do {			      \
  |  |  268|  1.69k|	SEXP irc__x__ = (x);				      \
  |  |  269|  1.69k|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  248|  1.69k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  195|  1.69k|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  1.69k|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (269:6): [True: 0, False: 1.69k]
  |  |  ------------------
  |  |  270|  1.69k|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  ------------------
  |  |  |  |  256|      0|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  271|  1.69k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (271:14): [Folded, False: 1.69k]
  |  |  ------------------
  ------------------
  |  Branch (3853:37): [True: 1.69k, False: 0]
  ------------------
 3854|  1.69k|    EXTPTR_TAG(s) = CHK(tag); if (tag) INCREMENT_REFCNT(tag);
  ------------------
  |  |  443|  1.69k|#define EXTPTR_TAG(x)	TAG(x)
  |  |  ------------------
  |  |  |  |  440|  1.69k|#define TAG(e)		((e)->u.listsxp.tagval)
  |  |  ------------------
  ------------------
                  EXTPTR_TAG(s) = CHK(tag); if (tag) INCREMENT_REFCNT(tag);
  ------------------
  |  |  267|  1.69k|# define INCREMENT_REFCNT(x) do {			      \
  |  |  268|  1.69k|	SEXP irc__x__ = (x);				      \
  |  |  269|  1.69k|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  248|  1.69k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  195|  1.69k|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  1.69k|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (269:6): [True: 1.66k, False: 24]
  |  |  ------------------
  |  |  270|  1.69k|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  ------------------
  |  |  |  |  256|  1.66k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  1.66k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  271|  1.69k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (271:14): [Folded, False: 1.69k]
  |  |  ------------------
  ------------------
  |  Branch (3854:35): [True: 1.69k, False: 0]
  ------------------
 3855|  1.69k|    return s;
 3856|  1.69k|}
R_ExternalPtrAddr:
 3864|  4.92k|{
 3865|  4.92k|    CHKEXTPTRSXP(s);
  ------------------
  |  | 3859|  4.92k|    if (TYPEOF(x) != EXTPTRSXP)						\
  |  |  ------------------
  |  |  |  |  233|  4.92k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != EXTPTRSXP)						\
  |  |  ------------------
  |  |  |  |  134|  4.92k|#define EXTPTRSXP   22    /* external pointer */
  |  |  ------------------
  |  |  |  Branch (3859:9): [True: 0, False: 4.92k]
  |  |  ------------------
  |  | 3860|  4.92k|	error(_("%s: argument of type %s is not an external pointer"),	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not an external pointer"),	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 3861|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
 3866|  4.92k|    return EXTPTR_PTR(CHK(s));
  ------------------
  |  |  444|  4.92k|#define EXTPTR_PTR(e)	((e)->u.listsxp.carval)
  ------------------
 3867|  4.92k|}
R_ExternalPtrTag:
 3870|  9.62k|{
 3871|  9.62k|    CHKEXTPTRSXP(s);
  ------------------
  |  | 3859|  9.62k|    if (TYPEOF(x) != EXTPTRSXP)						\
  |  |  ------------------
  |  |  |  |  233|  9.62k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != EXTPTRSXP)						\
  |  |  ------------------
  |  |  |  |  134|  9.62k|#define EXTPTRSXP   22    /* external pointer */
  |  |  ------------------
  |  |  |  Branch (3859:9): [True: 0, False: 9.62k]
  |  |  ------------------
  |  | 3860|  9.62k|	error(_("%s: argument of type %s is not an external pointer"),	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not an external pointer"),	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 3861|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
 3872|  9.62k|    return CHK(EXTPTR_TAG(CHK(s)));
  ------------------
  |  |  443|  9.62k|#define EXTPTR_TAG(x)	TAG(x)
  |  |  ------------------
  |  |  |  |  440|  9.62k|#define TAG(e)		((e)->u.listsxp.tagval)
  |  |  ------------------
  ------------------
 3873|  9.62k|}
R_SetExternalPtrAddr:
 3888|    352|{
 3889|    352|    CHKEXTPTRSXP(s);
  ------------------
  |  | 3859|    352|    if (TYPEOF(x) != EXTPTRSXP)						\
  |  |  ------------------
  |  |  |  |  233|    352|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != EXTPTRSXP)						\
  |  |  ------------------
  |  |  |  |  134|    352|#define EXTPTRSXP   22    /* external pointer */
  |  |  ------------------
  |  |  |  Branch (3859:9): [True: 0, False: 352]
  |  |  ------------------
  |  | 3860|    352|	error(_("%s: argument of type %s is not an external pointer"),	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not an external pointer"),	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 3861|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
 3890|    352|    EXTPTR_PTR(s) = p;
  ------------------
  |  |  444|    352|#define EXTPTR_PTR(e)	((e)->u.listsxp.carval)
  ------------------
 3891|    352|}
R_SetExternalPtrTag:
 3894|    352|{
 3895|    352|    CHKEXTPTRSXP(s);
  ------------------
  |  | 3859|    352|    if (TYPEOF(x) != EXTPTRSXP)						\
  |  |  ------------------
  |  |  |  |  233|    352|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != EXTPTRSXP)						\
  |  |  ------------------
  |  |  |  |  134|    352|#define EXTPTRSXP   22    /* external pointer */
  |  |  ------------------
  |  |  |  Branch (3859:9): [True: 0, False: 352]
  |  |  ------------------
  |  | 3860|    352|	error(_("%s: argument of type %s is not an external pointer"),	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not an external pointer"),	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 3861|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
 3896|    352|    FIX_REFCNT(s, EXTPTR_TAG(s), tag);
  ------------------
  |  | 1335|    352|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|    352|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|    352|	SEXP __x__ = (x);						\
  |  |  |  | 1321|    352|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|    352|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    352|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|    352|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 352, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 352]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|    352|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|    352|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|    352|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 0, False: 352]
  |  |  |  |  ------------------
  |  |  |  | 1325|      0|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|      0|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1327|      0|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|      0|		    else						\
  |  |  |  | 1329|      0|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|      0|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|      0|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|      0|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|      0|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|      0|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|      0|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|      0|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|      0|		}							\
  |  |  |  | 1331|      0|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|      0|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|      0|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|      0|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|      0|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|      0|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|      0|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|      0|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|      0|	    }								\
  |  |  |  | 1333|    352|	}								\
  |  |  |  | 1334|    352|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 352]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3897|    352|    CHECK_OLD_TO_NEW(s, tag);
  ------------------
  |  | 1350|    352|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|    352|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|    352|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|    704|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    352|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 352]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|    352|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 0, False: 0]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 352]
  |  |  ------------------
  ------------------
 3898|    352|    EXTPTR_TAG(s) = tag;
  ------------------
  |  |  443|    352|#define EXTPTR_TAG(x)	TAG(x)
  |  |  ------------------
  |  |  |  |  440|    352|#define TAG(e)		((e)->u.listsxp.tagval)
  |  |  ------------------
  ------------------
 3899|    352|}
R_SetExternalPtrProtected:
 3902|    352|{
 3903|    352|    CHKEXTPTRSXP(s);
  ------------------
  |  | 3859|    352|    if (TYPEOF(x) != EXTPTRSXP)						\
  |  |  ------------------
  |  |  |  |  233|    352|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != EXTPTRSXP)						\
  |  |  ------------------
  |  |  |  |  134|    352|#define EXTPTRSXP   22    /* external pointer */
  |  |  ------------------
  |  |  |  Branch (3859:9): [True: 0, False: 352]
  |  |  ------------------
  |  | 3860|    352|	error(_("%s: argument of type %s is not an external pointer"),	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not an external pointer"),	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 3861|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
 3904|    352|    FIX_REFCNT(s, EXTPTR_PROT(s), p);
  ------------------
  |  | 1335|    352|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|    352|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|    352|	SEXP __x__ = (x);						\
  |  |  |  | 1321|    352|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|    352|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    352|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|    352|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 352, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 352]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|    352|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|    352|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|    352|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 0, False: 352]
  |  |  |  |  ------------------
  |  |  |  | 1325|      0|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|      0|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1327|      0|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|      0|		    else						\
  |  |  |  | 1329|      0|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|      0|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|      0|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|      0|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|      0|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|      0|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|      0|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|      0|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|      0|		}							\
  |  |  |  | 1331|      0|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|      0|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|      0|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|      0|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|      0|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|      0|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|      0|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|      0|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|      0|	    }								\
  |  |  |  | 1333|    352|	}								\
  |  |  |  | 1334|    352|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 352]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3905|    352|    CHECK_OLD_TO_NEW(s, p);
  ------------------
  |  | 1350|    352|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|    352|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|    352|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|    704|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    352|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 352]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|    352|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 0, False: 0]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 352]
  |  |  ------------------
  ------------------
 3906|    352|    EXTPTR_PROT(s) = p;
  ------------------
  |  |  442|    352|#define EXTPTR_PROT(x)	CDR(x)
  |  |  ------------------
  |  |  |  |  445|    352|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  ------------------
  ------------------
 3907|    352|}
R_MakeExternalPtrFn:
 3916|     12|{
 3917|     12|    fn_ptr tmp;
 3918|     12|    SEXP s = allocSExp(EXTPTRSXP);
  ------------------
  |  |  874|     12|#define allocSExp		Rf_allocSExp
  ------------------
                  SEXP s = allocSExp(EXTPTRSXP);
  ------------------
  |  |  134|     12|#define EXTPTRSXP   22    /* external pointer */
  ------------------
 3919|     12|    tmp.fn = p;
 3920|     12|    EXTPTR_PTR(s) = tmp.p;
  ------------------
  |  |  444|     12|#define EXTPTR_PTR(e)	((e)->u.listsxp.carval)
  ------------------
 3921|     12|    EXTPTR_PROT(s) = CHK(prot); if (prot) INCREMENT_REFCNT(prot);
  ------------------
  |  |  442|     12|#define EXTPTR_PROT(x)	CDR(x)
  |  |  ------------------
  |  |  |  |  445|     12|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  ------------------
  ------------------
                  EXTPTR_PROT(s) = CHK(prot); if (prot) INCREMENT_REFCNT(prot);
  ------------------
  |  |  267|     12|# define INCREMENT_REFCNT(x) do {			      \
  |  |  268|     12|	SEXP irc__x__ = (x);				      \
  |  |  269|     12|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  248|     12|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  195|     12|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|     12|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (269:6): [True: 0, False: 12]
  |  |  ------------------
  |  |  270|     12|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  ------------------
  |  |  |  |  256|      0|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  271|     12|    } while (0)
  |  |  ------------------
  |  |  |  Branch (271:14): [Folded, False: 12]
  |  |  ------------------
  ------------------
  |  Branch (3921:37): [True: 12, False: 0]
  ------------------
 3922|     12|    EXTPTR_TAG(s) = CHK(tag); if (tag) INCREMENT_REFCNT(tag);
  ------------------
  |  |  443|     12|#define EXTPTR_TAG(x)	TAG(x)
  |  |  ------------------
  |  |  |  |  440|     12|#define TAG(e)		((e)->u.listsxp.tagval)
  |  |  ------------------
  ------------------
                  EXTPTR_TAG(s) = CHK(tag); if (tag) INCREMENT_REFCNT(tag);
  ------------------
  |  |  267|     12|# define INCREMENT_REFCNT(x) do {			      \
  |  |  268|     12|	SEXP irc__x__ = (x);				      \
  |  |  269|     12|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  248|     12|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  195|     12|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|     12|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (269:6): [True: 0, False: 12]
  |  |  ------------------
  |  |  270|     12|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  ------------------
  |  |  |  |  256|      0|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  271|     12|    } while (0)
  |  |  ------------------
  |  |  |  Branch (271:14): [Folded, False: 12]
  |  |  ------------------
  ------------------
  |  Branch (3922:35): [True: 12, False: 0]
  ------------------
 3923|     12|    return s;
 3924|     12|}
ATTRIB:
 3942|  81.6M|SEXP (ATTRIB)(SEXP x) { return CHK(ATTRIB(CHK(x))); }
  ------------------
  |  |  230|  81.6M|#define ATTRIB(x)	((x)->attrib)
  ------------------
OBJECT:
 3944|  82.3M|int (OBJECT)(SEXP x) { return OBJECT(CHK(x)); }
  ------------------
  |  |  231|  82.3M|#define OBJECT(x)	((x)->sxpinfo.obj)
  ------------------
TYPEOF:
 3945|   704M|int (TYPEOF)(SEXP x) { return TYPEOF(CHK(x)); }
  ------------------
  |  |  233|   704M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
NAMED:
 3947|  7.35M|int (NAMED)(SEXP x) { return NAMED(CHK(x)); }
  ------------------
  |  |  337|  7.35M|# define NAMED(x) REFCNT(x)
  |  |  ------------------
  |  |  |  |  248|  7.35M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  ------------------
RTRACE:
 3948|  15.5M|attribute_hidden int (RTRACE)(SEXP x) { return RTRACE(CHK(x)); }
  ------------------
  |  |  235|  15.5M|#define RTRACE(x)	((x)->sxpinfo.trace)
  ------------------
LEVELS:
 3950|  24.3M|int (LEVELS)(SEXP x) { return LEVELS(CHK(x)); }
  ------------------
  |  |  236|  24.3M|#define LEVELS(x)	((x)->sxpinfo.gp)
  ------------------
REFCNT:
 3951|  42.5M|int (REFCNT)(SEXP x) { return REFCNT(CHK(x)); }
  ------------------
  |  |  248|  42.5M|# define REFCNT(x) ((x)->sxpinfo.named)
  ------------------
TRACKREFS:
 3952|  13.7M|attribute_hidden int (TRACKREFS)(SEXP x) { return TRACKREFS(CHK(x)); }
  ------------------
  |  |  249|  13.7M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  ------------------
  |  |  |  |  233|  13.7M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  ------------------
  |  |  |  |  114|  13.7M|#define CLOSXP	     3	  /* closures */
  |  |  ------------------
  |  |  |  Branch (249:24): [True: 0, False: 13.7M]
  |  |  ------------------
  ------------------
ALTREP:
 3953|  79.0M|int (ALTREP)(SEXP x) { return ALTREP(CHK(x)); }
  ------------------
  |  |  242|  79.0M|#define ALTREP(x)       ((x)->sxpinfo.alt)
  ------------------
MARK_NOT_MUTABLE:
 3954|  12.4M|void (MARK_NOT_MUTABLE)(SEXP x) { MARK_NOT_MUTABLE(CHK(x)); }
  ------------------
  |  |  283|  12.4M|# define MARK_NOT_MUTABLE(x) SET_REFCNT(x, REFCNTMAX)
  |  |  ------------------
  |  |  |  |  256|  12.4M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  12.4M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
MAYBE_SHARED:
 3955|  7.71M|int (MAYBE_SHARED)(SEXP x) { return MAYBE_SHARED(CHK(x)); }
  ------------------
  |  |  241|  7.71M|#  define MAYBE_SHARED(x) (REFCNT(x) > 1)
  |  |  ------------------
  |  |  |  |  248|  7.71M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  ------------------
NO_REFERENCES:
 3956|  10.0M|int (NO_REFERENCES)(SEXP x) { return NO_REFERENCES(CHK(x)); }
  ------------------
  |  |  242|  10.0M|#  define NO_REFERENCES(x) (REFCNT(x) == 0)
  |  |  ------------------
  |  |  |  |  248|  10.0M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  ------------------
IS_SCALAR:
 3960|  18.7M|{
 3961|  18.7M|    return TYPEOF(CHK(x)) == type && XLENGTH(x) == 1;
  ------------------
  |  |  233|  18.7M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  return TYPEOF(CHK(x)) == type && XLENGTH(x) == 1;
  ------------------
  |  |  407|  7.84M|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
  |  Branch (3961:12): [True: 7.84M, False: 10.8M]
  |  Branch (3961:38): [True: 7.84M, False: 2.56k]
  ------------------
 3962|  18.7M|}
DECREMENT_REFCNT:
 3966|  37.2M|void (DECREMENT_REFCNT)(SEXP x) { DECREMENT_REFCNT(CHK(x)); }
  ------------------
  |  |  262|  37.2M|# define DECREMENT_REFCNT(x) do {					\
  |  |  263|  37.2M|	SEXP drc__x__ = (x);						\
  |  |  264|  37.2M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  ------------------
  |  |  |  |  248|  37.2M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  ------------------
  |  |  |  |  248|  37.2M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  ------------------
  |  |  |  |  195|  37.2M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  37.2M|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (264:6): [True: 37.2M, False: 0]
  |  |  |  Branch (264:30): [True: 26.5M, False: 10.7M]
  |  |  ------------------
  |  |  265|  37.2M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  ------------------
  |  |  |  |  256|  26.5M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  26.5M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|  37.2M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (266:14): [Folded, False: 37.2M]
  |  |  ------------------
  ------------------
INCREMENT_REFCNT:
 3968|  82.8M|void (INCREMENT_REFCNT)(SEXP x) { INCREMENT_REFCNT(CHK(x)); }
  ------------------
  |  |  267|  82.8M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  268|  82.8M|	SEXP irc__x__ = (x);				      \
  |  |  269|  82.8M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  248|  82.8M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  195|  82.8M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  82.8M|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (269:6): [True: 56.4M, False: 26.3M]
  |  |  ------------------
  |  |  270|  82.8M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  ------------------
  |  |  |  |  256|  56.4M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  56.4M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  271|  82.8M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (271:14): [Folded, False: 82.8M]
  |  |  ------------------
  ------------------
DISABLE_REFCNT:
 3970|     34|void (DISABLE_REFCNT)(SEXP x)  { DISABLE_REFCNT(CHK(x)); }
  ------------------
  |  |  280|     34|#define DISABLE_REFCNT(x) SET_TRACKREFS(x, FALSE)
  |  |  ------------------
  |  |  |  |  260|     34|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  ------------------
ENABLE_REFCNT:
 3972|  13.7M|void (ENABLE_REFCNT)(SEXP x) { ENABLE_REFCNT(CHK(x)); }
  ------------------
  |  |  279|  13.7M|#define ENABLE_REFCNT(x) SET_TRACKREFS(x, TRUE)
  |  |  ------------------
  |  |  |  |  260|  13.7M|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  ------------------
ASSIGNMENT_PENDING:
 3974|  1.92M|int (ASSIGNMENT_PENDING)(SEXP x) { return ASSIGNMENT_PENDING(CHK(x)); }
  ------------------
  |  |  321|  1.92M|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  ------------------
  |  |  |  |  320|  1.92M|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  ------------------
  ------------------
SET_ASSIGNMENT_PENDING:
 3976|  3.85M|{
 3977|  3.85M|    SET_ASSIGNMENT_PENDING(CHK(x), v);
  ------------------
  |  |  322|  3.85M|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  323|  3.85M|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  ------------------
  |  |  |  |  320|  1.92M|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  ------------------
  |  |  |  Branch (323:6): [True: 1.92M, False: 1.92M]
  |  |  ------------------
  |  |  324|  3.85M|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  ------------------
  |  |  |  |  320|  1.92M|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  ------------------
  |  |  325|  3.85M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (325:14): [Folded, False: 3.85M]
  |  |  ------------------
  ------------------
 3978|  3.85M|}
IS_ASSIGNMENT_CALL:
 3980|   771k|int (IS_ASSIGNMENT_CALL)(SEXP x) { return IS_ASSIGNMENT_CALL(CHK(x)); }
  ------------------
  |  |  332|   771k|#define IS_ASSIGNMENT_CALL(call) ASSIGNMENT_PENDING(call)
  |  |  ------------------
  |  |  |  |  321|   771k|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |  320|   771k|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
MARK_ASSIGNMENT_CALL:
 3982|  1.54M|void (MARK_ASSIGNMENT_CALL)(SEXP x) { MARK_ASSIGNMENT_CALL(CHK(x)); }
  ------------------
  |  |  331|  1.54M|#define MARK_ASSIGNMENT_CALL(call) SET_ASSIGNMENT_PENDING(call, TRUE)
  |  |  ------------------
  |  |  |  |  322|  1.54M|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  323|  1.54M|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  320|  1.54M|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (323:6): [True: 1.54M, Folded]
  |  |  |  |  ------------------
  |  |  |  |  324|  1.54M|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  ------------------
  |  |  |  |  325|  1.54M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (325:14): [Folded, False: 1.54M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
SET_ATTRIB:
 3984|  6.47M|void (SET_ATTRIB)(SEXP x, SEXP v) {
 3985|  6.47M|    if(TYPEOF(v) != LISTSXP && TYPEOF(v) != NILSXP)
  ------------------
  |  |  233|  6.47M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(v) != LISTSXP && TYPEOF(v) != NILSXP)
  ------------------
  |  |  113|  12.9M|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
                  if(TYPEOF(v) != LISTSXP && TYPEOF(v) != NILSXP)
  ------------------
  |  |  233|  1.00M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(v) != LISTSXP && TYPEOF(v) != NILSXP)
  ------------------
  |  |  111|  1.00M|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (3985:8): [True: 1.00M, False: 5.46M]
  |  Branch (3985:32): [True: 0, False: 1.00M]
  ------------------
 3986|      0|	error("value of 'SET_ATTRIB' must be a pairlist or NULL, not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 3987|      0|	      R_typeToChar(v));
 3988|  6.47M|    FIX_REFCNT(x, ATTRIB(x), v);
  ------------------
  |  | 1335|  6.47M|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  6.47M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  6.47M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  6.47M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  6.47M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  6.47M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  6.47M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 6.47M, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 6.51k, False: 6.46M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  6.47M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  6.47M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  6.47M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 6.22M, False: 247k]
  |  |  |  |  ------------------
  |  |  |  | 1325|  6.22M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 6.22M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  6.22M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 6.22M]
  |  |  |  |  ------------------
  |  |  |  | 1327|  6.22M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  6.22M|		    else						\
  |  |  |  | 1329|  6.22M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  6.22M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  6.22M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  6.22M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  6.22M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  6.22M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  6.22M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  6.22M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 6.22M, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 773k, False: 5.45M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  6.22M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|   773k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|   773k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  6.22M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 6.22M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  6.22M|		}							\
  |  |  |  | 1331|  6.22M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  6.22M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  6.22M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  6.22M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  6.22M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  6.22M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  6.22M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 5.45M, False: 773k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  6.22M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  5.45M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  5.45M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  6.22M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 6.22M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 6.22M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  6.22M|	    }								\
  |  |  |  | 1333|  6.47M|	}								\
  |  |  |  | 1334|  6.47M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 6.47M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3989|  6.47M|    CHECK_OLD_TO_NEW(x, v);
  ------------------
  |  | 1350|  6.47M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  6.47M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  6.47M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  12.9M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  6.47M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 32, False: 6.47M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 32, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  6.47M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|     64|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|     32|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      4|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      4|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 28, False: 4]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 4]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 6.47M]
  |  |  ------------------
  ------------------
 3990|  6.47M|    ATTRIB(x) = v;
  ------------------
  |  |  230|  6.47M|#define ATTRIB(x)	((x)->attrib)
  ------------------
 3991|  6.47M|}
SET_OBJECT:
 3992|  9.69M|void (SET_OBJECT)(SEXP x, int v) { SET_OBJECT(CHK(x), v); }
  ------------------
  |  |  237|  9.69M|#define SET_OBJECT(x,v)	(((x)->sxpinfo.obj)=(v))
  ------------------
SETLEVELS:
 4003|  11.2M|int (SETLEVELS)(SEXP x, int v) { return SETLEVELS(CHK(x), v); }
  ------------------
  |  |  241|  11.2M|#define SETLEVELS(x,v)	(((x)->sxpinfo.gp)=((unsigned short)v))
  ------------------
SHALLOW_DUPLICATE_ATTRIB:
 4009|    112|void SHALLOW_DUPLICATE_ATTRIB(SEXP to, SEXP from) {
 4010|    112|    SET_ATTRIB(CHK(to), shallow_duplicate(CHK(ATTRIB(CHK(from)))));
  ------------------
  |  | 1030|    112|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
                  SET_ATTRIB(CHK(to), shallow_duplicate(CHK(ATTRIB(CHK(from)))));
  ------------------
  |  |  230|    112|#define ATTRIB(x)	((x)->attrib)
  ------------------
 4011|    112|    SET_OBJECT(CHK(to), OBJECT(from));
  ------------------
  |  |  237|    112|#define SET_OBJECT(x,v)	(((x)->sxpinfo.obj)=(v))
  ------------------
 4012|    112|    IS_S4_OBJECT(from) ?  SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);
  ------------------
  |  |  368|    112|#define IS_S4_OBJECT(x) ((x)->sxpinfo.gp & S4_OBJECT_MASK)
  |  |  ------------------
  |  |  |  |  367|    112|#define S4_OBJECT_MASK ((unsigned short)(1<<4))
  |  |  ------------------
  |  |  |  Branch (368:25): [True: 0, False: 112]
  |  |  ------------------
  ------------------
                  IS_S4_OBJECT(from) ?  SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);
  ------------------
  |  |  369|      0|#define SET_S4_OBJECT(x) (((x)->sxpinfo.gp) |= S4_OBJECT_MASK)
  |  |  ------------------
  |  |  |  |  367|      0|#define S4_OBJECT_MASK ((unsigned short)(1<<4))
  |  |  ------------------
  ------------------
                  IS_S4_OBJECT(from) ?  SET_S4_OBJECT(to) : UNSET_S4_OBJECT(to);
  ------------------
  |  |  370|    112|#define UNSET_S4_OBJECT(x) (((x)->sxpinfo.gp) &= ~S4_OBJECT_MASK)
  |  |  ------------------
  |  |  |  |  367|    112|#define S4_OBJECT_MASK ((unsigned short)(1<<4))
  |  |  ------------------
  ------------------
 4013|    112|}
SET_TYPEOF:
 4064|  6.58M|{
 4065|       |    /* Ideally this should not exist as a function outsie of base, but
 4066|       |       it was shown in WRE and is used in a good number of packages.
 4067|       |       So try to make it a little safer by only allowing some type
 4068|       |       changes.
 4069|       |    */
 4070|  6.58M|    if (TYPEOF(CHK(x)) != v) {
  ------------------
  |  |  233|  6.58M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
  |  Branch (4070:9): [True: 6.58M, False: 0]
  ------------------
 4071|  6.58M|	check_SET_TYPEOF(x, v);
 4072|  6.58M|	SET_TYPEOF(CHK(x), v);
  ------------------
  |  |  238|  6.58M|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 4073|  6.58M|    }
 4074|  6.58M|}
ALTREP_SET_TYPEOF:
 4077|    255|void (ALTREP_SET_TYPEOF)(SEXP x, int v) { SET_TYPEOF(CHK(x), v); }
  ------------------
  |  |  238|    255|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
ENSURE_NAMEDMAX:
 4079|  24.4M|void (ENSURE_NAMEDMAX)(SEXP x) { ENSURE_NAMEDMAX(CHK(x)); }
  ------------------
  |  |  339|  24.4M|# define ENSURE_NAMEDMAX(v) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (339:43): [Folded, False: 24.4M]
  |  |  ------------------
  ------------------
ENSURE_NAMED:
 4080|  38.2k|attribute_hidden void (ENSURE_NAMED)(SEXP x) { ENSURE_NAMED(CHK(x)); }
  ------------------
  |  |  340|  38.2k|# define ENSURE_NAMED(v) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (340:40): [Folded, False: 38.2k]
  |  |  ------------------
  ------------------
SETTER_CLEAR_NAMED:
 4082|  1.54M|void (SETTER_CLEAR_NAMED)(SEXP x) { SETTER_CLEAR_NAMED(CHK(x)); }
  ------------------
  |  |  351|  1.54M|# define SETTER_CLEAR_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (351:46): [Folded, False: 1.54M]
  |  |  ------------------
  ------------------
RAISE_NAMED:
 4084|  1.16M|void (RAISE_NAMED)(SEXP x, int n) { RAISE_NAMED(CHK(x), n); }
  ------------------
  |  |  352|  1.16M|# define RAISE_NAMED(x, n) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (352:42): [Folded, False: 1.16M]
  |  |  ------------------
  ------------------
IS_S4_OBJECT:
 4088|  10.1M|int (IS_S4_OBJECT)(SEXP x){ return IS_S4_OBJECT(CHK(x)); }
  ------------------
  |  |  368|  10.1M|#define IS_S4_OBJECT(x) ((x)->sxpinfo.gp & S4_OBJECT_MASK)
  |  |  ------------------
  |  |  |  |  367|  10.1M|#define S4_OBJECT_MASK ((unsigned short)(1<<4))
  |  |  ------------------
  ------------------
UNSET_S4_OBJECT:
 4092|  7.73M|void (UNSET_S4_OBJECT)(SEXP x){ UNSET_S4_OBJECT(CHK(x)); }
  ------------------
  |  |  370|  7.73M|#define UNSET_S4_OBJECT(x) (((x)->sxpinfo.gp) &= ~S4_OBJECT_MASK)
  |  |  ------------------
  |  |  |  |  367|  7.73M|#define S4_OBJECT_MASK ((unsigned short)(1<<4))
  |  |  ------------------
  ------------------
NOJIT:
 4095|  2.82k|attribute_hidden int (NOJIT)(SEXP x) { return NOJIT(CHK(x)); }
  ------------------
  |  |  374|  2.82k|#define NOJIT(x) ((x)->sxpinfo.gp & NOJIT_MASK)
  |  |  ------------------
  |  |  |  |  373|  2.82k|#define NOJIT_MASK ((unsigned short)(1<<5))
  |  |  ------------------
  ------------------
MAYBEJIT:
 4096|  1.98k|attribute_hidden int (MAYBEJIT)(SEXP x) { return MAYBEJIT(CHK(x)); }
  ------------------
  |  |  377|  1.98k|#define MAYBEJIT(x) ((x)->sxpinfo.gp & MAYBEJIT_MASK)
  |  |  ------------------
  |  |  |  |  376|  1.98k|#define MAYBEJIT_MASK ((unsigned short)(1<<6))
  |  |  ------------------
  ------------------
SET_NOJIT:
 4097|    936|attribute_hidden void (SET_NOJIT)(SEXP x) { SET_NOJIT(CHK(x)); }
  ------------------
  |  |  375|    936|#define SET_NOJIT(x) (((x)->sxpinfo.gp) |= NOJIT_MASK)
  |  |  ------------------
  |  |  |  |  373|    936|#define NOJIT_MASK ((unsigned short)(1<<5))
  |  |  ------------------
  ------------------
SET_MAYBEJIT:
 4098|      4|attribute_hidden void (SET_MAYBEJIT)(SEXP x) { SET_MAYBEJIT(CHK(x)); }
  ------------------
  |  |  378|      4|#define SET_MAYBEJIT(x) (((x)->sxpinfo.gp) |= MAYBEJIT_MASK)
  |  |  ------------------
  |  |  |  |  376|      4|#define MAYBEJIT_MASK ((unsigned short)(1<<6))
  |  |  ------------------
  ------------------
UNSET_MAYBEJIT:
 4099|      1|attribute_hidden void (UNSET_MAYBEJIT)(SEXP x) { UNSET_MAYBEJIT(CHK(x)); }
  ------------------
  |  |  379|      1|#define UNSET_MAYBEJIT(x) (((x)->sxpinfo.gp) &= ~MAYBEJIT_MASK)
  |  |  ------------------
  |  |  |  |  376|      1|#define MAYBEJIT_MASK ((unsigned short)(1<<6))
  |  |  ------------------
  ------------------
IS_GROWABLE:
 4103|     29|int (IS_GROWABLE)(SEXP x) { return IS_GROWABLE(CHK(x)); }
  ------------------
  |  |  384|     29|#define IS_GROWABLE(x) (GROWABLE_BIT_SET(x) && XLENGTH(x) < XTRUELENGTH(x))
  |  |  ------------------
  |  |  |  |  382|     58|#define GROWABLE_BIT_SET(x) ((x)->sxpinfo.gp & GROWABLE_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |  937|     29|#define GROWABLE_MASK ((unsigned short)(1<<5))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (382:29): [True: 0, False: 29]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define IS_GROWABLE(x) (GROWABLE_BIT_SET(x) && XLENGTH(x) < XTRUELENGTH(x))
  |  |  ------------------
  |  |  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  ------------------
  |  |  |  Branch (384:48): [True: 0, False: 0]
  |  |  ------------------
  ------------------
GROWABLE_BIT_SET:
 4105|  2.70M|int (GROWABLE_BIT_SET)(SEXP x) { return GROWABLE_BIT_SET(CHK(x)); }
  ------------------
  |  |  382|  2.70M|#define GROWABLE_BIT_SET(x) ((x)->sxpinfo.gp & GROWABLE_MASK)
  |  |  ------------------
  |  |  |  |  937|  2.70M|#define GROWABLE_MASK ((unsigned short)(1<<5))
  |  |  ------------------
  ------------------
LENGTH:
 4125|  16.8M|int (LENGTH)(SEXP x) { return x == R_NilValue ? 0 : LENGTH(CHK2(x)); }
  ------------------
  |  |  403|  16.8M|#define LENGTH(x) LENGTH_EX(x, __FILE__, __LINE__)
  ------------------
  |  Branch (4125:31): [True: 0, False: 16.8M]
  ------------------
XLENGTH:
 4126|  77.1M|R_xlen_t (XLENGTH)(SEXP x) { return XLENGTH(CHK2(x)); }
  ------------------
  |  |  407|  77.1M|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
TRUELENGTH:
 4128|  24.0k|R_xlen_t (TRUELENGTH)(SEXP x) { return TRUELENGTH(CHK2(x)); }
  ------------------
  |  |  404|  24.0k|#define TRUELENGTH(x) XTRUELENGTH(x)
  ------------------
SET_TRUELENGTH:
 4142|  2.83M|void (SET_TRUELENGTH)(SEXP x, R_xlen_t v) { SET_TRUELENGTH(CHK2(x), v); }
  ------------------
  |  |  395|  2.83M|#define SET_TRUELENGTH(x,v) do {				\
  |  |  396|  2.83M|	SEXP sl__x__ = (x);					\
  |  |  397|  2.83M|	R_xlen_t sl__v__ = (v);					\
  |  |  398|  2.83M|	if (ALTREP(x)) error("can't set ALTREP truelength");	\
  |  |  ------------------
  |  |  |  |  242|  2.83M|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (242:25): [True: 0, False: 2.83M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	if (ALTREP(x)) error("can't set ALTREP truelength");	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  399|  2.83M|	SET_STDVEC_TRUELENGTH(sl__x__, sl__v__);	\
  |  |  ------------------
  |  |  |  |  394|  2.83M|#define SET_STDVEC_TRUELENGTH(x, v) (STDVEC_TRUELENGTH(x)=(v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  393|  2.83M|#define STDVEC_TRUELENGTH(x) (((VECSEXP) (x))->vecsxp.truelength)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  400|  2.83M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (400:14): [Folded, False: 2.83M]
  |  |  ------------------
  ------------------
IS_LONG_VEC:
 4143|    131|int  (IS_LONG_VEC)(SEXP x) { return IS_LONG_VEC(CHK2(x)); }
  ------------------
  |  |  388|    131|# define IS_LONG_VEC(x) (XLENGTH(x) > R_SHORT_LEN_MAX)
  |  |  ------------------
  |  |  |  |  407|    131|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  ------------------
  |  |               # define IS_LONG_VEC(x) (XLENGTH(x) > R_SHORT_LEN_MAX)
  |  |  ------------------
  |  |  |  |   77|    131|# define R_SHORT_LEN_MAX 2147483647
  |  |  ------------------
  ------------------
STDVEC_LENGTH:
 4146|  38.5M|R_xlen_t (STDVEC_LENGTH)(SEXP x) { return STDVEC_LENGTH(CHK2(x)); }
  ------------------
  |  |  392|  38.5M|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  ------------------
STDVEC_TRUELENGTH:
 4148|  2.86M|R_xlen_t (STDVEC_TRUELENGTH)(SEXP x) { return STDVEC_TRUELENGTH(CHK2(x)); }
  ------------------
  |  |  393|  2.86M|#define STDVEC_TRUELENGTH(x) (((VECSEXP) (x))->vecsxp.truelength)
  ------------------
SETALTREP:
 4149|    255|attribute_hidden void (SETALTREP)(SEXP x, int v) { SETALTREP(x, v); }
  ------------------
  |  |  243|    255|#define SETALTREP(x, v) (((x)->sxpinfo.alt) = (v))
  ------------------
R_CHAR:
 4155|  43.5M|const char *(R_CHAR)(SEXP x) {
 4156|  43.5M|    if(TYPEOF(x) != CHARSXP) // Han-Tak proposes to prepend  'x && '
  ------------------
  |  |  233|  43.5M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != CHARSXP) // Han-Tak proposes to prepend  'x && '
  ------------------
  |  |  120|  43.5M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (4156:8): [True: 0, False: 43.5M]
  ------------------
 4157|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4158|      0|	      "R_CHAR", "CHARSXP", R_typeToChar(x));
 4159|  43.5M|    return (const char *) CHAR(CHK(x));
  ------------------
  |  |  422|  43.5M|#define CHAR(x)		((const char *) STDVEC_DATAPTR(x))
  |  |  ------------------
  |  |  |  |  420|  43.5M|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  ------------------
  ------------------
 4160|  43.5M|}
STRING_ELT:
 4162|  32.0M|SEXP (STRING_ELT)(SEXP x, R_xlen_t i) {
 4163|  32.0M|    if(TYPEOF(x) != STRSXP)
  ------------------
  |  |  233|  32.0M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != STRSXP)
  ------------------
  |  |  126|  32.0M|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (4163:8): [True: 0, False: 32.0M]
  ------------------
 4164|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4165|      0|	      "STRING_ELT", "character vector", R_typeToChar(x));
 4166|  32.0M|    if (i < 0 || i >= XLENGTH(x))
  ------------------
  |  |  407|  32.0M|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
  |  Branch (4166:9): [True: 0, False: 32.0M]
  |  Branch (4166:18): [True: 0, False: 32.0M]
  ------------------
 4167|      0|	error(_("attempt access index %lld/%lld in STRING_ELT"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt access index %lld/%lld in STRING_ELT"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4168|      0|	      (long long)i, (long long)XLENGTH(x));
  ------------------
  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
 4169|  32.0M|    if (ALTREP(x))
  ------------------
  |  |  242|  32.0M|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  ------------------
  |  |  |  Branch (242:25): [True: 41, False: 32.0M]
  |  |  ------------------
  ------------------
 4170|     41|	return CHK(ALTSTRING_ELT(CHK(x), i));
 4171|  32.0M|    else {
 4172|  32.0M|	SEXP *ps = STDVEC_DATAPTR(CHK(x));
  ------------------
  |  |  420|  32.0M|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  ------------------
 4173|  32.0M|	return CHK(ps[i]);
 4174|  32.0M|    }
 4175|  32.0M|}
VECTOR_ELT:
 4177|  22.1M|SEXP (VECTOR_ELT)(SEXP x, R_xlen_t i) {
 4178|       |    /* We need to allow vector-like types here */
 4179|  22.1M|    if(TYPEOF(x) != VECSXP &&
  ------------------
  |  |  233|  22.1M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != VECSXP &&
  ------------------
  |  |  131|  44.2M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (4179:8): [True: 56, False: 22.0M]
  ------------------
 4180|     56|       TYPEOF(x) != EXPRSXP &&
  ------------------
  |  |  233|     56|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                     TYPEOF(x) != EXPRSXP &&
  ------------------
  |  |  132|  22.1M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (4180:8): [True: 0, False: 56]
  ------------------
 4181|      0|       TYPEOF(x) != WEAKREFSXP)
  ------------------
  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                     TYPEOF(x) != WEAKREFSXP)
  ------------------
  |  |  135|      0|#define WEAKREFSXP  23    /* weak reference */
  ------------------
  |  Branch (4181:8): [True: 0, False: 0]
  ------------------
 4182|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4183|      0|	      "VECTOR_ELT", "list", R_typeToChar(x));
 4184|  22.1M|    if (i < 0 || i >= XLENGTH(x))
  ------------------
  |  |  407|  22.1M|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
  |  Branch (4184:9): [True: 0, False: 22.1M]
  |  Branch (4184:18): [True: 0, False: 22.1M]
  ------------------
 4185|      0|	error(_("attempt access index %lld/%lld in VECTOR_ELT"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt access index %lld/%lld in VECTOR_ELT"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4186|      0|	      (long long)i, (long long)XLENGTH(x));
  ------------------
  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
 4187|  22.1M|    if (ALTREP(x)) {
  ------------------
  |  |  242|  22.1M|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  ------------------
  |  |  |  Branch (242:25): [True: 0, False: 22.1M]
  |  |  ------------------
  ------------------
 4188|      0|	SEXP ans = CHK(ALTLIST_ELT(CHK(x), i));
 4189|       |	/* the element is marked as not mutable since complex
 4190|       |	   assignment can't see reference counts on any intermediate
 4191|       |	   containers in an ALTREP */
 4192|      0|	MARK_NOT_MUTABLE(ans);
  ------------------
  |  |  283|      0|# define MARK_NOT_MUTABLE(x) SET_REFCNT(x, REFCNTMAX)
  |  |  ------------------
  |  |  |  |  256|      0|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4193|      0|        return ans;
 4194|      0|    }
 4195|  22.1M|    else
 4196|  22.1M|        return CHK(VECTOR_ELT_0(CHK(x), i));
  ------------------
  |  |   80|  22.1M|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  ------------------
  |  |  |  |  420|  22.1M|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  ------------------
  ------------------
 4197|  22.1M|}
STDVEC_DATAPTR:
 4216|  62.3M|{
 4217|  62.3M|    if (ALTREP(x))
  ------------------
  |  |  242|  62.3M|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  ------------------
  |  |  |  Branch (242:25): [True: 0, False: 62.3M]
  |  |  ------------------
  ------------------
 4218|      0|	error("cannot get STDVEC_DATAPTR from ALTREP object");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4219|  62.3M|    if (! isVector(x) && TYPEOF(x) != WEAKREFSXP)
  ------------------
  |  |  974|  62.3M|#define isVector		Rf_isVector
  ------------------
                  if (! isVector(x) && TYPEOF(x) != WEAKREFSXP)
  ------------------
  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if (! isVector(x) && TYPEOF(x) != WEAKREFSXP)
  ------------------
  |  |  135|      0|#define WEAKREFSXP  23    /* weak reference */
  ------------------
  |  Branch (4219:9): [True: 0, False: 62.3M]
  |  Branch (4219:26): [True: 0, False: 0]
  ------------------
 4220|      0|	error("STDVEC_DATAPTR can only be applied to a vector, not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4221|      0|	      R_typeToChar(x));
 4222|  62.3M|    CHKZLN(x);
  ------------------
  |  | 4206|  62.3M|# define CHKZLN(x) do {						\
  |  | 4207|  62.3M|	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  392|  62.3M|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (4207:6): [True: 0, False: 62.3M]
  |  |  |  Branch (4207:36): [True: 0, False: 0]
  |  |  ------------------
  |  | 4208|  62.3M|	    return (void *) 1;					\
  |  | 4209|  62.3M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4209:14): [Folded, False: 62.3M]
  |  |  ------------------
  ------------------
 4223|  62.3M|    return STDVEC_DATAPTR(x);
  ------------------
  |  |  420|  62.3M|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  ------------------
 4224|  62.3M|}
DATAPTR_RW:
 4227|    852|void *DATAPTR_RW(SEXP x) { return DATAPTR(x); }
LOGICAL:
 4229|  8.28M|int *(LOGICAL)(SEXP x) {
 4230|  8.28M|    if(TYPEOF(x) != LGLSXP)
  ------------------
  |  |  233|  8.28M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != LGLSXP)
  ------------------
  |  |  121|  8.28M|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (4230:8): [True: 0, False: 8.28M]
  ------------------
 4231|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4232|      0|	      "LOGICAL",  "logical", R_typeToChar(x));
 4233|  8.28M|    CHKZLN(x);
  ------------------
  |  | 4206|  8.28M|# define CHKZLN(x) do {						\
  |  | 4207|  8.28M|	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  392|  8.28M|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  233|     22|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|     22|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (4207:6): [True: 22, False: 8.28M]
  |  |  |  Branch (4207:36): [True: 22, False: 0]
  |  |  ------------------
  |  | 4208|  8.28M|	    return (void *) 1;					\
  |  | 4209|  8.28M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4209:14): [Folded, False: 8.28M]
  |  |  ------------------
  ------------------
 4234|  8.28M|    return LOGICAL(x);
  ------------------
  |  |  423|  8.28M|#define LOGICAL(x)	((int *) DATAPTR(x))
  ------------------
 4235|  8.28M|}
LOGICAL_RO:
 4237|  4.01k|const int *(LOGICAL_RO)(SEXP x) {
 4238|  4.01k|    if(TYPEOF(x) != LGLSXP)
  ------------------
  |  |  233|  4.01k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != LGLSXP)
  ------------------
  |  |  121|  4.01k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (4238:8): [True: 0, False: 4.01k]
  ------------------
 4239|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4240|      0|	      "LOGICAL_RO",  "logical", R_typeToChar(x));
 4241|  4.01k|    CHKZLN(x);
  ------------------
  |  | 4206|  4.01k|# define CHKZLN(x) do {						\
  |  | 4207|  4.01k|	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  392|  4.01k|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  233|     22|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|     22|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (4207:6): [True: 22, False: 3.99k]
  |  |  |  Branch (4207:36): [True: 22, False: 0]
  |  |  ------------------
  |  | 4208|  4.01k|	    return (void *) 1;					\
  |  | 4209|  4.01k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4209:14): [Folded, False: 3.99k]
  |  |  ------------------
  ------------------
 4242|  3.99k|    return LOGICAL_RO(x);
  ------------------
  |  |  429|  3.99k|#define LOGICAL_RO(x)	((const int *) DATAPTR_RO(x))
  ------------------
 4243|  4.01k|}
INTEGER:
 4246|  9.02M|int *(INTEGER)(SEXP x) {
 4247|  9.02M|    if(TYPEOF(x) != INTSXP && TYPEOF(x) != LGLSXP)
  ------------------
  |  |  233|  9.02M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != INTSXP && TYPEOF(x) != LGLSXP)
  ------------------
  |  |  123|  18.0M|#define INTSXP	    13	  /* integer vectors */
  ------------------
                  if(TYPEOF(x) != INTSXP && TYPEOF(x) != LGLSXP)
  ------------------
  |  |  233|  13.4k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != INTSXP && TYPEOF(x) != LGLSXP)
  ------------------
  |  |  121|  13.4k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (4247:8): [True: 13.4k, False: 9.01M]
  |  Branch (4247:31): [True: 0, False: 13.4k]
  ------------------
 4248|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4249|      0|	      "INTEGER", "integer", R_typeToChar(x));
 4250|  9.02M|    CHKZLN(x);
  ------------------
  |  | 4206|  9.02M|# define CHKZLN(x) do {						\
  |  | 4207|  9.02M|	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  392|  9.02M|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  233|     54|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|     54|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (4207:6): [True: 54, False: 9.02M]
  |  |  |  Branch (4207:36): [True: 54, False: 0]
  |  |  ------------------
  |  | 4208|  9.02M|	    return (void *) 1;					\
  |  | 4209|  9.02M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4209:14): [Folded, False: 9.02M]
  |  |  ------------------
  ------------------
 4251|  9.02M|    return INTEGER(x);
  ------------------
  |  |  424|  9.02M|#define INTEGER(x)	((int *) DATAPTR(x))
  ------------------
 4252|  9.02M|}
INTEGER_RO:
 4254|   411k|const int *(INTEGER_RO)(SEXP x) {
 4255|   411k|    if(TYPEOF(x) != INTSXP && TYPEOF(x) != LGLSXP)
  ------------------
  |  |  233|   411k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != INTSXP && TYPEOF(x) != LGLSXP)
  ------------------
  |  |  123|   822k|#define INTSXP	    13	  /* integer vectors */
  ------------------
                  if(TYPEOF(x) != INTSXP && TYPEOF(x) != LGLSXP)
  ------------------
  |  |  233|     18|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != INTSXP && TYPEOF(x) != LGLSXP)
  ------------------
  |  |  121|     18|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (4255:8): [True: 18, False: 411k]
  |  Branch (4255:31): [True: 0, False: 18]
  ------------------
 4256|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4257|      0|	      "INTEGER_RO", "integer", R_typeToChar(x));
 4258|   411k|    CHKZLN(x);
  ------------------
  |  | 4206|   411k|# define CHKZLN(x) do {						\
  |  | 4207|   411k|	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  392|   411k|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  233|    612|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|    612|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (4207:6): [True: 612, False: 410k]
  |  |  |  Branch (4207:36): [True: 612, False: 0]
  |  |  ------------------
  |  | 4208|   411k|	    return (void *) 1;					\
  |  | 4209|   411k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4209:14): [Folded, False: 410k]
  |  |  ------------------
  ------------------
 4259|   410k|    return INTEGER_RO(x);
  ------------------
  |  |  430|   410k|#define INTEGER_RO(x)	((const int *) DATAPTR_RO(x))
  ------------------
 4260|   411k|}
RAW:
 4262|  6.14k|Rbyte *(RAW)(SEXP x) {
 4263|  6.14k|    if(TYPEOF(x) != RAWSXP)
  ------------------
  |  |  233|  6.14k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != RAWSXP)
  ------------------
  |  |  136|  6.14k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (4263:8): [True: 0, False: 6.14k]
  ------------------
 4264|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4265|      0|	      "RAW", "raw", R_typeToChar(x));
 4266|  6.14k|    CHKZLN(x);
  ------------------
  |  | 4206|  6.14k|# define CHKZLN(x) do {						\
  |  | 4207|  6.14k|	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  392|  6.14k|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (4207:6): [True: 0, False: 6.14k]
  |  |  |  Branch (4207:36): [True: 0, False: 0]
  |  |  ------------------
  |  | 4208|  6.14k|	    return (void *) 1;					\
  |  | 4209|  6.14k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4209:14): [Folded, False: 6.14k]
  |  |  ------------------
  ------------------
 4267|  6.14k|    return RAW(x);
  ------------------
  |  |  425|  6.14k|#define RAW(x)		((Rbyte *) DATAPTR(x))
  ------------------
 4268|  6.14k|}
REAL:
 4278|   971k|double *(REAL)(SEXP x) {
 4279|   971k|    if(TYPEOF(x) != REALSXP)
  ------------------
  |  |  233|   971k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != REALSXP)
  ------------------
  |  |  124|   971k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (4279:8): [True: 0, False: 971k]
  ------------------
 4280|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4281|      0|	      "REAL", "numeric", R_typeToChar(x));
 4282|   971k|    CHKZLN(x);
  ------------------
  |  | 4206|   971k|# define CHKZLN(x) do {						\
  |  | 4207|   971k|	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  392|   971k|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  233|    478|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|    478|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (4207:6): [True: 478, False: 971k]
  |  |  |  Branch (4207:36): [True: 478, False: 0]
  |  |  ------------------
  |  | 4208|   971k|	    return (void *) 1;					\
  |  | 4209|   971k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4209:14): [Folded, False: 971k]
  |  |  ------------------
  ------------------
 4283|   971k|    return REAL(x);
  ------------------
  |  |  427|   971k|#define REAL(x)		((double *) DATAPTR(x))
  ------------------
 4284|   971k|}
REAL_RO:
 4286|  12.5k|const double *(REAL_RO)(SEXP x) {
 4287|  12.5k|    if(TYPEOF(x) != REALSXP)
  ------------------
  |  |  233|  12.5k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != REALSXP)
  ------------------
  |  |  124|  12.5k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (4287:8): [True: 0, False: 12.5k]
  ------------------
 4288|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4289|      0|	      "REAL_RO", "numeric", R_typeToChar(x));
 4290|  12.5k|    CHKZLN(x);
  ------------------
  |  | 4206|  12.5k|# define CHKZLN(x) do {						\
  |  | 4207|  12.5k|	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  392|  12.5k|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  233|    478|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|    478|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (4207:6): [True: 478, False: 12.0k]
  |  |  |  Branch (4207:36): [True: 478, False: 0]
  |  |  ------------------
  |  | 4208|  12.5k|	    return (void *) 1;					\
  |  | 4209|  12.5k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4209:14): [Folded, False: 12.0k]
  |  |  ------------------
  ------------------
 4291|  12.0k|    return REAL_RO(x);
  ------------------
  |  |  433|  12.0k|#define REAL_RO(x)	((const double *) DATAPTR_RO(x))
  ------------------
 4292|  12.5k|}
COMPLEX:
 4294|      2|Rcomplex *(COMPLEX)(SEXP x) {
 4295|      2|    if(TYPEOF(x) != CPLXSXP)
  ------------------
  |  |  233|      2|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != CPLXSXP)
  ------------------
  |  |  125|      2|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (4295:8): [True: 0, False: 2]
  ------------------
 4296|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4297|      0|	      "COMPLEX", "complex", R_typeToChar(x));
 4298|      2|    CHKZLN(x);
  ------------------
  |  | 4206|      2|# define CHKZLN(x) do {						\
  |  | 4207|      2|	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  392|      2|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  233|      2|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|      2|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (4207:6): [True: 2, False: 0]
  |  |  |  Branch (4207:36): [True: 2, False: 0]
  |  |  ------------------
  |  | 4208|      2|	    return (void *) 1;					\
  |  | 4209|      2|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4209:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 4299|      0|    return COMPLEX(x);
  ------------------
  |  |  426|      0|#define COMPLEX(x)	((Rcomplex *) DATAPTR(x))
  ------------------
 4300|      2|}
STRING_PTR:
 4310|      8|SEXP *(STRING_PTR)(SEXP x) {
 4311|      8|    if(TYPEOF(x) != STRSXP)
  ------------------
  |  |  233|      8|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != STRSXP)
  ------------------
  |  |  126|      8|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (4311:8): [True: 0, False: 8]
  ------------------
 4312|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4313|      0|	      "STRING_PTR", "character", R_typeToChar(x));
 4314|      8|    CHKZLN(x);
  ------------------
  |  | 4206|      8|# define CHKZLN(x) do {						\
  |  | 4207|      8|	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  392|      8|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (4207:6): [True: 0, False: 8]
  |  |  |  Branch (4207:36): [True: 0, False: 0]
  |  |  ------------------
  |  | 4208|      8|	    return (void *) 1;					\
  |  | 4209|      8|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4209:14): [Folded, False: 8]
  |  |  ------------------
  ------------------
 4315|      8|    return STRING_PTR(x);
  ------------------
  |  |  428|      8|#define STRING_PTR(x)	((SEXP *) DATAPTR(x))
  ------------------
 4316|      8|}
STRING_PTR_RO:
 4318|    255|const SEXP *(STRING_PTR_RO)(SEXP x) {
 4319|    255|    if(TYPEOF(x) != STRSXP)
  ------------------
  |  |  233|    255|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != STRSXP)
  ------------------
  |  |  126|    255|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (4319:8): [True: 0, False: 255]
  ------------------
 4320|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4321|      0|	      __func__, "character", R_typeToChar(x));
 4322|    255|    CHKZLN(x);
  ------------------
  |  | 4206|    255|# define CHKZLN(x) do {						\
  |  | 4207|    255|	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  392|    255|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               	if (STDVEC_LENGTH(CHK(x)) == 0 && TYPEOF(x) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (4207:6): [True: 0, False: 255]
  |  |  |  Branch (4207:36): [True: 0, False: 0]
  |  |  ------------------
  |  | 4208|    255|	    return (void *) 1;					\
  |  | 4209|    255|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4209:14): [Folded, False: 255]
  |  |  ------------------
  ------------------
 4323|    255|    return STRING_PTR_RO(x);
  ------------------
  |  |  434|    255|#define STRING_PTR_RO(x)((const SEXP *) DATAPTR_RO(x))
  ------------------
 4324|    255|}
SET_STRING_ELT:
 4334|  13.8M|void (SET_STRING_ELT)(SEXP x, R_xlen_t i, SEXP v) {
 4335|  13.8M|    if(TYPEOF(CHK(x)) != STRSXP)
  ------------------
  |  |  233|  13.8M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(CHK(x)) != STRSXP)
  ------------------
  |  |  126|  13.8M|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (4335:8): [True: 0, False: 13.8M]
  ------------------
 4336|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4337|      0|	      "SET_STRING_ELT", "character vector", R_typeToChar(x));
 4338|  13.8M|    if(TYPEOF(CHK(v)) != CHARSXP)
  ------------------
  |  |  233|  13.8M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(CHK(v)) != CHARSXP)
  ------------------
  |  |  120|  13.8M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (4338:8): [True: 0, False: 13.8M]
  ------------------
 4339|      0|       error("Value of SET_STRING_ELT() must be a 'CHARSXP' not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4340|      0|	     R_typeToChar(v));
 4341|  13.8M|    if (i < 0 || i >= XLENGTH(x))
  ------------------
  |  |  407|  13.8M|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
  |  Branch (4341:9): [True: 0, False: 13.8M]
  |  Branch (4341:18): [True: 0, False: 13.8M]
  ------------------
 4342|      0|	error(_("attempt to set index %lld/%lld in SET_STRING_ELT"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt to set index %lld/%lld in SET_STRING_ELT"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4343|      0|	      (long long)i, (long long)XLENGTH(x));
  ------------------
  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
 4344|  13.8M|    CHECK_OLD_TO_NEW(x, v);
  ------------------
  |  | 1350|  13.8M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  13.8M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  13.8M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  27.6M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  13.8M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 1.63k, False: 13.8M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 1.63k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  13.8M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  3.27k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  1.63k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 1.63k, False: 0]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 13.8M]
  |  |  ------------------
  ------------------
 4345|  13.8M|    if (ALTREP(x))
  ------------------
  |  |  242|  13.8M|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  ------------------
  |  |  |  Branch (242:25): [True: 1.30k, False: 13.8M]
  |  |  ------------------
  ------------------
 4346|  1.30k|	ALTSTRING_SET_ELT(x, i, v);
 4347|  13.8M|    else {
 4348|  13.8M|	SEXP *ps = STDVEC_DATAPTR(x);
  ------------------
  |  |  420|  13.8M|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  ------------------
 4349|  13.8M|	FIX_REFCNT(x, ps[i], v);
  ------------------
  |  | 1335|  13.8M|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  13.8M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  13.8M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  13.8M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  13.8M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  13.8M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  13.8M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 13.8M, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 13.8M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  13.8M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  13.8M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  13.8M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 13.6M, False: 111k]
  |  |  |  |  ------------------
  |  |  |  | 1325|  13.6M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 13.6M, False: 15]
  |  |  |  |  ------------------
  |  |  |  | 1326|  13.6M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 13.6M]
  |  |  |  |  ------------------
  |  |  |  | 1327|  13.6M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  13.6M|		    else						\
  |  |  |  | 1329|  13.6M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  13.6M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  13.6M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  13.6M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  13.6M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  3.66k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  3.66k|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  3.66k|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 3.66k, False: 13.6M]
  |  |  |  |  |  |  |  Branch (264:30): [True: 3.66k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  13.6M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  3.66k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  3.66k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  13.6M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 13.6M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  13.6M|		}							\
  |  |  |  | 1331|  13.6M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  13.6M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  13.6M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  13.6M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  13.6M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  13.6M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  13.6M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 2.31M, False: 11.3M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  13.6M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  2.31M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  2.31M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  13.6M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 13.6M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 13.6M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  13.6M|	    }								\
  |  |  |  | 1333|  13.8M|	}								\
  |  |  |  | 1334|  13.8M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 13.8M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4350|  13.8M|	ps[i] = v;
 4351|  13.8M|    }
 4352|  13.8M|}
SET_VECTOR_ELT:
 4354|  13.9M|SEXP (SET_VECTOR_ELT)(SEXP x, R_xlen_t i, SEXP v) {
 4355|       |    /*  we need to allow vector-like types here */
 4356|  13.9M|    if(TYPEOF(x) != VECSXP &&
  ------------------
  |  |  233|  13.9M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if(TYPEOF(x) != VECSXP &&
  ------------------
  |  |  131|  27.9M|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (4356:8): [True: 10.0k, False: 13.9M]
  ------------------
 4357|  10.0k|       TYPEOF(x) != EXPRSXP &&
  ------------------
  |  |  233|  10.0k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                     TYPEOF(x) != EXPRSXP &&
  ------------------
  |  |  132|  13.9M|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (4357:8): [True: 9.96k, False: 56]
  ------------------
 4358|  9.96k|       TYPEOF(x) != WEAKREFSXP) {
  ------------------
  |  |  233|  9.96k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                     TYPEOF(x) != WEAKREFSXP) {
  ------------------
  |  |  135|  9.96k|#define WEAKREFSXP  23    /* weak reference */
  ------------------
  |  Branch (4358:8): [True: 0, False: 9.96k]
  ------------------
 4359|      0|	error("%s() can only be applied to a '%s', not a '%s'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4360|      0|	      "SET_VECTOR_ELT", "list", R_typeToChar(x));
 4361|      0|    }
 4362|  13.9M|    if (i < 0 || i >= XLENGTH(x))
  ------------------
  |  |  407|  13.9M|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
  |  Branch (4362:9): [True: 0, False: 13.9M]
  |  Branch (4362:18): [True: 0, False: 13.9M]
  ------------------
 4363|      0|	error(_("attempt to set index %lld/%lld in SET_VECTOR_ELT"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt to set index %lld/%lld in SET_VECTOR_ELT"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4364|      0|	      (long long)i, (long long)XLENGTH(x));
  ------------------
  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
 4365|  13.9M|    if (ALTREP(x))
  ------------------
  |  |  242|  13.9M|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  ------------------
  |  |  |  Branch (242:25): [True: 0, False: 13.9M]
  |  |  ------------------
  ------------------
 4366|      0|        ALTLIST_SET_ELT(x, i, v);
 4367|  13.9M|    else {
 4368|  13.9M|        FIX_REFCNT(x, VECTOR_ELT_0(x, i), v);
  ------------------
  |  | 1335|  13.9M|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  13.9M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  13.9M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  13.9M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  13.9M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  13.9M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  13.9M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 13.9M, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 13.9M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  13.9M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  13.9M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  13.9M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 11.2M, False: 2.71M]
  |  |  |  |  ------------------
  |  |  |  | 1325|  11.2M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 11.2M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  11.2M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 11.2M]
  |  |  |  |  ------------------
  |  |  |  | 1327|  11.2M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  11.2M|		    else						\
  |  |  |  | 1329|  11.2M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  11.2M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  11.2M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  11.2M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  11.2M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  11.2M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  11.2M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  11.2M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 11.2M, False: 847]
  |  |  |  |  |  |  |  Branch (264:30): [True: 77.9k, False: 11.1M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  11.2M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  77.9k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  77.9k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  11.2M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 11.2M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  11.2M|		}							\
  |  |  |  | 1331|  11.2M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  11.2M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  11.2M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  11.2M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  11.2M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  11.2M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  11.2M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 5.58M, False: 5.67M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  11.2M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  5.58M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  5.58M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  11.2M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 11.2M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 11.2M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  11.2M|	    }								\
  |  |  |  | 1333|  13.9M|	}								\
  |  |  |  | 1334|  13.9M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 13.9M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4369|  13.9M|        CHECK_OLD_TO_NEW(x, v);
  ------------------
  |  | 1350|  13.9M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  13.9M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  13.9M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  27.9M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  13.9M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 31.3k, False: 13.9M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 31.3k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  13.9M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  62.6k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  31.3k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|  2.59k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|  2.59k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 28.7k, False: 2.59k]
  |  |  |  |  |  Branch (566:28): [True: 17, False: 2.57k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 13.9M]
  |  |  ------------------
  ------------------
 4370|  13.9M|        SET_VECTOR_ELT_0(x, i, v);
  ------------------
  |  |   81|  13.9M|#define SET_VECTOR_ELT_0(x,i, v) (((SEXP *) STDVEC_DATAPTR(x))[i] = (v))
  |  |  ------------------
  |  |  |  |  420|  13.9M|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  ------------------
  ------------------
 4371|  13.9M|    }
 4372|  13.9M|    return v;
 4373|  13.9M|}
BNDCELL_TAG:
 4402|   368M|int (BNDCELL_TAG)(SEXP cell) { return BNDCELL_TAG(cell); }
  ------------------
  |  |  463|   368M|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  ------------------
BNDCELL_IVAL:
 4408|  1.93M|int (BNDCELL_IVAL)(SEXP cell) { return BNDCELL_IVAL(cell); }
  ------------------
  |  |  497|  1.93M|#define BNDCELL_IVAL(v) ((R_bndval_t *) &CAR0(v))->ival
  |  |  ------------------
  |  |  |  |  441|  1.93M|#define CAR0(e)		((e)->u.listsxp.carval)
  |  |  ------------------
  ------------------
BNDCELL_LVAL:
 4410|      4|int (BNDCELL_LVAL)(SEXP cell) { return BNDCELL_LVAL(cell); }
  ------------------
  |  |  498|      4|#define BNDCELL_LVAL(v) ((R_bndval_t *) &CAR0(v))->ival
  |  |  ------------------
  |  |  |  |  441|      4|#define CAR0(e)		((e)->u.listsxp.carval)
  |  |  ------------------
  ------------------
SET_BNDCELL_DVAL:
 4412|     49|void (SET_BNDCELL_DVAL)(SEXP cell, double v) { SET_BNDCELL_DVAL(cell, v); }
  ------------------
  |  |  500|     49|#define SET_BNDCELL_DVAL(cell, dval) (BNDCELL_DVAL(cell) = (dval))
  |  |  ------------------
  |  |  |  |  496|     49|#define BNDCELL_DVAL(v) ((R_bndval_t *) &CAR0(v))->dval
  |  |  |  |  ------------------
  |  |  |  |  |  |  441|     49|#define CAR0(e)		((e)->u.listsxp.carval)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
SET_BNDCELL_IVAL:
 4414|   388k|void (SET_BNDCELL_IVAL)(SEXP cell, int v) { SET_BNDCELL_IVAL(cell, v); }
  ------------------
  |  |  501|   388k|#define SET_BNDCELL_IVAL(cell, ival) (BNDCELL_IVAL(cell) = (ival))
  |  |  ------------------
  |  |  |  |  497|   388k|#define BNDCELL_IVAL(v) ((R_bndval_t *) &CAR0(v))->ival
  |  |  |  |  ------------------
  |  |  |  |  |  |  441|   388k|#define CAR0(e)		((e)->u.listsxp.carval)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
SET_BNDCELL_LVAL:
 4416|     47|void (SET_BNDCELL_LVAL)(SEXP cell, int v) { SET_BNDCELL_LVAL(cell, v); }
  ------------------
  |  |  502|     47|#define SET_BNDCELL_LVAL(cell, lval) (BNDCELL_LVAL(cell) = (lval))
  |  |  ------------------
  |  |  |  |  498|     47|#define BNDCELL_LVAL(v) ((R_bndval_t *) &CAR0(v))->ival
  |  |  |  |  ------------------
  |  |  |  |  |  |  441|     47|#define CAR0(e)		((e)->u.listsxp.carval)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
INIT_BNDCELL:
 4418|   386k|void (INIT_BNDCELL)(SEXP cell, int type) { INIT_BNDCELL(cell, type); }
  ------------------
  |  |  504|   386k|#define INIT_BNDCELL(cell, type) do {		\
  |  |  505|   386k|	if (BNDCELL_TAG(cell) == 0)		\
  |  |  ------------------
  |  |  |  |  463|   386k|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  ------------------
  |  |  |  Branch (505:6): [True: 386k, False: 0]
  |  |  ------------------
  |  |  506|   386k|	    SETCAR(cell, R_NilValue);		\
  |  |  507|   386k|	SET_BNDCELL_TAG(cell, type);		\
  |  |  ------------------
  |  |  |  |  464|   386k|#define SET_BNDCELL_TAG(e, v) ((e)->sxpinfo.extra = (v))
  |  |  ------------------
  |  |  508|   386k|	SET_MISSING(cell, 0);			\
  |  |  ------------------
  |  |  |  |  457|   386k|#define SET_MISSING(x,v) do { \
  |  |  |  |  458|   386k|  SEXP __x__ = (x); \
  |  |  |  |  459|   386k|  int __v__ = (v); \
  |  |  |  |  460|   386k|  int __other_flags__ = __x__->sxpinfo.gp & ~MISSING_MASK; \
  |  |  |  |  ------------------
  |  |  |  |  |  |  455|   386k|#define MISSING_MASK	15 /* reserve 4 bits--only 2 uses now */
  |  |  |  |  ------------------
  |  |  |  |  461|   386k|  __x__->sxpinfo.gp = __other_flags__ | __v__; \
  |  |  |  |  462|   386k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (462:10): [Folded, False: 386k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  509|   386k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (509:14): [Folded, False: 386k]
  |  |  ------------------
  ------------------
PROMISE_TAG:
 4420|  7.08M|int (PROMISE_TAG)(SEXP cell) { return PROMISE_TAG(cell); }
  ------------------
  |  | 1274|  7.08M|# define PROMISE_TAG(x)  BNDCELL_TAG(x)
  |  |  ------------------
  |  |  |  |  463|  7.08M|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  ------------------
  ------------------
SET_PROMISE_TAG:
 4422|  3.13M|void (SET_PROMISE_TAG)(SEXP cell, int val) { SET_PROMISE_TAG(cell, val); }
  ------------------
  |  | 1275|  3.13M|# define SET_PROMISE_TAG(x, v) SET_BNDCELL_TAG(x, v)
  |  |  ------------------
  |  |  |  |  464|  3.13M|#define SET_BNDCELL_TAG(e, v) ((e)->sxpinfo.extra = (v))
  |  |  ------------------
  ------------------
SET_BNDCELL:
 4433|  1.16M|{
 4434|  1.16M|    CLEAR_BNDCELL_TAG(cell);
  ------------------
  |  | 4424|  1.16M|#define CLEAR_BNDCELL_TAG(cell) do {		\
  |  | 4425|  1.16M|	if (BNDCELL_TAG(cell)) {		\
  |  |  ------------------
  |  |  |  |  463|  1.16M|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (463:24): [True: 59, False: 1.16M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4426|     59|	    CAR0(cell) = R_NilValue;		\
  |  |  ------------------
  |  |  |  |  441|     59|#define CAR0(e)		((e)->u.listsxp.carval)
  |  |  ------------------
  |  | 4427|     59|	    SET_BNDCELL_TAG(cell, 0);		\
  |  |  ------------------
  |  |  |  |  464|     59|#define SET_BNDCELL_TAG(e, v) ((e)->sxpinfo.extra = (v))
  |  |  ------------------
  |  | 4428|     59|	}					\
  |  | 4429|  1.16M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4429:14): [Folded, False: 1.16M]
  |  |  ------------------
  ------------------
 4435|  1.16M|    SETCAR(cell, val);
 4436|  1.16M|}
R_expand_binding_value:
 4439|     35|{
 4440|       |#if BOXED_BINDING_CELLS
 4441|       |    SET_BNDCELL_TAG(b, 0);
 4442|       |#else
 4443|     35|    int enabled = R_GCEnabled;
 4444|     35|    R_GCEnabled = FALSE;
 4445|     35|    int typetag = BNDCELL_TAG(b);
  ------------------
  |  |  463|     35|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  ------------------
 4446|     35|    if (typetag) {
  ------------------
  |  Branch (4446:9): [True: 35, False: 0]
  ------------------
 4447|     35|	union {
 4448|     35|	    SEXP sxpval;
 4449|     35|	    double dval;
 4450|     35|	    int ival;
 4451|     35|	} vv;
 4452|     35|	SEXP val;
 4453|     35|	vv.sxpval = CAR0(b);
  ------------------
  |  |  441|     35|#define CAR0(e)		((e)->u.listsxp.carval)
  ------------------
 4454|     35|	switch (typetag) {
  ------------------
  |  Branch (4454:10): [True: 35, False: 0]
  ------------------
 4455|      1|	case REALSXP:
  ------------------
  |  |  124|      1|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (4455:2): [True: 1, False: 34]
  ------------------
 4456|      1|	    PROTECT(b);
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4457|      1|	    val = ScalarReal(vv.dval);
  ------------------
  |  | 1024|      1|#define ScalarReal		Rf_ScalarReal
  ------------------
 4458|      1|	    SET_BNDCELL(b, val);
 4459|      1|	    INCREMENT_NAMED(val);
  ------------------
  |  |  222|      1|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 1]
  |  |  ------------------
  ------------------
 4460|      1|	    UNPROTECT(1);
  ------------------
  |  |  358|      1|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4461|      1|	    break;
 4462|     32|	case INTSXP:
  ------------------
  |  |  123|     32|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (4462:2): [True: 32, False: 3]
  ------------------
 4463|     32|	    PROTECT(b);
  ------------------
  |  |  357|     32|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4464|     32|	    val = ScalarInteger(vv.ival);
  ------------------
  |  | 1022|     32|#define ScalarInteger		Rf_ScalarInteger
  ------------------
 4465|     32|	    SET_BNDCELL(b, val);
 4466|     32|	    INCREMENT_NAMED(val);
  ------------------
  |  |  222|     32|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 32]
  |  |  ------------------
  ------------------
 4467|     32|	    UNPROTECT(1);
  ------------------
  |  |  358|     32|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4468|     32|	    break;
 4469|      2|	case LGLSXP:
  ------------------
  |  |  121|      2|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (4469:2): [True: 2, False: 33]
  ------------------
 4470|      2|	    PROTECT(b);
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 4471|      2|	    val = ScalarLogical(vv.ival);
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
 4472|      2|	    SET_BNDCELL(b, val);
 4473|      2|	    INCREMENT_NAMED(val);
  ------------------
  |  |  222|      2|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 2]
  |  |  ------------------
  ------------------
 4474|      2|	    UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 4475|      2|	    break;
 4476|     35|	}
 4477|     35|    }
 4478|     35|    R_GCEnabled = enabled;
 4479|     35|#endif
 4480|     35|}
R_args_enable_refcnt:
 4492|  1.54M|{
 4493|  1.54M|#ifdef SWITCH_TO_REFCNT
 4494|       |    /* args is escaping into user C code and might get captured, so
 4495|       |       make sure it is reference counting. Should be able to get rid
 4496|       |       of this function if we reduce use of CONS_NR. */
 4497|  4.63M|    for (SEXP a = args; a != R_NilValue; a = CDR(a))
  ------------------
  |  |  445|  3.08M|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
  |  Branch (4497:25): [True: 3.08M, False: 1.54M]
  ------------------
 4498|  3.08M|	if (! TRACKREFS(a)) {
  ------------------
  |  |  249|  3.08M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  ------------------
  |  |  |  |  233|  3.08M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  ------------------
  |  |  |  |  114|  3.08M|#define CLOSXP	     3	  /* closures */
  |  |  ------------------
  |  |  |  Branch (249:24): [True: 0, False: 3.08M]
  |  |  ------------------
  ------------------
  |  Branch (4498:6): [True: 1.54M, False: 1.54M]
  ------------------
 4499|  1.54M|	    ENABLE_REFCNT(a);
  ------------------
  |  |  279|  1.54M|#define ENABLE_REFCNT(x) SET_TRACKREFS(x, TRUE)
  |  |  ------------------
  |  |  |  |  260|  1.54M|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  ------------------
 4500|  1.54M|	    INCREMENT_REFCNT(CAR(a));
  ------------------
  |  |  267|  1.54M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  268|  1.54M|	SEXP irc__x__ = (x);				      \
  |  |  269|  1.54M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  248|  1.54M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  195|  1.54M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  1.54M|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (269:6): [True: 772k, False: 772k]
  |  |  ------------------
  |  |  270|  1.54M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  ------------------
  |  |  |  |  256|   772k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|   772k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  271|  1.54M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (271:14): [Folded, False: 1.54M]
  |  |  ------------------
  ------------------
 4501|  1.54M|	    INCREMENT_REFCNT(CDR(a));
  ------------------
  |  |  267|  1.54M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  268|  1.54M|	SEXP irc__x__ = (x);				      \
  |  |  269|  1.54M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  248|  1.54M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  ------------------
  |  |  |  |  195|  1.54M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  1.54M|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (269:6): [True: 1.54M, False: 4]
  |  |  ------------------
  |  |  270|  1.54M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  ------------------
  |  |  |  |  256|  1.54M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  1.54M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  271|  1.54M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (271:14): [Folded, False: 1.54M]
  |  |  ------------------
  ------------------
 4502|  1.54M|#ifdef TESTING_WRITE_BARRIER
 4503|       |	    /* this should not see non-tracking arguments */
 4504|  1.54M|	    if (! TRACKREFS(CAR(a)))
  ------------------
  |  |  249|  1.54M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  ------------------
  |  |  |  |  233|  1.54M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  ------------------
  |  |  |  |  114|  1.54M|#define CLOSXP	     3	  /* closures */
  |  |  ------------------
  |  |  |  Branch (249:24): [True: 0, False: 1.54M]
  |  |  ------------------
  ------------------
  |  Branch (4504:10): [True: 0, False: 1.54M]
  ------------------
 4505|      0|		error("argument not tracking references");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4506|  1.54M|#endif
 4507|  1.54M|	}
 4508|  1.54M|#endif
 4509|  1.54M|}
R_try_clear_args_refcnt:
 4512|  1.54M|{
 4513|  1.54M|#ifdef SWITCH_TO_REFCNT
 4514|       |    /* If args excapes properly its reference count will have been
 4515|       |       incremented. If it has no references, then it can be reverted
 4516|       |       to NR and the reference counts on its CAR and CDR can be
 4517|       |       decremented. */
 4518|  4.63M|    while (args != R_NilValue && NO_REFERENCES(args)) {
  ------------------
  |  |  242|  3.08M|#  define NO_REFERENCES(x) (REFCNT(x) == 0)
  |  |  ------------------
  |  |  |  |  248|  3.08M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |  |  Branch (242:28): [True: 3.08M, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (4518:12): [True: 3.08M, False: 1.54M]
  ------------------
 4519|  3.08M|	SEXP next = CDR(args);
  ------------------
  |  |  445|  3.08M|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
 4520|  3.08M|	DISABLE_REFCNT(args);
  ------------------
  |  |  280|  3.08M|#define DISABLE_REFCNT(x) SET_TRACKREFS(x, FALSE)
  |  |  ------------------
  |  |  |  |  260|  3.08M|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  ------------------
 4521|  3.08M|	DECREMENT_REFCNT(CAR(args));
  ------------------
  |  |  262|  3.08M|# define DECREMENT_REFCNT(x) do {					\
  |  |  263|  3.08M|	SEXP drc__x__ = (x);						\
  |  |  264|  3.08M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  ------------------
  |  |  |  |  248|  3.08M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  ------------------
  |  |  |  |  248|  3.08M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  ------------------
  |  |  |  |  195|  3.08M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  3.08M|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (264:6): [True: 3.08M, False: 0]
  |  |  |  Branch (264:30): [True: 772k, False: 2.31M]
  |  |  ------------------
  |  |  265|  3.08M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  ------------------
  |  |  |  |  256|   772k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|   772k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|  3.08M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (266:14): [Folded, False: 3.08M]
  |  |  ------------------
  ------------------
 4522|  3.08M|	DECREMENT_REFCNT(CDR(args));
  ------------------
  |  |  262|  3.08M|# define DECREMENT_REFCNT(x) do {					\
  |  |  263|  3.08M|	SEXP drc__x__ = (x);						\
  |  |  264|  3.08M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  ------------------
  |  |  |  |  248|  3.08M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  ------------------
  |  |  |  |  248|  3.08M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  ------------------
  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  ------------------
  |  |  |  |  195|  3.08M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  3.08M|#define NAMED_BITS 16
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (264:6): [True: 3.08M, False: 0]
  |  |  |  Branch (264:30): [True: 1.54M, False: 1.54M]
  |  |  ------------------
  |  |  265|  3.08M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  ------------------
  |  |  |  |  256|  1.54M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  1.54M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|  3.08M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (266:14): [Folded, False: 3.08M]
  |  |  ------------------
  ------------------
 4523|  3.08M|	args = next;
 4524|  3.08M|    }
 4525|  1.54M|#endif
 4526|  1.54M|}
TAG:
 4529|   381M|SEXP (TAG)(SEXP e) { return CHK(TAG(CHKCONS(e))); }
  ------------------
  |  |  440|   381M|#define TAG(e)		((e)->u.listsxp.tagval)
  ------------------
CAR0:
 4530|   313M|attribute_hidden SEXP (CAR0)(SEXP e) { return CHK(CAR0(CHKCONS(e))); }
  ------------------
  |  |  441|   313M|#define CAR0(e)		((e)->u.listsxp.carval)
  ------------------
CDR:
 4531|   528M|SEXP (CDR)(SEXP e) { return CHK(CDR(CHKCONS(e))); }
  ------------------
  |  |  445|   528M|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
CADR:
 4534|  11.3M|SEXP (CADR)(SEXP e) { return CHK(CADR(CHKCONS(e))); }
  ------------------
  |  |  448|  11.3M|#define CADR(e)		CAR(CDR(e))
  |  |  ------------------
  |  |  |  |  445|  11.3M|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  ------------------
  ------------------
CDDR:
 4535|   783k|SEXP (CDDR)(SEXP e) { return CHK(CDDR(CHKCONS(e))); }
  ------------------
  |  |  449|   783k|#define CDDR(e)		CDR(CDR(e))
  |  |  ------------------
  |  |  |  |  445|   783k|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  ------------------
  ------------------
CDDDR:
 4536|   770k|SEXP (CDDDR)(SEXP e) { return CHK(CDDDR(CHKCONS(e))); }
  ------------------
  |  |  450|   770k|#define CDDDR(e)	CDR(CDR(CDR(e)))
  |  |  ------------------
  |  |  |  |  445|   770k|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  ------------------
  ------------------
CADDR:
 4537|  1.56M|SEXP (CADDR)(SEXP e) { return CHK(CADDR(CHKCONS(e))); }
  ------------------
  |  |  451|  1.56M|#define CADDR(e)	CAR(CDR(CDR(e)))
  |  |  ------------------
  |  |  |  |  445|  1.56M|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  ------------------
  ------------------
CADDDR:
 4538|  1.54M|SEXP (CADDDR)(SEXP e) { return CHK(CADDDR(CHKCONS(e))); }
  ------------------
  |  |  452|  1.54M|#define CADDDR(e)	CAR(CDR(CDR(CDR(e))))
  |  |  ------------------
  |  |  |  |  445|  1.54M|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  ------------------
  ------------------
CAD4R:
 4539|    424|SEXP (CAD4R)(SEXP e) { return CHK(CAD4R(CHKCONS(e))); }
  ------------------
  |  |  453|    424|#define CAD4R(e)	CAR(CDR(CDR(CDR(CDR(e)))))
  |  |  ------------------
  |  |  |  |  445|    424|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  ------------------
  ------------------
CAD5R:
 4540|     16|SEXP (CAD5R)(SEXP e) { return CHK(CAD5R(CHKCONS(e))); }
  ------------------
  |  |  454|     16|#define CAD5R(e)	CAR(CDR(CDR(CDR(CDR(CDR(e))))))
  |  |  ------------------
  |  |  |  |  445|     16|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  ------------------
  ------------------
MISSING:
 4541|   784k|attribute_hidden int (MISSING)(SEXP x) { return MISSING(CHKCONS(x)); }
  ------------------
  |  |  456|   784k|#define MISSING(x)	((x)->sxpinfo.gp & MISSING_MASK)/* for closure calls */
  |  |  ------------------
  |  |  |  |  455|   784k|#define MISSING_MASK	15 /* reserve 4 bits--only 2 uses now */
  |  |  ------------------
  ------------------
SET_TAG:
 4544|  36.8M|{
 4545|  36.8M|    if (CHKCONS(x) == NULL || x == R_NilValue)
  ------------------
  |  Branch (4545:9): [True: 0, False: 36.8M]
  |  Branch (4545:31): [True: 0, False: 36.8M]
  ------------------
 4546|      0|	error(_("bad value"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("bad value"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4547|  36.8M|    FIX_REFCNT(x, TAG(x), v);
  ------------------
  |  | 1335|  36.8M|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  36.8M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  36.8M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  36.8M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  36.8M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  36.8M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  36.8M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 29.1M, False: 7.72M]
  |  |  |  |  |  |  |  Branch (249:24): [True: 6.51k, False: 36.8M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  29.1M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  29.1M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  29.1M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 28.8M, False: 251k]
  |  |  |  |  ------------------
  |  |  |  | 1325|  28.8M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 28.8M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  28.8M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 28.8M]
  |  |  |  |  ------------------
  |  |  |  | 1327|  28.8M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  28.8M|		    else						\
  |  |  |  | 1329|  28.8M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  28.8M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  28.8M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  28.8M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  28.8M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  28.8M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  28.8M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  28.8M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 28.8M, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 8, False: 28.8M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  28.8M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|      8|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|      8|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  28.8M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 28.8M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  28.8M|		}							\
  |  |  |  | 1331|  28.8M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  28.8M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  28.8M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  28.8M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  28.8M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  28.8M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  28.8M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 2.09M, False: 26.7M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  28.8M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  2.09M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  2.09M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  28.8M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 28.8M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 28.8M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  28.8M|	    }								\
  |  |  |  | 1333|  29.1M|	}								\
  |  |  |  | 1334|  36.8M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 36.8M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4548|  36.8M|    CHECK_OLD_TO_NEW(x, v);
  ------------------
  |  | 1350|  36.8M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  36.8M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  36.8M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  73.6M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  36.8M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 47, False: 36.8M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 47, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  36.8M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|     94|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|     47|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|     47|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|     47|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 0, False: 47]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 47]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 36.8M]
  |  |  ------------------
  ------------------
 4549|  36.8M|    TAG(x) = v;
  ------------------
  |  |  440|  36.8M|#define TAG(e)		((e)->u.listsxp.tagval)
  ------------------
 4550|  36.8M|}
SETCAR:
 4553|  38.6M|{
 4554|  38.6M|    if (CHKCONS(x) == NULL || x == R_NilValue)
  ------------------
  |  Branch (4554:9): [True: 0, False: 38.6M]
  |  Branch (4554:31): [True: 0, False: 38.6M]
  ------------------
 4555|      0|	error(_("bad value"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("bad value"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4556|  38.6M|    CLEAR_BNDCELL_TAG(x);
  ------------------
  |  | 4424|  38.6M|#define CLEAR_BNDCELL_TAG(cell) do {		\
  |  | 4425|  38.6M|	if (BNDCELL_TAG(cell)) {		\
  |  |  ------------------
  |  |  |  |  463|  38.6M|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (463:24): [True: 0, False: 38.6M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4426|      0|	    CAR0(cell) = R_NilValue;		\
  |  |  ------------------
  |  |  |  |  441|      0|#define CAR0(e)		((e)->u.listsxp.carval)
  |  |  ------------------
  |  | 4427|      0|	    SET_BNDCELL_TAG(cell, 0);		\
  |  |  ------------------
  |  |  |  |  464|      0|#define SET_BNDCELL_TAG(e, v) ((e)->sxpinfo.extra = (v))
  |  |  ------------------
  |  | 4428|      0|	}					\
  |  | 4429|  38.6M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4429:14): [Folded, False: 38.6M]
  |  |  ------------------
  ------------------
 4557|  38.6M|    if (y == CAR(x))
  ------------------
  |  Branch (4557:9): [True: 397k, False: 38.2M]
  ------------------
 4558|   397k|	return y;
 4559|  38.2M|    FIX_BINDING_REFCNT(x, CAR(x), y);
  ------------------
  |  | 1337|  38.2M|    FIX_REFCNT_EX(x, old, new, TRUE)
  |  |  ------------------
  |  |  |  | 1319|  38.2M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  38.2M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  38.2M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  38.2M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  38.2M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  38.2M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 31.2M, False: 7.03M]
  |  |  |  |  |  |  |  Branch (249:24): [True: 6.35k, False: 38.2M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  31.2M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  31.2M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  31.2M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 31.2M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1325|  31.2M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 31.2M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  31.2M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|  31.2M|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|  31.2M|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 31.2M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [True: 31.2M, Folded]
  |  |  |  |  ------------------
  |  |  |  | 1327|  31.2M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  31.2M|		    else						\
  |  |  |  | 1329|  31.2M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  31.2M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  31.2M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  31.2M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  31.2M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  31.2M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  31.2M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  31.2M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 31.2M, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 16.8M, False: 14.3M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  31.2M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  16.8M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  16.8M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  31.2M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 31.2M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  31.2M|		}							\
  |  |  |  | 1331|  31.2M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  31.2M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  31.2M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  31.2M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  31.2M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  31.2M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  31.2M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 7.38M, False: 23.8M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  31.2M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  7.38M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  7.38M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  31.2M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 31.2M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 31.2M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  31.2M|	    }								\
  |  |  |  | 1333|  31.2M|	}								\
  |  |  |  | 1334|  38.2M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 38.2M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4560|  38.2M|    CHECK_OLD_TO_NEW(x, y);
  ------------------
  |  | 1350|  38.2M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  38.2M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  38.2M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  76.4M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  38.2M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 5.59k, False: 38.2M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 5.59k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  38.2M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  11.1k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  5.59k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|  5.34k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|  5.34k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 251, False: 5.34k]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 5.34k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 38.2M]
  |  |  ------------------
  ------------------
 4561|  38.2M|    CAR0(x) = y;
  ------------------
  |  |  441|  38.2M|#define CAR0(e)		((e)->u.listsxp.carval)
  ------------------
 4562|  38.2M|    return y;
 4563|  38.6M|}
SETCDR:
 4566|  23.7M|{
 4567|  23.7M|    if (CHKCONS(x) == NULL || x == R_NilValue)
  ------------------
  |  Branch (4567:9): [True: 0, False: 23.7M]
  |  Branch (4567:31): [True: 0, False: 23.7M]
  ------------------
 4568|      0|	error(_("bad value"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("bad value"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4569|  23.7M|    FIX_REFCNT(x, CDR(x), y);
  ------------------
  |  | 1335|  23.7M|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  23.7M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  23.7M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  23.7M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  23.7M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  23.7M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  23.7M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 7.41M, False: 16.3M]
  |  |  |  |  |  |  |  Branch (249:24): [True: 6.51k, False: 23.7M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  7.41M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  7.41M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  7.41M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 7.25M, False: 162k]
  |  |  |  |  ------------------
  |  |  |  | 1325|  7.25M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 7.25M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  7.25M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 7.25M]
  |  |  |  |  ------------------
  |  |  |  | 1327|  7.25M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  7.25M|		    else						\
  |  |  |  | 1329|  7.25M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  7.25M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  7.25M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  7.25M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  7.25M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  7.25M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  7.25M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  7.25M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 7.25M, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 3.12M, False: 4.12M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  7.25M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  3.12M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  3.12M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  7.25M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 7.25M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  7.25M|		}							\
  |  |  |  | 1331|  7.25M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  7.25M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  7.25M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  7.25M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  7.25M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  7.25M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  7.25M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 5.68M, False: 1.56M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  7.25M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  5.68M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  5.68M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  7.25M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 7.25M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 7.25M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  7.25M|	    }								\
  |  |  |  | 1333|  7.41M|	}								\
  |  |  |  | 1334|  23.7M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 23.7M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4570|  23.7M|#ifdef TESTING_WRITE_BARRIER
 4571|       |    /* this should not add a non-tracking CDR to a tracking cell */
 4572|  23.7M|    if (TRACKREFS(x) && y && ! TRACKREFS(y))
  ------------------
  |  |  249|  47.4M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  ------------------
  |  |  |  |  233|  23.7M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  ------------------
  |  |  |  |  114|  23.7M|#define CLOSXP	     3	  /* closures */
  |  |  ------------------
  |  |  |  Branch (249:23): [True: 7.41M, False: 16.3M]
  |  |  |  Branch (249:24): [True: 6.51k, False: 23.7M]
  |  |  ------------------
  ------------------
                  if (TRACKREFS(x) && y && ! TRACKREFS(y))
  ------------------
  |  |  249|  7.41M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  ------------------
  |  |  |  |  233|  7.41M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  ------------------
  |  |  |  |  114|  7.41M|#define CLOSXP	     3	  /* closures */
  |  |  ------------------
  |  |  |  Branch (249:24): [True: 0, False: 7.41M]
  |  |  ------------------
  ------------------
  |  Branch (4572:25): [True: 7.41M, False: 0]
  |  Branch (4572:30): [True: 0, False: 7.41M]
  ------------------
 4573|      0|	error("inserting non-tracking CDR in tracking cell");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4574|  23.7M|#endif
 4575|  23.7M|    CHECK_OLD_TO_NEW(x, y);
  ------------------
  |  | 1350|  23.7M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  23.7M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  23.7M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  47.4M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  23.7M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 5.16k, False: 23.7M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 5.16k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  23.7M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  10.3k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  5.16k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|  3.42k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|  3.42k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 1.74k, False: 3.42k]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 3.42k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 23.7M]
  |  |  ------------------
  ------------------
 4576|  23.7M|    CDR(x) = y;
  ------------------
  |  |  445|  23.7M|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
 4577|  23.7M|    return y;
 4578|  23.7M|}
SETCADR:
 4581|  2.86k|{
 4582|  2.86k|    SEXP cell;
 4583|  2.86k|    if (CHKCONS(x) == NULL || x == R_NilValue ||
  ------------------
  |  Branch (4583:9): [True: 0, False: 2.86k]
  |  Branch (4583:31): [True: 0, False: 2.86k]
  ------------------
 4584|  2.86k|	CHKCONS(CDR(x)) == NULL || CDR(x) == R_NilValue)
  ------------------
  |  |  445|  2.86k|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
              	CHKCONS(CDR(x)) == NULL || CDR(x) == R_NilValue)
  ------------------
  |  |  445|  2.86k|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
  |  Branch (4584:2): [True: 0, False: 2.86k]
  |  Branch (4584:29): [True: 0, False: 2.86k]
  ------------------
 4585|      0|	error(_("bad value"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("bad value"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4586|  2.86k|    cell = CDR(x);
  ------------------
  |  |  445|  2.86k|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
 4587|  2.86k|    CLEAR_BNDCELL_TAG(cell);
  ------------------
  |  | 4424|  2.86k|#define CLEAR_BNDCELL_TAG(cell) do {		\
  |  | 4425|  2.86k|	if (BNDCELL_TAG(cell)) {		\
  |  |  ------------------
  |  |  |  |  463|  2.86k|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (463:24): [True: 0, False: 2.86k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 4426|      0|	    CAR0(cell) = R_NilValue;		\
  |  |  ------------------
  |  |  |  |  441|      0|#define CAR0(e)		((e)->u.listsxp.carval)
  |  |  ------------------
  |  | 4427|      0|	    SET_BNDCELL_TAG(cell, 0);		\
  |  |  ------------------
  |  |  |  |  464|      0|#define SET_BNDCELL_TAG(e, v) ((e)->sxpinfo.extra = (v))
  |  |  ------------------
  |  | 4428|      0|	}					\
  |  | 4429|  2.86k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (4429:14): [Folded, False: 2.86k]
  |  |  ------------------
  ------------------
 4588|  2.86k|    FIX_REFCNT(cell, CAR(cell), y);
  ------------------
  |  | 1335|  2.86k|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  2.86k|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  2.86k|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  2.86k|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  2.86k|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  2.86k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  2.86k|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 396, False: 2.46k]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 2.86k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|    396|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|    396|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|    396|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 396, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1325|    396|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 396, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|    396|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 396]
  |  |  |  |  ------------------
  |  |  |  | 1327|    396|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|    396|		    else						\
  |  |  |  | 1329|    396|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|    396|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|    396|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|    396|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|    396|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|    396|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|    396|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|    396|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 396, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 392, False: 4]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|    396|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|    392|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|    392|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|    396|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 396]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|    396|		}							\
  |  |  |  | 1331|    396|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|    396|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|    396|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|    396|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|    396|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|    396|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|    396|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 394, False: 2]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|    396|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|    394|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|    394|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|    396|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 396]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 396, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|    396|	    }								\
  |  |  |  | 1333|    396|	}								\
  |  |  |  | 1334|  2.86k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 2.86k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4589|  2.86k|    CHECK_OLD_TO_NEW(cell, y);
  ------------------
  |  | 1350|  2.86k|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  2.86k|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  2.86k|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  5.72k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  2.86k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 2.86k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  2.86k|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 0, False: 0]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 2.86k]
  |  |  ------------------
  ------------------
 4590|  2.86k|    CAR0(cell) = y;
  ------------------
  |  |  441|  2.86k|#define CAR0(e)		((e)->u.listsxp.carval)
  ------------------
 4591|  2.86k|    return y;
 4592|  2.86k|}
SET_MISSING:
 4652|  16.8M|void (SET_MISSING)(SEXP x, int v) { SET_MISSING(CHKCONS(x), v); }
  ------------------
  |  |  457|  16.8M|#define SET_MISSING(x,v) do { \
  |  |  458|  16.8M|  SEXP __x__ = (x); \
  |  |  459|  16.8M|  int __v__ = (v); \
  |  |  460|  16.8M|  int __other_flags__ = __x__->sxpinfo.gp & ~MISSING_MASK; \
  |  |  ------------------
  |  |  |  |  455|  16.8M|#define MISSING_MASK	15 /* reserve 4 bits--only 2 uses now */
  |  |  ------------------
  |  |  461|  16.8M|  __x__->sxpinfo.gp = __other_flags__ | __v__; \
  |  |  462|  16.8M|} while (0)
  |  |  ------------------
  |  |  |  Branch (462:10): [Folded, False: 16.8M]
  |  |  ------------------
  ------------------
FORMALS:
 4660|  3.91M|SEXP (FORMALS)(SEXP x) { CHKCLOSXP(x); return CHK(FORMALS(CHK(x))); }
  ------------------
  |  | 4657|  3.91M|    if (TYPEOF(x) != CLOSXP && TYPEOF(x) != LISTSXP) \
  |  |  ------------------
  |  |  |  |  233|  3.91M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != CLOSXP && TYPEOF(x) != LISTSXP) \
  |  |  ------------------
  |  |  |  |  114|  7.83M|#define CLOSXP	     3	  /* closures */
  |  |  ------------------
  |  |                   if (TYPEOF(x) != CLOSXP && TYPEOF(x) != LISTSXP) \
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != CLOSXP && TYPEOF(x) != LISTSXP) \
  |  |  ------------------
  |  |  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  |  |  ------------------
  |  |  |  Branch (4657:9): [True: 0, False: 3.91M]
  |  |  |  Branch (4657:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 4658|  3.91M|	error(_("%s: argument of type %s is not a closure"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not a closure"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 4659|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
              SEXP (FORMALS)(SEXP x) { CHKCLOSXP(x); return CHK(FORMALS(CHK(x))); }
  ------------------
  |  |  513|  3.91M|#define FORMALS(x)	((x)->u.closxp.formals)
  ------------------
BODY:
 4661|  11.3M|SEXP (BODY)(SEXP x) { CHKCLOSXP(x); return CHK(BODY(CHK(x))); }
  ------------------
  |  | 4657|  11.3M|    if (TYPEOF(x) != CLOSXP && TYPEOF(x) != LISTSXP) \
  |  |  ------------------
  |  |  |  |  233|  11.3M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != CLOSXP && TYPEOF(x) != LISTSXP) \
  |  |  ------------------
  |  |  |  |  114|  22.6M|#define CLOSXP	     3	  /* closures */
  |  |  ------------------
  |  |                   if (TYPEOF(x) != CLOSXP && TYPEOF(x) != LISTSXP) \
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != CLOSXP && TYPEOF(x) != LISTSXP) \
  |  |  ------------------
  |  |  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  |  |  ------------------
  |  |  |  Branch (4657:9): [True: 0, False: 11.3M]
  |  |  |  Branch (4657:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 4658|  11.3M|	error(_("%s: argument of type %s is not a closure"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not a closure"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 4659|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
              SEXP (BODY)(SEXP x) { CHKCLOSXP(x); return CHK(BODY(CHK(x))); }
  ------------------
  |  |  514|  11.3M|#define BODY(x)		((x)->u.closxp.body)
  ------------------
CLOENV:
 4662|  5.46M|SEXP (CLOENV)(SEXP x) { CHKCLOSXP(x); return CHK(CLOENV(CHK(x))); }
  ------------------
  |  | 4657|  5.46M|    if (TYPEOF(x) != CLOSXP && TYPEOF(x) != LISTSXP) \
  |  |  ------------------
  |  |  |  |  233|  5.46M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != CLOSXP && TYPEOF(x) != LISTSXP) \
  |  |  ------------------
  |  |  |  |  114|  10.9M|#define CLOSXP	     3	  /* closures */
  |  |  ------------------
  |  |                   if (TYPEOF(x) != CLOSXP && TYPEOF(x) != LISTSXP) \
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != CLOSXP && TYPEOF(x) != LISTSXP) \
  |  |  ------------------
  |  |  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  |  |  ------------------
  |  |  |  Branch (4657:9): [True: 0, False: 5.46M]
  |  |  |  Branch (4657:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 4658|  5.46M|	error(_("%s: argument of type %s is not a closure"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not a closure"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 4659|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
              SEXP (CLOENV)(SEXP x) { CHKCLOSXP(x); return CHK(CLOENV(CHK(x))); }
  ------------------
  |  |  515|  5.46M|#define CLOENV(x)	((x)->u.closxp.env)
  ------------------
RDEBUG:
 4663|  7.83M|int (RDEBUG)(SEXP x) { return RDEBUG(CHK(x)); }
  ------------------
  |  |  516|  7.83M|#define RDEBUG(x)	((x)->sxpinfo.debug)
  ------------------
RSTEP:
 4664|  3.91M|attribute_hidden int (RSTEP)(SEXP x) { return RSTEP(CHK(x)); }
  ------------------
  |  |  518|  3.91M|#define RSTEP(x)	((x)->sxpinfo.spare)
  ------------------
SET_FORMALS:
 4670|  3.09M|void (SET_FORMALS)(SEXP x, SEXP v) { FIX_REFCNT(x, FORMALS(x), v); CHECK_OLD_TO_NEW(x, v); FORMALS(x) = v; }
  ------------------
  |  | 1335|  3.09M|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  3.09M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  3.09M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  3.09M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  3.09M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  3.09M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  3.09M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 3.09M, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 3.09M, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  3.09M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  3.09M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  3.09M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 2.70M, False: 385k]
  |  |  |  |  ------------------
  |  |  |  | 1325|  2.70M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 2.70M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  2.70M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 2.70M]
  |  |  |  |  ------------------
  |  |  |  | 1327|  2.70M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  2.70M|		    else						\
  |  |  |  | 1329|  2.70M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  2.70M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  2.70M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  2.70M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  2.70M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  2.70M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  2.70M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  2.70M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 2.70M, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 0, False: 2.70M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  2.70M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|      0|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  2.70M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 2.70M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  2.70M|		}							\
  |  |  |  | 1331|  2.70M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  2.70M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  2.70M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  2.70M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  2.70M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  2.70M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  2.70M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 468k, False: 2.23M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  2.70M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|   468k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|   468k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  2.70M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 2.70M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 2.70M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  2.70M|	    }								\
  |  |  |  | 1333|  3.09M|	}								\
  |  |  |  | 1334|  3.09M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 3.09M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
              void (SET_FORMALS)(SEXP x, SEXP v) { FIX_REFCNT(x, FORMALS(x), v); CHECK_OLD_TO_NEW(x, v); FORMALS(x) = v; }
  ------------------
  |  | 1350|  3.09M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  3.09M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  3.09M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  6.18M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  3.09M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 3.09M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  3.09M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 0, False: 0]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 3.09M]
  |  |  ------------------
  ------------------
              void (SET_FORMALS)(SEXP x, SEXP v) { FIX_REFCNT(x, FORMALS(x), v); CHECK_OLD_TO_NEW(x, v); FORMALS(x) = v; }
  ------------------
  |  |  513|  3.09M|#define FORMALS(x)	((x)->u.closxp.formals)
  ------------------
SET_BODY:
 4672|  3.09M|void (SET_BODY)(SEXP x, SEXP v) { FIX_REFCNT(x, BODY(x), v); CHECK_OLD_TO_NEW(x, v); BODY(x) = v; }
  ------------------
  |  | 1335|  3.09M|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  3.09M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  3.09M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  3.09M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  3.09M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  3.09M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  3.09M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 3.09M, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 3.09M, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  3.09M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  3.09M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  3.09M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 3.09M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1325|  3.09M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 3.09M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  3.09M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 3.09M]
  |  |  |  |  ------------------
  |  |  |  | 1327|  3.09M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  3.09M|		    else						\
  |  |  |  | 1329|  3.09M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  3.09M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  3.09M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  3.09M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  3.09M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  3.09M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  3.09M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  3.09M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 3.09M, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 1, False: 3.09M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  3.09M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|      1|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|      1|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  3.09M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 3.09M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  3.09M|		}							\
  |  |  |  | 1331|  3.09M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  3.09M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  3.09M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  3.09M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  3.09M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  3.09M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  3.09M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 534k, False: 2.55M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  3.09M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|   534k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|   534k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  3.09M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 3.09M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 3.09M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  3.09M|	    }								\
  |  |  |  | 1333|  3.09M|	}								\
  |  |  |  | 1334|  3.09M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 3.09M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
              void (SET_BODY)(SEXP x, SEXP v) { FIX_REFCNT(x, BODY(x), v); CHECK_OLD_TO_NEW(x, v); BODY(x) = v; }
  ------------------
  |  | 1350|  3.09M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  3.09M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  3.09M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  6.18M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  3.09M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 3.09M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  3.09M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 0, False: 0]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 3.09M]
  |  |  ------------------
  ------------------
              void (SET_BODY)(SEXP x, SEXP v) { FIX_REFCNT(x, BODY(x), v); CHECK_OLD_TO_NEW(x, v); BODY(x) = v; }
  ------------------
  |  |  514|  3.09M|#define BODY(x)		((x)->u.closxp.body)
  ------------------
SET_CLOENV:
 4674|  3.09M|void (SET_CLOENV)(SEXP x, SEXP v) { FIX_REFCNT(x, CLOENV(x), v); CHECK_OLD_TO_NEW(x, v); CLOENV(x) = v; }
  ------------------
  |  | 1335|  3.09M|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  3.09M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  3.09M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  3.09M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  3.09M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  3.09M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  3.09M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 3.09M, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 3.09M, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  3.09M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  3.09M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  3.09M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 3.09M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1325|  3.09M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 3.09M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  3.09M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 3.09M]
  |  |  |  |  ------------------
  |  |  |  | 1327|  3.09M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  3.09M|		    else						\
  |  |  |  | 1329|  3.09M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  3.09M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  3.09M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  3.09M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  3.09M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  3.09M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  3.09M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  3.09M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 3.09M, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 0, False: 3.09M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  3.09M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|      0|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  3.09M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 3.09M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  3.09M|		}							\
  |  |  |  | 1331|  3.09M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  3.09M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  3.09M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  3.09M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  3.09M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  3.09M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  3.09M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 3.09M, False: 34]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  3.09M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  3.09M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  3.09M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  3.09M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 3.09M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 3.09M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  3.09M|	    }								\
  |  |  |  | 1333|  3.09M|	}								\
  |  |  |  | 1334|  3.09M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 3.09M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
              void (SET_CLOENV)(SEXP x, SEXP v) { FIX_REFCNT(x, CLOENV(x), v); CHECK_OLD_TO_NEW(x, v); CLOENV(x) = v; }
  ------------------
  |  | 1350|  3.09M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  3.09M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  3.09M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  6.18M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  3.09M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 3.09M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  3.09M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 0, False: 0]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 3.09M]
  |  |  ------------------
  ------------------
              void (SET_CLOENV)(SEXP x, SEXP v) { FIX_REFCNT(x, CLOENV(x), v); CHECK_OLD_TO_NEW(x, v); CLOENV(x) = v; }
  ------------------
  |  |  515|  3.09M|#define CLOENV(x)	((x)->u.closxp.env)
  ------------------
SET_RDEBUG:
 4675|      8|void (SET_RDEBUG)(SEXP x, int v) { SET_RDEBUG(CHK(x), v); }
  ------------------
  |  |  517|      8|#define SET_RDEBUG(x,v)	(((x)->sxpinfo.debug)=(v))
  ------------------
PRIMOFFSET:
 4683|  58.7M|int (PRIMOFFSET)(SEXP x) { return PRIMOFFSET(CHK(x)); }
  ------------------
  |  | 1253|  58.7M|#define PRIMOFFSET(x)	((x)->u.primsxp.offset)
  ------------------
SET_PRIMOFFSET:
 4685|  1.54k|void (SET_PRIMOFFSET)(SEXP x, int v) { SET_PRIMOFFSET(CHK(x), v); }
  ------------------
  |  | 1254|  1.54k|#define SET_PRIMOFFSET(x,v)	(((x)->u.primsxp.offset)=(v))
  ------------------
PRINTNAME:
 4694|  33.7M|SEXP (PRINTNAME)(SEXP x) { CHKSYMSXP(x); return CHK(PRINTNAME(CHK(x))); }
  ------------------
  |  | 4691|  33.7M|    if (x != R_NilValue && TYPEOF(x) != SYMSXP) \
  |  |  ------------------
  |  |  |  |  233|  33.7M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (x != R_NilValue && TYPEOF(x) != SYMSXP) \
  |  |  ------------------
  |  |  |  |  112|  67.5M|#define SYMSXP	     1	  /* symbols */
  |  |  ------------------
  |  |  |  Branch (4691:9): [True: 33.7M, False: 46]
  |  |  |  Branch (4691:28): [True: 0, False: 33.7M]
  |  |  ------------------
  |  | 4692|  33.7M|	error(_("%s: argument of type %s is not a symbol or NULL"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not a symbol or NULL"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 4693|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
              SEXP (PRINTNAME)(SEXP x) { CHKSYMSXP(x); return CHK(PRINTNAME(CHK(x))); }
  ------------------
  |  |  522|  33.7M|#define PRINTNAME(x)	((x)->u.symsxp.pname)
  ------------------
SYMVALUE:
 4695|  23.1M|SEXP (SYMVALUE)(SEXP x) { CHKSYMSXP(x); return CHK(SYMVALUE(CHK(x))); }
  ------------------
  |  | 4691|  23.1M|    if (x != R_NilValue && TYPEOF(x) != SYMSXP) \
  |  |  ------------------
  |  |  |  |  233|  23.1M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (x != R_NilValue && TYPEOF(x) != SYMSXP) \
  |  |  ------------------
  |  |  |  |  112|  46.2M|#define SYMSXP	     1	  /* symbols */
  |  |  ------------------
  |  |  |  Branch (4691:9): [True: 23.1M, False: 0]
  |  |  |  Branch (4691:28): [True: 0, False: 23.1M]
  |  |  ------------------
  |  | 4692|  23.1M|	error(_("%s: argument of type %s is not a symbol or NULL"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not a symbol or NULL"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 4693|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
              SEXP (SYMVALUE)(SEXP x) { CHKSYMSXP(x); return CHK(SYMVALUE(CHK(x))); }
  ------------------
  |  |  523|  23.1M|#define SYMVALUE(x)	((x)->u.symsxp.value)
  ------------------
INTERNAL:
 4696|  2.74M|SEXP (INTERNAL)(SEXP x) { CHKSYMSXP(x); return CHK(INTERNAL(CHK(x))); }
  ------------------
  |  | 4691|  2.74M|    if (x != R_NilValue && TYPEOF(x) != SYMSXP) \
  |  |  ------------------
  |  |  |  |  233|  2.74M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (x != R_NilValue && TYPEOF(x) != SYMSXP) \
  |  |  ------------------
  |  |  |  |  112|  5.48M|#define SYMSXP	     1	  /* symbols */
  |  |  ------------------
  |  |  |  Branch (4691:9): [True: 2.74M, False: 0]
  |  |  |  Branch (4691:28): [True: 0, False: 2.74M]
  |  |  ------------------
  |  | 4692|  2.74M|	error(_("%s: argument of type %s is not a symbol or NULL"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not a symbol or NULL"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 4693|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
              SEXP (INTERNAL)(SEXP x) { CHKSYMSXP(x); return CHK(INTERNAL(CHK(x))); }
  ------------------
  |  |  524|  2.74M|#define INTERNAL(x)	((x)->u.symsxp.internal)
  ------------------
DDVAL:
 4697|  1.19M|int (DDVAL)(SEXP x) { CHKSYMSXP(x); return DDVAL(CHK(x)); }
  ------------------
  |  | 4691|  1.19M|    if (x != R_NilValue && TYPEOF(x) != SYMSXP) \
  |  |  ------------------
  |  |  |  |  233|  1.19M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (x != R_NilValue && TYPEOF(x) != SYMSXP) \
  |  |  ------------------
  |  |  |  |  112|  2.39M|#define SYMSXP	     1	  /* symbols */
  |  |  ------------------
  |  |  |  Branch (4691:9): [True: 1.19M, False: 0]
  |  |  |  Branch (4691:28): [True: 0, False: 1.19M]
  |  |  ------------------
  |  | 4692|  1.19M|	error(_("%s: argument of type %s is not a symbol or NULL"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not a symbol or NULL"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 4693|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
              int (DDVAL)(SEXP x) { CHKSYMSXP(x); return DDVAL(CHK(x)); }
  ------------------
  |  |  526|  1.19M|#define DDVAL(x)	((x)->sxpinfo.gp & DDVAL_MASK) /* for ..1, ..2 etc */
  |  |  ------------------
  |  |  |  |  525|  1.19M|#define DDVAL_MASK	1
  |  |  ------------------
  ------------------
SET_PRINTNAME:
 4700|  14.1k|void (SET_PRINTNAME)(SEXP x, SEXP v) { FIX_REFCNT(x, PRINTNAME(x), v); CHECK_OLD_TO_NEW(x, v); PRINTNAME(x) = v; }
  ------------------
  |  | 1335|  14.1k|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  14.1k|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  14.1k|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  14.1k|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  14.1k|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  14.1k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  14.1k|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 14.1k, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 14.1k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  14.1k|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  14.1k|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  14.1k|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 14.1k, False: 2]
  |  |  |  |  ------------------
  |  |  |  | 1325|  14.1k|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 14.1k, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  14.1k|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 14.1k]
  |  |  |  |  ------------------
  |  |  |  | 1327|  14.1k|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  14.1k|		    else						\
  |  |  |  | 1329|  14.1k|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  14.1k|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  14.1k|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  14.1k|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  14.1k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  14.1k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  14.1k|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  14.1k|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 14.1k, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 0, False: 14.1k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  14.1k|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|      0|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  14.1k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 14.1k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  14.1k|		}							\
  |  |  |  | 1331|  14.1k|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  14.1k|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  14.1k|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  14.1k|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  14.1k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  14.1k|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  14.1k|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 14.1k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  14.1k|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  14.1k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  14.1k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  14.1k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 14.1k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 14.1k, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  14.1k|	    }								\
  |  |  |  | 1333|  14.1k|	}								\
  |  |  |  | 1334|  14.1k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 14.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
              void (SET_PRINTNAME)(SEXP x, SEXP v) { FIX_REFCNT(x, PRINTNAME(x), v); CHECK_OLD_TO_NEW(x, v); PRINTNAME(x) = v; }
  ------------------
  |  | 1350|  14.1k|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  14.1k|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  14.1k|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  28.2k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  14.1k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 14.1k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  14.1k|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 0, False: 0]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 14.1k]
  |  |  ------------------
  ------------------
              void (SET_PRINTNAME)(SEXP x, SEXP v) { FIX_REFCNT(x, PRINTNAME(x), v); CHECK_OLD_TO_NEW(x, v); PRINTNAME(x) = v; }
  ------------------
  |  |  522|  14.1k|#define PRINTNAME(x)	((x)->u.symsxp.pname)
  ------------------
SET_SYMVALUE:
 4704|  19.0k|{
 4705|  19.0k|    if (SYMVALUE(x) == v)
  ------------------
  |  |  523|  19.0k|#define SYMVALUE(x)	((x)->u.symsxp.value)
  ------------------
  |  Branch (4705:9): [True: 14, False: 19.0k]
  ------------------
 4706|     14|	return;
 4707|  19.0k|    FIX_BINDING_REFCNT(x, SYMVALUE(x), v);
  ------------------
  |  | 1337|  19.0k|    FIX_REFCNT_EX(x, old, new, TRUE)
  |  |  ------------------
  |  |  |  | 1319|  19.0k|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  19.0k|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  19.0k|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  19.0k|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  19.0k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  19.0k|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 18.9k, False: 90]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 19.0k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  18.9k|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  18.9k|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  18.9k|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 18.9k, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1325|  18.9k|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 18.9k, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  18.9k|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|  18.9k|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|  18.9k|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 18.9k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [True: 18.9k, Folded]
  |  |  |  |  ------------------
  |  |  |  | 1327|  18.9k|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  18.9k|		    else						\
  |  |  |  | 1329|  18.9k|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  18.9k|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  18.9k|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  18.9k|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  18.9k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  18.9k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  18.9k|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  18.9k|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 18.9k, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 4.74k, False: 14.1k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  18.9k|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  4.74k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  4.74k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  18.9k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 18.9k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  18.9k|		}							\
  |  |  |  | 1331|  18.9k|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  18.9k|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  18.9k|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  18.9k|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  18.9k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  18.9k|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  18.9k|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 8.52k, False: 10.3k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  18.9k|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  8.52k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  8.52k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  18.9k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 18.9k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 18.9k, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  18.9k|	    }								\
  |  |  |  | 1333|  18.9k|	}								\
  |  |  |  | 1334|  19.0k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 19.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4708|  19.0k|    CHECK_OLD_TO_NEW(x, v);
  ------------------
  |  | 1350|  19.0k|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  19.0k|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  19.0k|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  38.0k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  19.0k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 1.66k, False: 17.3k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 1.66k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  19.0k|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  3.32k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  1.66k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      1|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      1|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 1.66k, False: 1]
  |  |  |  |  |  Branch (566:28): [True: 1, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 19.0k]
  |  |  ------------------
  ------------------
 4709|  19.0k|    SYMVALUE(x) = v;
  ------------------
  |  |  523|  19.0k|#define SYMVALUE(x)	((x)->u.symsxp.value)
  ------------------
 4710|  19.0k|}
SET_INTERNAL:
 4713|  1.11k|void (SET_INTERNAL)(SEXP x, SEXP v) {
 4714|  1.11k|    FIX_REFCNT(x, INTERNAL(x), v);
  ------------------
  |  | 1335|  1.11k|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  1.11k|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  1.11k|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  1.11k|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  1.11k|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  1.11k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  1.11k|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 1.11k, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 1.11k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  1.11k|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  1.11k|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  1.11k|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 1.11k, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1325|  1.11k|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 1.11k, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  1.11k|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 1.11k]
  |  |  |  |  ------------------
  |  |  |  | 1327|  1.11k|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  1.11k|		    else						\
  |  |  |  | 1329|  1.11k|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  1.11k|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  1.11k|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  1.11k|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  1.11k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  1.11k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  1.11k|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  1.11k|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 1.11k, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 4, False: 1.11k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  1.11k|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|      4|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|      4|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  1.11k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 1.11k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  1.11k|		}							\
  |  |  |  | 1331|  1.11k|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  1.11k|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  1.11k|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  1.11k|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  1.11k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  1.11k|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  1.11k|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 1.11k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  1.11k|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  1.11k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  1.11k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  1.11k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 1.11k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 1.11k, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  1.11k|	    }								\
  |  |  |  | 1333|  1.11k|	}								\
  |  |  |  | 1334|  1.11k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 1.11k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4715|  1.11k|    CHECK_OLD_TO_NEW(x, v);
  ------------------
  |  | 1350|  1.11k|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  1.11k|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  1.11k|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  2.23k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  1.11k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 1.11k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  1.11k|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 0, False: 0]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 1.11k]
  |  |  ------------------
  ------------------
 4716|  1.11k|    INTERNAL(x) = v;
  ------------------
  |  |  524|  1.11k|#define INTERNAL(x)	((x)->u.symsxp.internal)
  ------------------
 4717|  1.11k|}
SET_DDVAL:
 4718|  14.1k|attribute_hidden void (SET_DDVAL)(SEXP x, int v) { SET_DDVAL(CHK(x), v); }
  ------------------
  |  |  529|  14.1k|#define SET_DDVAL(x,v) ((v) ? SET_DDVAL_BIT(x) : UNSET_DDVAL_BIT(x)) /* for ..1, ..2 etc */
  |  |  ------------------
  |  |  |  |  527|    130|#define SET_DDVAL_BIT(x) (((x)->sxpinfo.gp) |= DDVAL_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |  525|    130|#define DDVAL_MASK	1
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define SET_DDVAL(x,v) ((v) ? SET_DDVAL_BIT(x) : UNSET_DDVAL_BIT(x)) /* for ..1, ..2 etc */
  |  |  ------------------
  |  |  |  |  528|  13.9k|#define UNSET_DDVAL_BIT(x) (((x)->sxpinfo.gp) &= ~DDVAL_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |  525|  13.9k|#define DDVAL_MASK	1
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (529:25): [True: 130, False: 13.9k]
  |  |  ------------------
  ------------------
FRAME:
 4727|  77.5M|SEXP (FRAME)(SEXP x) { CHKENVSXP(x); return CHK(FRAME(CHK(x))); }
  ------------------
  |  | 4723|  77.5M|    if (TYPEOF(x) != ENVSXP && x != R_NilValue)				\
  |  |  ------------------
  |  |  |  |  233|  77.5M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != ENVSXP && x != R_NilValue)				\
  |  |  ------------------
  |  |  |  |  115|   155M|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (4723:9): [True: 0, False: 77.5M]
  |  |  |  Branch (4723:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 4724|  77.5M|	error(_("%s: argument of type %s is not an environment or NULL"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not an environment or NULL"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 4725|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
              SEXP (FRAME)(SEXP x) { CHKENVSXP(x); return CHK(FRAME(CHK(x))); }
  ------------------
  |  |  532|  77.5M|#define FRAME(x)	((x)->u.envsxp.frame)
  ------------------
ENCLOS:
 4729|  18.3M|SEXP (ENCLOS)(SEXP x) { CHKENVSXP(x); return CHK(ENCLOS(CHK(x))); }
  ------------------
  |  | 4723|  18.3M|    if (TYPEOF(x) != ENVSXP && x != R_NilValue)				\
  |  |  ------------------
  |  |  |  |  233|  18.3M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != ENVSXP && x != R_NilValue)				\
  |  |  ------------------
  |  |  |  |  115|  36.7M|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (4723:9): [True: 0, False: 18.3M]
  |  |  |  Branch (4723:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 4724|  18.3M|	error(_("%s: argument of type %s is not an environment or NULL"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not an environment or NULL"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 4725|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
              SEXP (ENCLOS)(SEXP x) { CHKENVSXP(x); return CHK(ENCLOS(CHK(x))); }
  ------------------
  |  |  533|  18.3M|#define ENCLOS(x)	((x)->u.envsxp.enclos)
  ------------------
HASHTAB:
 4731|  65.3M|SEXP (HASHTAB)(SEXP x) { CHKENVSXP(x); return CHK(HASHTAB(CHK(x))); }
  ------------------
  |  | 4723|  65.3M|    if (TYPEOF(x) != ENVSXP && x != R_NilValue)				\
  |  |  ------------------
  |  |  |  |  233|  65.3M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != ENVSXP && x != R_NilValue)				\
  |  |  ------------------
  |  |  |  |  115|   130M|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (4723:9): [True: 0, False: 65.3M]
  |  |  |  Branch (4723:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 4724|  65.3M|	error(_("%s: argument of type %s is not an environment or NULL"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not an environment or NULL"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 4725|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
              SEXP (HASHTAB)(SEXP x) { CHKENVSXP(x); return CHK(HASHTAB(CHK(x))); }
  ------------------
  |  |  534|  65.3M|#define HASHTAB(x)	((x)->u.envsxp.hashtab)
  ------------------
ENVFLAGS:
 4733|  19.0M|int (ENVFLAGS)(SEXP x) { CHKENVSXP(x); return ENVFLAGS(CHK(x)); }
  ------------------
  |  | 4723|  19.0M|    if (TYPEOF(x) != ENVSXP && x != R_NilValue)				\
  |  |  ------------------
  |  |  |  |  233|  19.0M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |                   if (TYPEOF(x) != ENVSXP && x != R_NilValue)				\
  |  |  ------------------
  |  |  |  |  115|  38.0M|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  |  |  |  Branch (4723:9): [True: 0, False: 19.0M]
  |  |  |  Branch (4723:32): [True: 0, False: 0]
  |  |  ------------------
  |  | 4724|  19.0M|	error(_("%s: argument of type %s is not an environment or NULL"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("%s: argument of type %s is not an environment or NULL"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 4725|      0|	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  |  |  ------------------
  |  |               	      __func__, sexptype2char(TYPEOF(x)))
  |  |  ------------------
  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  ------------------
              int (ENVFLAGS)(SEXP x) { CHKENVSXP(x); return ENVFLAGS(CHK(x)); }
  ------------------
  |  |  535|  19.0M|#define ENVFLAGS(x)	((x)->sxpinfo.gp)	/* for environments */
  ------------------
SET_FRAME:
 4737|  9.29M|void (SET_FRAME)(SEXP x, SEXP v) { FIX_REFCNT(x, FRAME(x), v); CHECK_OLD_TO_NEW(x, v); FRAME(x) = v; }
  ------------------
  |  | 1335|  9.29M|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  9.29M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  9.29M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  9.29M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  9.29M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  9.29M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  9.29M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 9.29M, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 9.29M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  9.29M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  9.29M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  9.29M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 9.29M, False: 44]
  |  |  |  |  ------------------
  |  |  |  | 1325|  9.29M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 9.29M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  9.29M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 9.29M]
  |  |  |  |  ------------------
  |  |  |  | 1327|  9.29M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  9.29M|		    else						\
  |  |  |  | 1329|  9.29M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  9.29M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  9.29M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  9.29M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  9.29M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  9.29M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  9.29M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  9.29M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 9.29M, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 9.29M, False: 30]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  9.29M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  9.29M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  9.29M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  9.29M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 9.29M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  9.29M|		}							\
  |  |  |  | 1331|  9.29M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  9.29M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  9.29M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  9.29M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  9.29M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  9.29M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  9.29M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 9.29M, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  9.29M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  9.29M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  9.29M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  9.29M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 9.29M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 9.29M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  9.29M|	    }								\
  |  |  |  | 1333|  9.29M|	}								\
  |  |  |  | 1334|  9.29M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 9.29M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
              void (SET_FRAME)(SEXP x, SEXP v) { FIX_REFCNT(x, FRAME(x), v); CHECK_OLD_TO_NEW(x, v); FRAME(x) = v; }
  ------------------
  |  | 1350|  9.29M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  9.29M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  9.29M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  18.5M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  9.29M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 790, False: 9.29M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 790, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  9.29M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  1.58k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    790|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 790, False: 0]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 9.29M]
  |  |  ------------------
  ------------------
              void (SET_FRAME)(SEXP x, SEXP v) { FIX_REFCNT(x, FRAME(x), v); CHECK_OLD_TO_NEW(x, v); FRAME(x) = v; }
  ------------------
  |  |  532|  9.29M|#define FRAME(x)	((x)->u.envsxp.frame)
  ------------------
SET_ENCLOS:
 4741|  2.75M|{
 4742|  2.75M|    if (v == R_NilValue)
  ------------------
  |  Branch (4742:9): [True: 0, False: 2.75M]
  ------------------
 4743|       |	/* mainly to handle unserializing old files */
 4744|      0|	v = R_EmptyEnv;
 4745|  2.75M|    if (TYPEOF(v) != ENVSXP)
  ------------------
  |  |  233|  2.75M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if (TYPEOF(v) != ENVSXP)
  ------------------
  |  |  115|  2.75M|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (4745:9): [True: 0, False: 2.75M]
  ------------------
 4746|      0|	error(_("'parent' is not an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'parent' is not an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4747|  5.51M|    for (SEXP e = v; e != R_NilValue; e = ENCLOS(e))
  ------------------
  |  |  533|  2.75M|#define ENCLOS(x)	((x)->u.envsxp.enclos)
  ------------------
  |  Branch (4747:22): [True: 2.75M, False: 2.75M]
  ------------------
 4748|  2.75M|	if (e == x)
  ------------------
  |  Branch (4748:6): [True: 0, False: 2.75M]
  ------------------
 4749|      0|	    error(_("cycles in parent chains are not allowed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("cycles in parent chains are not allowed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4750|  2.75M|    FIX_REFCNT(x, ENCLOS(x), v);
  ------------------
  |  | 1335|  2.75M|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  2.75M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  2.75M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  2.75M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  2.75M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  2.75M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  2.75M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 2.75M, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 2.75M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  2.75M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  2.75M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  2.75M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 2.75M, False: 16]
  |  |  |  |  ------------------
  |  |  |  | 1325|  2.75M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 2.75M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  2.75M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 2.75M]
  |  |  |  |  ------------------
  |  |  |  | 1327|  2.75M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  2.75M|		    else						\
  |  |  |  | 1329|  2.75M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  2.75M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  2.75M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  2.75M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  2.75M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  2.75M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  2.75M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  2.75M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 2.75M, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 1.17M, False: 1.57M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  2.75M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  1.17M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  1.17M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  2.75M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 2.75M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  2.75M|		}							\
  |  |  |  | 1331|  2.75M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  2.75M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  2.75M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  2.75M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  2.75M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  2.75M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  2.75M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 83.8k, False: 2.67M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  2.75M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  83.8k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  83.8k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  2.75M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 2.75M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 2.75M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  2.75M|	    }								\
  |  |  |  | 1333|  2.75M|	}								\
  |  |  |  | 1334|  2.75M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 2.75M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4751|  2.75M|    CHECK_OLD_TO_NEW(x, v);
  ------------------
  |  | 1350|  2.75M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  2.75M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  2.75M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  5.50M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  2.75M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 610, False: 2.75M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 610, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  2.75M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  1.22k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    610|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|    602|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|    602|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 8, False: 602]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 602]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 2.75M]
  |  |  ------------------
  ------------------
 4752|  2.75M|    ENCLOS(x) = v;
  ------------------
  |  |  533|  2.75M|#define ENCLOS(x)	((x)->u.envsxp.enclos)
  ------------------
 4753|  2.75M|}
SET_HASHTAB:
 4755|  1.40k|void (SET_HASHTAB)(SEXP x, SEXP v) { FIX_REFCNT(x, HASHTAB(x), v); CHECK_OLD_TO_NEW(x, v); HASHTAB(x) = v; }
  ------------------
  |  | 1335|  1.40k|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  1.40k|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  1.40k|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  1.40k|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  1.40k|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  1.40k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  1.40k|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 1.40k, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 1.40k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  1.40k|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  1.40k|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  1.40k|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 1.40k, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1325|  1.40k|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 1.40k, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  1.40k|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 1.40k]
  |  |  |  |  ------------------
  |  |  |  | 1327|  1.40k|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  1.40k|		    else						\
  |  |  |  | 1329|  1.40k|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  1.40k|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  1.40k|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  1.40k|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  1.40k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  1.40k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  1.40k|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  1.40k|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 1.40k, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 601, False: 803]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  1.40k|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|    601|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|    601|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  1.40k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 1.40k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  1.40k|		}							\
  |  |  |  | 1331|  1.40k|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  1.40k|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  1.40k|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  1.40k|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  1.40k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  1.40k|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  1.40k|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 1.40k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  1.40k|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  1.40k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  1.40k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  1.40k|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 1.40k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 1.40k, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  1.40k|	    }								\
  |  |  |  | 1333|  1.40k|	}								\
  |  |  |  | 1334|  1.40k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 1.40k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
              void (SET_HASHTAB)(SEXP x, SEXP v) { FIX_REFCNT(x, HASHTAB(x), v); CHECK_OLD_TO_NEW(x, v); HASHTAB(x) = v; }
  ------------------
  |  | 1350|  1.40k|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  1.40k|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  1.40k|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  2.80k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  1.40k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 30, False: 1.37k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 30, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  1.40k|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|     60|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|     30|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 30, False: 0]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 1.40k]
  |  |  ------------------
  ------------------
              void (SET_HASHTAB)(SEXP x, SEXP v) { FIX_REFCNT(x, HASHTAB(x), v); CHECK_OLD_TO_NEW(x, v); HASHTAB(x) = v; }
  ------------------
  |  |  534|  1.40k|#define HASHTAB(x)	((x)->u.envsxp.hashtab)
  ------------------
SET_ENVFLAGS:
 4757|     64|void (SET_ENVFLAGS)(SEXP x, int v) { SET_ENVFLAGS(x, v); }
  ------------------
  |  |  536|     64|#define SET_ENVFLAGS(x,v)	(((x)->sxpinfo.gp)=(v))
  ------------------
PRCODE:
 4760|  14.0M|SEXP (PRCODE)(SEXP x) { return CHK(PRCODE(CHK(x))); }
  ------------------
  |  | 1264|  14.0M|#define PRCODE(x)	((x)->u.promsxp.expr)
  ------------------
PRENV:
 4761|  9.37M|SEXP (PRENV)(SEXP x) { return CHK(PRENV(CHK(x))); }
  ------------------
  |  | 1265|  9.37M|#define PRENV(x)	((x)->u.promsxp.env)
  ------------------
PRVALUE:
 4762|  11.3M|SEXP (PRVALUE)(SEXP x) { return CHK(PRVALUE(CHK(x))); }
  ------------------
  |  | 1271|  11.3M|    (PROMISE_TAG(x) ? R_expand_promise_value(x) : PRVALUE0(x))
  |  |  ------------------
  |  |  |  | 1274|  11.3M|# define PROMISE_TAG(x)  BNDCELL_TAG(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |  463|  11.3M|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (463:24): [True: 0, False: 11.3M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                   (PROMISE_TAG(x) ? R_expand_promise_value(x) : PRVALUE0(x))
  |  |  ------------------
  |  |  |  | 1269|  11.3M|# define PRVALUE0(x) ((x)->u.promsxp.value)
  |  |  ------------------
  ------------------
PRSEEN:
 4763|  10.5M|attribute_hidden int (PRSEEN)(SEXP x) { return PRSEEN(CHK(x)); }
  ------------------
  |  | 1266|  10.5M|#define PRSEEN(x)	((x)->sxpinfo.gp)
  ------------------
PROMISE_IS_EVALUATED:
 4766|  28.1M|{
 4767|  28.1M|    x = CHK(x);
 4768|  28.1M|    return PROMISE_IS_EVALUATED(x);
  ------------------
  |  | 1273|  28.1M|    (PROMISE_TAG(x) || PRVALUE0(x) != R_UnboundValue)
  |  |  ------------------
  |  |  |  | 1274|  28.1M|# define PROMISE_TAG(x)  BNDCELL_TAG(x)
  |  |  |  |  ------------------
  |  |  |  |  |  |  463|  56.3M|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (463:24): [True: 0, False: 28.1M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |                   (PROMISE_TAG(x) || PRVALUE0(x) != R_UnboundValue)
  |  |  ------------------
  |  |  |  | 1269|  28.1M|# define PRVALUE0(x) ((x)->u.promsxp.value)
  |  |  ------------------
  |  |  |  Branch (1273:24): [True: 7.03M, False: 21.1M]
  |  |  ------------------
  ------------------
 4769|  28.1M|}
SET_PRENV:
 4771|  12.1M|void (SET_PRENV)(SEXP x, SEXP v){ FIX_REFCNT(x, PRENV(x), v); CHECK_OLD_TO_NEW(x, v); PRENV(x) = v; }
  ------------------
  |  | 1335|  12.1M|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  12.1M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  12.1M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  12.1M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  12.1M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  12.1M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  12.1M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 12.1M, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 12.1M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  12.1M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  12.1M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  12.1M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 9.76M, False: 2.40M]
  |  |  |  |  ------------------
  |  |  |  | 1325|  9.76M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 9.76M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  9.76M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 9.76M]
  |  |  |  |  ------------------
  |  |  |  | 1327|  9.76M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  9.76M|		    else						\
  |  |  |  | 1329|  9.76M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  9.76M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  9.76M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  9.76M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  9.76M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  9.76M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  9.76M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  9.76M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 9.76M, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 9.76M, False: 4.46k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  9.76M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  9.76M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  9.76M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  9.76M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 9.76M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  9.76M|		}							\
  |  |  |  | 1331|  9.76M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  9.76M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  9.76M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  9.76M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  9.76M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  9.76M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  9.76M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 82, False: 9.76M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  9.76M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|     82|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|     82|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  9.76M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 9.76M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 9.76M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  9.76M|	    }								\
  |  |  |  | 1333|  12.1M|	}								\
  |  |  |  | 1334|  12.1M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 12.1M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
              void (SET_PRENV)(SEXP x, SEXP v){ FIX_REFCNT(x, PRENV(x), v); CHECK_OLD_TO_NEW(x, v); PRENV(x) = v; }
  ------------------
  |  | 1350|  12.1M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  12.1M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  12.1M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  24.3M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  12.1M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 3.44k, False: 12.1M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 3.44k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  12.1M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  6.89k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  3.44k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|  3.44k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|  3.44k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 0, False: 3.44k]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 3.44k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 12.1M]
  |  |  ------------------
  ------------------
              void (SET_PRENV)(SEXP x, SEXP v){ FIX_REFCNT(x, PRENV(x), v); CHECK_OLD_TO_NEW(x, v); PRENV(x) = v; }
  ------------------
  |  | 1265|  12.1M|#define PRENV(x)	((x)->u.promsxp.env)
  ------------------
SET_PRCODE:
 4772|  4.74M|void (SET_PRCODE)(SEXP x, SEXP v) { FIX_REFCNT(x, PRCODE(x), v); CHECK_OLD_TO_NEW(x, v); PRCODE(x) = v; }
  ------------------
  |  | 1335|  4.74M|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  4.74M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  4.74M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  4.74M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  4.74M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  4.74M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  4.74M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 4.74M, False: 0]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 4.74M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  4.74M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  4.74M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  4.74M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 4.35M, False: 389k]
  |  |  |  |  ------------------
  |  |  |  | 1325|  4.35M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 4.35M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  4.35M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 4.35M]
  |  |  |  |  ------------------
  |  |  |  | 1327|  4.35M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  4.35M|		    else						\
  |  |  |  | 1329|  4.35M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  4.35M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  4.35M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  4.35M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  4.35M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  4.35M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  4.35M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  4.35M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 4.35M, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 3.64M, False: 708k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  4.35M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  3.64M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  3.64M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  4.35M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 4.35M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  4.35M|		}							\
  |  |  |  | 1331|  4.35M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  4.35M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  4.35M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  4.35M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  4.35M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  4.35M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  4.35M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 0, False: 4.35M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  4.35M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|      0|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|      0|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  4.35M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 4.35M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 4.35M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  4.35M|	    }								\
  |  |  |  | 1333|  4.74M|	}								\
  |  |  |  | 1334|  4.74M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 4.74M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
              void (SET_PRCODE)(SEXP x, SEXP v) { FIX_REFCNT(x, PRCODE(x), v); CHECK_OLD_TO_NEW(x, v); PRCODE(x) = v; }
  ------------------
  |  | 1350|  4.74M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  4.74M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  4.74M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  9.48M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  4.74M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 1.37k, False: 4.74M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 1.37k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  4.74M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  2.74k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  1.37k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|  1.37k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|  1.37k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 0, False: 1.37k]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 1.37k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 4.74M]
  |  |  ------------------
  ------------------
              void (SET_PRCODE)(SEXP x, SEXP v) { FIX_REFCNT(x, PRCODE(x), v); CHECK_OLD_TO_NEW(x, v); PRCODE(x) = v; }
  ------------------
  |  | 1264|  4.74M|#define PRCODE(x)	((x)->u.promsxp.expr)
  ------------------
SET_PRSEEN:
 4773|  15.6M|attribute_hidden void (SET_PRSEEN)(SEXP x, int v) { SET_PRSEEN(CHK(x), v); }
  ------------------
  |  | 1267|  15.6M|#define SET_PRSEEN(x,v)	(((x)->sxpinfo.gp)=(v))
  ------------------
SET_PRVALUE:
 4776|  13.7M|{
 4777|  13.7M|    if (TYPEOF(x) != PROMSXP)
  ------------------
  |  |  233|  13.7M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if (TYPEOF(x) != PROMSXP)
  ------------------
  |  |  116|  13.7M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (4777:9): [True: 0, False: 13.7M]
  ------------------
 4778|      0|	error("expecting a 'PROMSXP', not a '%s'", R_typeToChar(x));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4779|  13.7M|#ifdef IMMEDIATE_PROMISE_VALUES
 4780|  13.7M|    if (PROMISE_TAG(x)) {
  ------------------
  |  | 1274|  13.7M|# define PROMISE_TAG(x)  BNDCELL_TAG(x)
  |  |  ------------------
  |  |  |  |  463|  13.7M|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (463:24): [True: 2, False: 13.7M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4781|      2|	SET_PROMISE_TAG(x, 0);
  ------------------
  |  | 1275|      2|# define SET_PROMISE_TAG(x, v) SET_BNDCELL_TAG(x, v)
  |  |  ------------------
  |  |  |  |  464|      2|#define SET_BNDCELL_TAG(e, v) ((e)->sxpinfo.extra = (v))
  |  |  ------------------
  ------------------
 4782|      2|	PRVALUE0(x) = R_UnboundValue;
  ------------------
  |  | 1269|      2|# define PRVALUE0(x) ((x)->u.promsxp.value)
  ------------------
 4783|      2|    }
 4784|  13.7M|#endif
 4785|  13.7M|    FIX_REFCNT(x, PRVALUE0(x), v);
  ------------------
  |  | 1335|  13.7M|#define FIX_REFCNT(x, old, new) FIX_REFCNT_EX(x, old, new, FALSE)
  |  |  ------------------
  |  |  |  | 1319|  13.7M|#define FIX_REFCNT_EX(x, old, new, chkpnd) do {				\
  |  |  |  | 1320|  13.7M|	SEXP __x__ = (x);						\
  |  |  |  | 1321|  13.7M|	if (TRACKREFS(__x__)) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  |  249|  13.7M|# define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  13.7M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               # define TRACKREFS(x) (TYPEOF(x) == CLOSXP ? TRUE : ! (x)->sxpinfo.spare)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  13.7M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (249:23): [True: 12.9M, False: 771k]
  |  |  |  |  |  |  |  Branch (249:24): [True: 0, False: 13.7M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1322|  12.9M|	    SEXP __old__ = (old);					\
  |  |  |  | 1323|  12.9M|	    SEXP __new__ = (new);					\
  |  |  |  | 1324|  12.9M|	    if (__old__ != __new__) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1324:10): [True: 11.3M, False: 1.55M]
  |  |  |  |  ------------------
  |  |  |  | 1325|  11.3M|		if (__old__) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1325:7): [True: 11.3M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1326|  11.3M|		    if ((chkpnd) && ASSIGNMENT_PENDING(__x__))		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  321|      0|#define ASSIGNMENT_PENDING(x) ((x)->sxpinfo.gp & ASSIGNMENT_PENDING_MASK)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (321:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1326:11): [Folded, False: 11.3M]
  |  |  |  |  ------------------
  |  |  |  | 1327|  11.3M|			SET_ASSIGNMENT_PENDING(__x__, FALSE);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  322|      0|#define SET_ASSIGNMENT_PENDING(x, v) do {			\
  |  |  |  |  |  |  323|      0|	if (v) (((x)->sxpinfo.gp) |= ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (323:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  324|      0|	else (((x)->sxpinfo.gp) &= ~ASSIGNMENT_PENDING_MASK);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  320|      0|#define ASSIGNMENT_PENDING_MASK (1 << 11)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  325|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (325:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1328|  11.3M|		    else						\
  |  |  |  | 1329|  11.3M|			DECREMENT_REFCNT(__old__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  262|  11.3M|# define DECREMENT_REFCNT(x) do {					\
  |  |  |  |  |  |  263|  11.3M|	SEXP drc__x__ = (x);						\
  |  |  |  |  |  |  264|  11.3M|	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  11.3M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  11.3M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(drc__x__) > 0 && REFCNT(drc__x__) < REFCNTMAX)	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  11.3M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  11.3M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (264:6): [True: 11.3M, False: 0]
  |  |  |  |  |  |  |  Branch (264:30): [True: 2.02M, False: 9.36M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  265|  11.3M|	    SET_REFCNT(drc__x__, REFCNT(drc__x__) - 1);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  2.02M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  2.02M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  266|  11.3M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (266:14): [Folded, False: 11.3M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  | 1330|  11.3M|		}							\
  |  |  |  | 1331|  11.3M|		if (__new__) INCREMENT_REFCNT(__new__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  267|  11.3M|# define INCREMENT_REFCNT(x) do {			      \
  |  |  |  |  |  |  268|  11.3M|	SEXP irc__x__ = (x);				      \
  |  |  |  |  |  |  269|  11.3M|	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  11.3M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	if (REFCNT(irc__x__) < REFCNTMAX)		      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  195|  11.3M|# define REFCNTMAX ((1 << NAMED_BITS) - 1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  126|  11.3M|#define NAMED_BITS 16
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (269:6): [True: 4.79M, False: 6.59M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  270|  11.3M|	    SET_REFCNT(irc__x__, REFCNT(irc__x__) + 1);	      \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  256|  4.79M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  248|  4.79M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  271|  11.3M|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (271:14): [Folded, False: 11.3M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1331:7): [True: 11.3M, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1332|  11.3M|	    }								\
  |  |  |  | 1333|  12.9M|	}								\
  |  |  |  | 1334|  13.7M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1334:14): [Folded, False: 13.7M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 4786|  13.7M|    CHECK_OLD_TO_NEW(x, v);
  ------------------
  |  | 1350|  13.7M|#define CHECK_OLD_TO_NEW(x,y) do { \
  |  | 1351|  13.7M|  if (NODE_IS_OLDER(CHK(x), CHK(y))) old_to_new(x,y);  } while (0)
  |  |  ------------------
  |  |  |  |  565|  13.7M|    (NODE_IS_MARKED(x) && (y) && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  27.4M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  13.7M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (268:27): [True: 3.45k, False: 13.7M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (565:27): [True: 3.45k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  566|  13.7M|   (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  6.91k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  3.45k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|  3.00k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |                  (! NODE_IS_MARKED(y) || NODE_GENERATION(x) > NODE_GENERATION(y)))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|  3.00k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (566:5): [True: 458, False: 3.00k]
  |  |  |  |  |  Branch (566:28): [True: 0, False: 3.00k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1351:65): [Folded, False: 13.7M]
  |  |  ------------------
  ------------------
 4787|  13.7M|    PRVALUE0(x) = v;
  ------------------
  |  | 1269|  13.7M|# define PRVALUE0(x) ((x)->u.promsxp.value)
  ------------------
 4788|  13.7M|}
IF_PROMSXP_SET_PRVALUE:
 4792|   776k|{
 4793|       |    /* promiseArgs produces a list containing promises or R_MissingArg.
 4794|       |       Using IF_PROMSXP_SET_PRVALUE avoids corrupting R_MissingArg. */
 4795|   776k|    if (TYPEOF(x) == PROMSXP)
  ------------------
  |  |  233|   776k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if (TYPEOF(x) == PROMSXP)
  ------------------
  |  |  116|   776k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (4795:9): [True: 776k, False: 0]
  ------------------
 4796|   776k|        SET_PRVALUE(x, v);
 4797|   776k|}
HASHASH:
 4802|  5.18M|int (HASHASH)(SEXP x) { return HASHASH(CHK(x)); }
  ------------------
  |  | 1284|  5.18M|#define HASHASH(x)      ((x)->sxpinfo.gp & HASHASH_MASK)
  |  |  ------------------
  |  |  |  |  940|  5.18M|#define HASHASH_MASK 1
  |  |  ------------------
  ------------------
HASHVALUE:
 4804|  5.17M|int (HASHVALUE)(SEXP x) { return HASHVALUE(CHK(x)); }
  ------------------
  |  | 1285|  5.17M|#define HASHVALUE(x)    ((int) TRUELENGTH(x))
  |  |  ------------------
  |  |  |  |  404|  5.17M|#define TRUELENGTH(x) XTRUELENGTH(x)
  |  |  ------------------
  ------------------
SET_HASHASH:
 4807|  14.1k|void (SET_HASHASH)(SEXP x, int v) { SET_HASHASH(CHK(x), v); }
  ------------------
  |  | 1286|  14.1k|#define SET_HASHASH(x,v) ((v) ? (((x)->sxpinfo.gp) |= HASHASH_MASK) : \
  |  |  ------------------
  |  |  |  |  940|  14.1k|#define HASHASH_MASK 1
  |  |  ------------------
  |  |  |  Branch (1286:27): [True: 14.1k, False: 0]
  |  |  ------------------
  |  | 1287|  14.1k|			  (((x)->sxpinfo.gp) &= (~HASHASH_MASK)))
  |  |  ------------------
  |  |  |  |  940|      0|#define HASHASH_MASK 1
  |  |  ------------------
  ------------------
SET_HASHVALUE:
 4809|  14.1k|void (SET_HASHVALUE)(SEXP x, int v) { SET_HASHVALUE(CHK(x), v); }
  ------------------
  |  | 1288|  14.1k|#define SET_HASHVALUE(x,v) SET_TRUELENGTH(x, ((int) (v)))
  |  |  ------------------
  |  |  |  |  395|  14.1k|#define SET_TRUELENGTH(x,v) do {				\
  |  |  |  |  396|  14.1k|	SEXP sl__x__ = (x);					\
  |  |  |  |  397|  14.1k|	R_xlen_t sl__v__ = (v);					\
  |  |  |  |  398|  14.1k|	if (ALTREP(x)) error("can't set ALTREP truelength");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  242|  14.1k|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (242:25): [True: 0, False: 14.1k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	if (ALTREP(x)) error("can't set ALTREP truelength");	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |  399|  14.1k|	SET_STDVEC_TRUELENGTH(sl__x__, sl__v__);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  394|  14.1k|#define SET_STDVEC_TRUELENGTH(x, v) (STDVEC_TRUELENGTH(x)=(v))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  393|  14.1k|#define STDVEC_TRUELENGTH(x) (((VECSEXP) (x))->vecsxp.truelength)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  400|  14.1k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (400:14): [Folded, False: 14.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
SET_CXTAIL:
 4813|  35.7k|SEXP (SET_CXTAIL)(SEXP x, SEXP v) {
 4814|       |#ifdef USE_TYPE_CHECKING
 4815|       |    if(TYPEOF(v) != CHARSXP && TYPEOF(v) != NILSXP)
 4816|       |	error("value of 'SET_CXTAIL' must be a char or NULL, not a '%s'",
 4817|       |	      R_typeToChar(v));
 4818|       |#endif
 4819|       |    /*CHECK_OLD_TO_NEW(x, v); *//* not needed since not properly traced */
 4820|  35.7k|    ATTRIB(x) = v;
  ------------------
  |  |  230|  35.7k|#define ATTRIB(x)	((x)->attrib)
  ------------------
 4821|  35.7k|    return x;
 4822|  35.7k|}
Rf_isNull:
 4825|  17.8M|Rboolean Rf_isNull(SEXP s) { return isNull(CHK(s)); }
  ------------------
  |  |  860|  17.8M|#define isNull(s)	(TYPEOF(s) == NILSXP)
  |  |  ------------------
  |  |  |  |  233|  17.8M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               #define isNull(s)	(TYPEOF(s) == NILSXP)
  |  |  ------------------
  |  |  |  |  111|  17.8M|#define NILSXP	     0	  /* nil = NULL */
  |  |  ------------------
  ------------------
Rf_isSymbol:
 4826|  30.6M|Rboolean Rf_isSymbol(SEXP s) { return isSymbol(CHK(s)); }
  ------------------
  |  |  862|  30.6M|#define isSymbol(s)	(TYPEOF(s) == SYMSXP)
  |  |  ------------------
  |  |  |  |  233|  30.6M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               #define isSymbol(s)	(TYPEOF(s) == SYMSXP)
  |  |  ------------------
  |  |  |  |  112|  30.6M|#define SYMSXP	     1	  /* symbols */
  |  |  ------------------
  ------------------
Rf_isLogical:
 4827|  6.10k|Rboolean Rf_isLogical(SEXP s) { return isLogical(CHK(s)); }
  ------------------
  |  |  864|  6.10k|#define isLogical(s)	(TYPEOF(s) == LGLSXP)
  |  |  ------------------
  |  |  |  |  233|  6.10k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               #define isLogical(s)	(TYPEOF(s) == LGLSXP)
  |  |  ------------------
  |  |  |  |  121|  6.10k|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  ------------------
Rf_isReal:
 4828|      6|Rboolean Rf_isReal(SEXP s) { return isReal(CHK(s)); }
  ------------------
  |  |  866|      6|#define isReal(s)	(TYPEOF(s) == REALSXP)
  |  |  ------------------
  |  |  |  |  233|      6|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               #define isReal(s)	(TYPEOF(s) == REALSXP)
  |  |  ------------------
  |  |  |  |  124|      6|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  ------------------
Rf_isComplex:
 4829|     40|Rboolean Rf_isComplex(SEXP s) { return isComplex(CHK(s)); }
  ------------------
  |  |  868|     40|#define isComplex(s)	(TYPEOF(s) == CPLXSXP)
  |  |  ------------------
  |  |  |  |  233|     40|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               #define isComplex(s)	(TYPEOF(s) == CPLXSXP)
  |  |  ------------------
  |  |  |  |  125|     40|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  ------------------
Rf_isExpression:
 4830|   770k|Rboolean Rf_isExpression(SEXP s) { return isExpression(CHK(s)); }
  ------------------
  |  |  870|   770k|#define isExpression(s) (TYPEOF(s) == EXPRSXP)
  |  |  ------------------
  |  |  |  |  233|   770k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               #define isExpression(s) (TYPEOF(s) == EXPRSXP)
  |  |  ------------------
  |  |  |  |  132|   770k|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  ------------------
  ------------------
Rf_isEnvironment:
 4831|  14.8M|Rboolean Rf_isEnvironment(SEXP s) { return isEnvironment(CHK(s)); }
  ------------------
  |  |  872|  14.8M|#define isEnvironment(s) (TYPEOF(s) == ENVSXP)
  |  |  ------------------
  |  |  |  |  233|  14.8M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               #define isEnvironment(s) (TYPEOF(s) == ENVSXP)
  |  |  ------------------
  |  |  |  |  115|  14.8M|#define ENVSXP	     4	  /* environments */
  |  |  ------------------
  ------------------
Rf_isString:
 4832|  5.47M|Rboolean Rf_isString(SEXP s) { return isString(CHK(s)); }
  ------------------
  |  |  874|  5.47M|#define isString(s)	(TYPEOF(s) == STRSXP)
  |  |  ------------------
  |  |  |  |  233|  5.47M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               #define isString(s)	(TYPEOF(s) == STRSXP)
  |  |  ------------------
  |  |  |  |  126|  5.47M|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  ------------------
Rf_isObject:
 4833|  15.1M|Rboolean Rf_isObject(SEXP s) { return isObject(CHK(s)); }
  ------------------
  |  |  876|  15.1M|#define isObject(s)	(OBJECT(s) != 0)
  |  |  ------------------
  |  |  |  |  231|  15.1M|#define OBJECT(x)	((x)->sxpinfo.obj)
  |  |  ------------------
  ------------------
IS_ACTIVE_BINDING:
 4837|  47.6M|(IS_ACTIVE_BINDING)(SEXP b) {return (Rboolean) IS_ACTIVE_BINDING(CHK(b));}
  ------------------
  |  | 1311|  47.6M|#define IS_ACTIVE_BINDING(b) ((b)->sxpinfo.gp & ACTIVE_BINDING_MASK)
  |  |  ------------------
  |  |  |  | 1308|  47.6M|#define ACTIVE_BINDING_MASK (1<<15)
  |  |  ------------------
  ------------------
BINDING_IS_LOCKED:
 4839|  12.0M|(BINDING_IS_LOCKED)(SEXP b) {return (Rboolean) BINDING_IS_LOCKED(CHK(b));}
  ------------------
  |  | 1312|  12.0M|#define BINDING_IS_LOCKED(b) ((b)->sxpinfo.gp & BINDING_LOCK_MASK)
  |  |  ------------------
  |  |  |  | 1309|  12.0M|#define BINDING_LOCK_MASK (1<<14)
  |  |  ------------------
  ------------------
SET_ACTIVE_BINDING_BIT:
 4841|      4|(SET_ACTIVE_BINDING_BIT)(SEXP b) {SET_ACTIVE_BINDING_BIT(CHK(b));}
  ------------------
  |  | 1313|      4|#define SET_ACTIVE_BINDING_BIT(b) ((b)->sxpinfo.gp |= ACTIVE_BINDING_MASK)
  |  |  ------------------
  |  |  |  | 1308|      4|#define ACTIVE_BINDING_MASK (1<<15)
  |  |  ------------------
  ------------------
LOCK_BINDING:
 4842|  13.2k|attribute_hidden void (LOCK_BINDING)(SEXP b) {LOCK_BINDING(CHK(b));}
  ------------------
  |  | 1314|  13.2k|#define LOCK_BINDING(b) do {						\
  |  | 1315|  13.2k|	SEXP lb__b__ = b;						\
  |  | 1316|  13.2k|	if (! IS_ACTIVE_BINDING(lb__b__)) {				\
  |  |  ------------------
  |  |  |  | 1311|  13.2k|#define IS_ACTIVE_BINDING(b) ((b)->sxpinfo.gp & ACTIVE_BINDING_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  | 1308|  13.2k|#define ACTIVE_BINDING_MASK (1<<15)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1316:6): [True: 13.2k, False: 4]
  |  |  ------------------
  |  | 1317|  13.2k|	    if (TYPEOF(lb__b__) == SYMSXP)				\
  |  |  ------------------
  |  |  |  |  233|  13.2k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |               	    if (TYPEOF(lb__b__) == SYMSXP)				\
  |  |  ------------------
  |  |  |  |  112|  13.2k|#define SYMSXP	     1	  /* symbols */
  |  |  ------------------
  |  |  |  Branch (1317:10): [True: 2.83k, False: 10.3k]
  |  |  ------------------
  |  | 1318|  13.2k|		MARK_NOT_MUTABLE(SYMVALUE(lb__b__));			\
  |  |  ------------------
  |  |  |  |  283|  2.83k|# define MARK_NOT_MUTABLE(x) SET_REFCNT(x, REFCNTMAX)
  |  |  |  |  ------------------
  |  |  |  |  |  |  256|  2.83k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  2.83k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1319|  13.2k|	    else							\
  |  | 1320|  13.2k|		MARK_NOT_MUTABLE(CAR(lb__b__));				\
  |  |  ------------------
  |  |  |  |  283|  10.3k|# define MARK_NOT_MUTABLE(x) SET_REFCNT(x, REFCNTMAX)
  |  |  |  |  ------------------
  |  |  |  |  |  |  256|  10.3k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  248|  10.3k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1321|  13.2k|	}								\
  |  | 1322|  13.2k|	((lb__b__))->sxpinfo.gp |= BINDING_LOCK_MASK;			\
  |  |  ------------------
  |  |  |  | 1309|  13.2k|#define BINDING_LOCK_MASK (1<<14)
  |  |  ------------------
  |  | 1323|  13.2k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (1323:14): [Folded, False: 13.2k]
  |  |  ------------------
  ------------------
UNLOCK_BINDING:
 4843|      6|attribute_hidden void (UNLOCK_BINDING)(SEXP b) {UNLOCK_BINDING(CHK(b));}
  ------------------
  |  | 1324|      6|#define UNLOCK_BINDING(b) ((b)->sxpinfo.gp &= (~BINDING_LOCK_MASK))
  |  |  ------------------
  |  |  |  | 1309|      6|#define BINDING_LOCK_MASK (1<<14)
  |  |  ------------------
  ------------------
SET_BASE_SYM_CACHED:
 4846|      4|void (SET_BASE_SYM_CACHED)(SEXP b) { SET_BASE_SYM_CACHED(CHK(b)); }
  ------------------
  |  | 1327|      4|#define SET_BASE_SYM_CACHED(b) ((b)->sxpinfo.gp |= BASE_SYM_CACHED_MASK)
  |  |  ------------------
  |  |  |  | 1326|      4|#define BASE_SYM_CACHED_MASK (1<<13)
  |  |  ------------------
  ------------------
BASE_SYM_CACHED:
 4850|      8|Rboolean (BASE_SYM_CACHED)(SEXP b) { return (Rboolean) BASE_SYM_CACHED(CHK(b)); }
  ------------------
  |  | 1329|      8|#define BASE_SYM_CACHED(b) ((b)->sxpinfo.gp & BASE_SYM_CACHED_MASK)
  |  |  ------------------
  |  |  |  | 1326|      8|#define BASE_SYM_CACHED_MASK (1<<13)
  |  |  ------------------
  ------------------
SET_SPECIAL_SYMBOL:
 4853|     92|void (SET_SPECIAL_SYMBOL)(SEXP b) { SET_SPECIAL_SYMBOL(CHK(b)); }
  ------------------
  |  | 1332|     92|#define SET_SPECIAL_SYMBOL(b) ((b)->sxpinfo.gp |= SPECIAL_SYMBOL_MASK)
  |  |  ------------------
  |  |  |  | 1331|     92|#define SPECIAL_SYMBOL_MASK (1<<12)
  |  |  ------------------
  ------------------
IS_SPECIAL_SYMBOL:
 4857|  24.9M|Rboolean (IS_SPECIAL_SYMBOL)(SEXP b) { return (Rboolean) IS_SPECIAL_SYMBOL(CHK(b)); }
  ------------------
  |  | 1334|  24.9M|#define IS_SPECIAL_SYMBOL(b) ((b)->sxpinfo.gp & SPECIAL_SYMBOL_MASK)
  |  |  ------------------
  |  |  |  | 1331|  24.9M|#define SPECIAL_SYMBOL_MASK (1<<12)
  |  |  ------------------
  ------------------
SET_NO_SPECIAL_SYMBOLS:
 4859|  3.91M|void (SET_NO_SPECIAL_SYMBOLS)(SEXP b) { SET_NO_SPECIAL_SYMBOLS(CHK(b)); }
  ------------------
  |  | 1335|  3.91M|#define SET_NO_SPECIAL_SYMBOLS(b) ((b)->sxpinfo.gp |= SPECIAL_SYMBOL_MASK)
  |  |  ------------------
  |  |  |  | 1331|  3.91M|#define SPECIAL_SYMBOL_MASK (1<<12)
  |  |  ------------------
  ------------------
UNSET_NO_SPECIAL_SYMBOLS:
 4861|    145|void (UNSET_NO_SPECIAL_SYMBOLS)(SEXP b) { UNSET_NO_SPECIAL_SYMBOLS(CHK(b)); }
  ------------------
  |  | 1336|    145|#define UNSET_NO_SPECIAL_SYMBOLS(b) ((b)->sxpinfo.gp &= (~SPECIAL_SYMBOL_MASK))
  |  |  ------------------
  |  |  |  | 1331|    145|#define SPECIAL_SYMBOL_MASK (1<<12)
  |  |  ------------------
  ------------------
NO_SPECIAL_SYMBOLS:
 4863|  1.56M|Rboolean (NO_SPECIAL_SYMBOLS)(SEXP b) { return (Rboolean) NO_SPECIAL_SYMBOLS(CHK(b)); }
  ------------------
  |  | 1337|  1.56M|#define NO_SPECIAL_SYMBOLS(b) ((b)->sxpinfo.gp & SPECIAL_SYMBOL_MASK)
  |  |  ------------------
  |  |  |  | 1331|  1.56M|#define SPECIAL_SYMBOL_MASK (1<<12)
  |  |  ------------------
  ------------------
IS_BYTES:
 4872|  3.62M|attribute_hidden int (IS_BYTES)(SEXP x) { return IS_BYTES(CHK(x)); }
  ------------------
  |  |  944|  3.62M|# define IS_BYTES(x) ((x)->sxpinfo.gp & BYTES_MASK)
  |  |  ------------------
  |  |  |  |  933|  3.62M|#define BYTES_MASK (1<<1)
  |  |  ------------------
  ------------------
IS_LATIN1:
 4873|  2.33M|attribute_hidden int (IS_LATIN1)(SEXP x) { return IS_LATIN1(CHK(x)); }
  ------------------
  |  |  946|  2.33M|# define IS_LATIN1(x) ((x)->sxpinfo.gp & LATIN1_MASK)
  |  |  ------------------
  |  |  |  |  934|  2.33M|#define LATIN1_MASK (1<<2)
  |  |  ------------------
  ------------------
IS_ASCII:
 4875|  4.59M|int  (IS_ASCII)(SEXP x) { return IS_ASCII(CHK(x)); }
  ------------------
  |  |  948|  4.59M|# define IS_ASCII(x) ((x)->sxpinfo.gp & ASCII_MASK)
  |  |  ------------------
  |  |  |  |  939|  4.59M|#define ASCII_MASK (1<<6)
  |  |  ------------------
  ------------------
IS_UTF8:
 4876|  2.34M|int  (IS_UTF8)(SEXP x) { return IS_UTF8(CHK(x)); }
  ------------------
  |  |  950|  2.34M|# define IS_UTF8(x) ((x)->sxpinfo.gp & UTF8_MASK)
  |  |  ------------------
  |  |  |  |  935|  2.34M|#define UTF8_MASK (1<<3)
  |  |  ------------------
  ------------------
SET_ASCII:
 4880|  35.0k|attribute_hidden void (SET_ASCII)(SEXP x) { SET_ASCII(CHK(x)); }
  ------------------
  |  |  949|  35.0k|# define SET_ASCII(x) (((x)->sxpinfo.gp) |= ASCII_MASK)
  |  |  ------------------
  |  |  |  |  939|  35.0k|#define ASCII_MASK (1<<6)
  |  |  ------------------
  ------------------
ENC_KNOWN:
 4881|  1.60M|/*attribute_hidden*/ int  (ENC_KNOWN)(SEXP x) { return ENC_KNOWN(CHK(x)); }
  ------------------
  |  |  952|  1.60M|# define ENC_KNOWN(x) ((x)->sxpinfo.gp & (LATIN1_MASK | UTF8_MASK))
  |  |  ------------------
  |  |  |  |  934|  1.60M|#define LATIN1_MASK (1<<2)
  |  |  ------------------
  |  |               # define ENC_KNOWN(x) ((x)->sxpinfo.gp & (LATIN1_MASK | UTF8_MASK))
  |  |  ------------------
  |  |  |  |  935|  1.60M|#define UTF8_MASK (1<<3)
  |  |  ------------------
  ------------------
SET_CACHED:
 4882|  35.7k|attribute_hidden void (SET_CACHED)(SEXP x) { SET_CACHED(CHK(x)); }
  ------------------
  |  |  953|  35.7k|# define SET_CACHED(x) (((x)->sxpinfo.gp) |= CACHED_MASK)
  |  |  ------------------
  |  |  |  |  938|  35.7k|#define CACHED_MASK (1<<5)
  |  |  ------------------
  ------------------
IS_CACHED:
 4883|  42.3k|/*attribute_hidden*/ int  (IS_CACHED)(SEXP x) { return IS_CACHED(CHK(x)); }
  ------------------
  |  |  954|  42.3k|# define IS_CACHED(x) (((x)->sxpinfo.gp) & CACHED_MASK)
  |  |  ------------------
  |  |  |  |  938|  42.3k|#define CACHED_MASK (1<<5)
  |  |  ------------------
  ------------------
R_AllocStringBuffer:
 4996|  76.4k|{
 4997|  76.4k|    size_t blen1, bsize = buf->defaultSize;
 4998|       |
 4999|       |    /* for backwards compatibility, this used to free the buffer */
 5000|  76.4k|    if(blen == (size_t)-1)
  ------------------
  |  Branch (5000:8): [True: 0, False: 76.4k]
  ------------------
 5001|      0|	error("R_AllocStringBuffer( (size_t)-1 ) is no longer allowed");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 5002|       |
 5003|  76.4k|    if(blen * sizeof(char) < buf->bufsize) return buf->data;
  ------------------
  |  Branch (5003:8): [True: 74.4k, False: 1.99k]
  ------------------
 5004|  1.99k|    blen1 = blen = (blen + 1) * sizeof(char);
 5005|  1.99k|    blen = (blen / bsize) * bsize;
 5006|  1.99k|    if(blen < blen1) blen += bsize;
  ------------------
  |  Branch (5006:8): [True: 1.99k, False: 0]
  ------------------
 5007|       |
 5008|       |    /* Result may be accessed as `wchar_t *` and other types; malloc /
 5009|       |      realloc guarantee correct memory alignment for all object types */
 5010|  1.99k|    if(buf->data == NULL) {
  ------------------
  |  Branch (5010:8): [True: 1.99k, False: 0]
  ------------------
 5011|  1.99k|	buf->data = (char *) malloc(blen);
 5012|  1.99k|	if(buf->data)
  ------------------
  |  Branch (5012:5): [True: 1.99k, False: 0]
  ------------------
 5013|  1.99k|	    buf->data[0] = '\0';
 5014|  1.99k|    } else
 5015|      0|	buf->data = (char *) realloc(buf->data, blen);
 5016|  1.99k|    buf->bufsize = blen;
 5017|  1.99k|    if(!buf->data) {
  ------------------
  |  Branch (5017:8): [True: 0, False: 1.99k]
  ------------------
 5018|      0|	buf->bufsize = 0;
 5019|       |	/* don't translate internal error message */
 5020|      0|	error("could not allocate memory (%u %s) in C function 'R_AllocStringBuffer'",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 5021|      0|	      (unsigned int) blen/1024/1024, "Mb");
 5022|      0|    }
 5023|  1.99k|    return buf->data;
 5024|  76.4k|}
R_FreeStringBuffer:
 5027|  1.98k|{
 5028|  1.98k|    if (buf->data != NULL) {
  ------------------
  |  Branch (5028:9): [True: 1.98k, False: 0]
  ------------------
 5029|  1.98k|	free(buf->data);
 5030|  1.98k|	buf->bufsize = 0;
 5031|       |	buf->data = NULL;
 5032|  1.98k|    }
 5033|  1.98k|}
R_FreeStringBufferL:
 5036|   774k|{
 5037|   774k|    if (buf->bufsize > buf->defaultSize) {
  ------------------
  |  Branch (5037:9): [True: 0, False: 774k]
  ------------------
 5038|      0|	free(buf->data);
 5039|      0|	buf->bufsize = 0;
 5040|       |	buf->data = NULL;
 5041|      0|    }
 5042|   774k|}
Rf_Seql:
 5049|  6.57M|{
 5050|       |    /* The only case where pointer comparisons do not suffice is where
 5051|       |      we have two strings in different encodings (which must be
 5052|       |      non-ASCII strings). Note that one of the strings could be marked
 5053|       |      as unknown. */
 5054|  6.57M|    if (a == b) return 1;
  ------------------
  |  Branch (5054:9): [True: 773k, False: 5.80M]
  ------------------
 5055|       |    /* Leave this to compiler to optimize */
 5056|  5.80M|    if (IS_CACHED(a) && IS_CACHED(b) && ENC_KNOWN(a) == ENC_KNOWN(b))
  ------------------
  |  |  954|  11.6M|# define IS_CACHED(x) (((x)->sxpinfo.gp) & CACHED_MASK)
  |  |  ------------------
  |  |  |  |  938|  5.80M|#define CACHED_MASK (1<<5)
  |  |  ------------------
  |  |  |  Branch (954:23): [True: 5.80M, False: 0]
  |  |  ------------------
  ------------------
                  if (IS_CACHED(a) && IS_CACHED(b) && ENC_KNOWN(a) == ENC_KNOWN(b))
  ------------------
  |  |  954|  11.6M|# define IS_CACHED(x) (((x)->sxpinfo.gp) & CACHED_MASK)
  |  |  ------------------
  |  |  |  |  938|  5.80M|#define CACHED_MASK (1<<5)
  |  |  ------------------
  |  |  |  Branch (954:23): [True: 5.80M, False: 0]
  |  |  ------------------
  ------------------
                  if (IS_CACHED(a) && IS_CACHED(b) && ENC_KNOWN(a) == ENC_KNOWN(b))
  ------------------
  |  |  952|  5.80M|# define ENC_KNOWN(x) ((x)->sxpinfo.gp & (LATIN1_MASK | UTF8_MASK))
  |  |  ------------------
  |  |  |  |  934|  5.80M|#define LATIN1_MASK (1<<2)
  |  |  ------------------
  |  |               # define ENC_KNOWN(x) ((x)->sxpinfo.gp & (LATIN1_MASK | UTF8_MASK))
  |  |  ------------------
  |  |  |  |  935|  5.80M|#define UTF8_MASK (1<<3)
  |  |  ------------------
  ------------------
                  if (IS_CACHED(a) && IS_CACHED(b) && ENC_KNOWN(a) == ENC_KNOWN(b))
  ------------------
  |  |  952|  5.80M|# define ENC_KNOWN(x) ((x)->sxpinfo.gp & (LATIN1_MASK | UTF8_MASK))
  |  |  ------------------
  |  |  |  |  934|  5.80M|#define LATIN1_MASK (1<<2)
  |  |  ------------------
  |  |               # define ENC_KNOWN(x) ((x)->sxpinfo.gp & (LATIN1_MASK | UTF8_MASK))
  |  |  ------------------
  |  |  |  |  935|  5.80M|#define UTF8_MASK (1<<3)
  |  |  ------------------
  ------------------
  |  Branch (5056:41): [True: 5.80M, False: 0]
  ------------------
 5057|  5.80M|	return 0;
 5058|      0|    else if (IS_BYTES(a) || IS_BYTES(b)) {
  ------------------
  |  |  944|      0|# define IS_BYTES(x) ((x)->sxpinfo.gp & BYTES_MASK)
  |  |  ------------------
  |  |  |  |  933|      0|#define BYTES_MASK (1<<1)
  |  |  ------------------
  |  |  |  Branch (944:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  else if (IS_BYTES(a) || IS_BYTES(b)) {
  ------------------
  |  |  944|      0|# define IS_BYTES(x) ((x)->sxpinfo.gp & BYTES_MASK)
  |  |  ------------------
  |  |  |  |  933|      0|#define BYTES_MASK (1<<1)
  |  |  ------------------
  |  |  |  Branch (944:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 5059|      0|	if (IS_BYTES(a) && IS_BYTES(b))
  ------------------
  |  |  944|      0|# define IS_BYTES(x) ((x)->sxpinfo.gp & BYTES_MASK)
  |  |  ------------------
  |  |  |  |  933|      0|#define BYTES_MASK (1<<1)
  |  |  ------------------
  |  |  |  Branch (944:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	if (IS_BYTES(a) && IS_BYTES(b))
  ------------------
  |  |  944|      0|# define IS_BYTES(x) ((x)->sxpinfo.gp & BYTES_MASK)
  |  |  ------------------
  |  |  |  |  933|      0|#define BYTES_MASK (1<<1)
  |  |  ------------------
  |  |  |  Branch (944:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 5060|       |	    /* only get here if at least one is not cached */
 5061|      0|	    return !strcmp(CHAR(a), CHAR(b));
  ------------------
  |  |  422|      0|#define CHAR(x)		((const char *) STDVEC_DATAPTR(x))
  |  |  ------------------
  |  |  |  |  420|      0|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  ------------------
  ------------------
              	    return !strcmp(CHAR(a), CHAR(b));
  ------------------
  |  |  422|      0|#define CHAR(x)		((const char *) STDVEC_DATAPTR(x))
  |  |  ------------------
  |  |  |  |  420|      0|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  ------------------
  ------------------
 5062|      0|	else
 5063|      0|	    return 0;
 5064|      0|    }
 5065|      0|    else {
 5066|      0|	SEXP vmax = R_VStack;
 5067|      0|	int result = !strcmp(translateCharUTF8(a), translateCharUTF8(b));
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
              	int result = !strcmp(translateCharUTF8(a), translateCharUTF8(b));
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
 5068|      0|	R_VStack = vmax; /* discard any memory used by translateCharUTF8 */
 5069|      0|	return result;
 5070|      0|    }
 5071|  5.80M|}
memory.c:NewWeakRef:
 1426|  2.43k|{
 1427|  2.43k|    SEXP w;
 1428|       |
 1429|  2.43k|    switch (TYPEOF(key)) {
  ------------------
  |  |  233|  2.43k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
 1430|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1430:5): [True: 0, False: 2.43k]
  ------------------
 1431|      0|    case ENVSXP:
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (1431:5): [True: 0, False: 2.43k]
  ------------------
 1432|  2.43k|    case EXTPTRSXP:
  ------------------
  |  |  134|  2.43k|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (1432:5): [True: 2.43k, False: 0]
  ------------------
 1433|  2.43k|    case BCODESXP:
  ------------------
  |  |  133|  2.43k|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (1433:5): [True: 0, False: 2.43k]
  ------------------
 1434|  2.43k|	break;
 1435|      0|    default: error(_("can only weakly reference/finalize reference objects"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  default: error(_("can only weakly reference/finalize reference objects"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (1435:5): [True: 0, False: 2.43k]
  ------------------
 1436|  2.43k|    }
 1437|       |
 1438|  2.43k|    PROTECT(key);
  ------------------
  |  |  357|  2.43k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1439|       |    /* fin before val: R_MakeWeakRefC() passes a fresh finalizer object,
 1440|       |       and duplicate(val) below can collect it */
 1441|  2.43k|    PROTECT(fin);
  ------------------
  |  |  357|  2.43k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1442|  2.43k|    PROTECT(val = MAYBE_REFERENCED(val) ? duplicate(val) : val);
  ------------------
  |  |  357|  4.86k|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  |  Branch (357:31): [True: 2.43k, False: 0]
  |  |  ------------------
  ------------------
 1443|  2.43k|    w = allocVector(VECSXP, WEAKREF_SIZE);
  ------------------
  |  |  875|  2.43k|#define allocVector		Rf_allocVector
  ------------------
                  w = allocVector(VECSXP, WEAKREF_SIZE);
  ------------------
  |  |  131|  2.43k|#define VECSXP	    19	  /* generic vectors */
  ------------------
                  w = allocVector(VECSXP, WEAKREF_SIZE);
  ------------------
  |  | 1413|  2.43k|#define WEAKREF_SIZE 4
  ------------------
 1444|  2.43k|    SET_TYPEOF(w, WEAKREFSXP);
  ------------------
  |  |  238|  2.43k|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 1445|  2.43k|    if (key != R_NilValue) {
  ------------------
  |  Branch (1445:9): [True: 2.43k, False: 0]
  ------------------
 1446|       |	/* If the key is R_NilValue we don't register the weak reference.
 1447|       |	   This is used in loading saved images. */
 1448|  2.43k|	SET_WEAKREF_KEY(w, key);
  ------------------
  |  | 1415|  2.43k|#define SET_WEAKREF_KEY(w, k) SET_VECTOR_ELT(w, 0, k)
  ------------------
 1449|  2.43k|	SET_WEAKREF_VALUE(w, val);
  ------------------
  |  | 1417|  2.43k|#define SET_WEAKREF_VALUE(w, v) SET_VECTOR_ELT(w, 1, v)
  ------------------
 1450|  2.43k|	SET_WEAKREF_FINALIZER(w, fin);
  ------------------
  |  | 1419|  2.43k|#define SET_WEAKREF_FINALIZER(w, f) SET_VECTOR_ELT(w, 2, f)
  ------------------
 1451|  2.43k|	SET_WEAKREF_NEXT(w, R_weak_refs);
  ------------------
  |  | 1421|  2.43k|#define SET_WEAKREF_NEXT(w, n) SET_VECTOR_ELT(w, 3, n)
  ------------------
 1452|  2.43k|	CLEAR_READY_TO_FINALIZE(w);
  ------------------
  |  | 1404|  2.43k|#define CLEAR_READY_TO_FINALIZE(s) ((s)->sxpinfo.gp &= ~READY_TO_FINALIZE_MASK)
  |  |  ------------------
  |  |  |  | 1401|  2.43k|#define READY_TO_FINALIZE_MASK 1
  |  |  ------------------
  ------------------
 1453|  2.43k|	if (onexit)
  ------------------
  |  Branch (1453:6): [True: 0, False: 2.43k]
  ------------------
 1454|      0|	    SET_FINALIZE_ON_EXIT(w);
  ------------------
  |  | 1409|      0|#define SET_FINALIZE_ON_EXIT(s) ((s)->sxpinfo.gp |= FINALIZE_ON_EXIT_MASK)
  |  |  ------------------
  |  |  |  | 1407|      0|#define FINALIZE_ON_EXIT_MASK 2
  |  |  ------------------
  ------------------
 1455|  2.43k|	else
 1456|  2.43k|	    CLEAR_FINALIZE_ON_EXIT(w);
  ------------------
  |  | 1410|  2.43k|#define CLEAR_FINALIZE_ON_EXIT(s) ((s)->sxpinfo.gp &= ~FINALIZE_ON_EXIT_MASK)
  |  |  ------------------
  |  |  |  | 1407|  2.43k|#define FINALIZE_ON_EXIT_MASK 2
  |  |  ------------------
  ------------------
 1457|  2.43k|	R_weak_refs = w;
 1458|  2.43k|    }
 1459|  2.43k|    UNPROTECT(3);
  ------------------
  |  |  358|  2.43k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1460|  2.43k|    return w;
 1461|  2.43k|}
memory.c:MakeCFinalizer:
 1511|    866|{
 1512|    866|    SEXP s = allocVector(RAWSXP, sizeof(R_CFinalizer_t));
  ------------------
  |  |  875|    866|#define allocVector		Rf_allocVector
  ------------------
                  SEXP s = allocVector(RAWSXP, sizeof(R_CFinalizer_t));
  ------------------
  |  |  136|    866|#define RAWSXP      24    /* raw bytes */
  ------------------
 1513|    866|    *((R_CFinalizer_t *) RAW(s)) = cfun;
  ------------------
  |  |  425|    866|#define RAW(x)		((Rbyte *) DATAPTR(x))
  ------------------
 1514|    866|    return s;
 1515|       |    /*return R_MakeExternalPtr((void *) cfun, R_NilValue, R_NilValue);*/
 1516|    866|}
memory.c:isCFinalizer:
 1505|     65|{
 1506|     65|    return TYPEOF(fun) == RAWSXP;
  ------------------
  |  |  233|     65|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  return TYPEOF(fun) == RAWSXP;
  ------------------
  |  |  136|     65|#define RAWSXP      24    /* raw bytes */
  ------------------
 1507|       |    /*return TYPEOF(fun) == EXTPTRSXP;*/
 1508|     65|}
memory.c:GetCFinalizer:
 1519|     63|{
 1520|     63|    return *((R_CFinalizer_t *) RAW(fun));
  ------------------
  |  |  425|     63|#define RAW(x)		((Rbyte *) DATAPTR(x))
  ------------------
 1521|       |    /*return (R_CFinalizer_t) R_ExternalPtrAddr(fun);*/
 1522|     63|}
memory.c:RunFinalizers:
 1574|      3|{
 1575|      3|    R_CHECK_THREAD;
  ------------------
  |  |  566|      3|# define R_CHECK_THREAD R_check_thread(__func__)
  ------------------
 1576|       |    /* Prevent this function from running again when already in
 1577|       |       progress. Jumps can only occur inside the top level context
 1578|       |       where they will be caught, so the flag is guaranteed to be
 1579|       |       reset at the end. */
 1580|      3|    static Rboolean running = FALSE;
 1581|      3|    if (running) return FALSE;
  ------------------
  |  Branch (1581:9): [True: 0, False: 3]
  ------------------
 1582|      3|    running = TRUE;
 1583|       |
 1584|      3|    volatile SEXP s, last;
 1585|      3|    volatile Rboolean finalizer_run = FALSE;
 1586|       |
 1587|  1.45k|    for (s = R_weak_refs, last = R_NilValue; s != R_NilValue;) {
  ------------------
  |  Branch (1587:46): [True: 1.45k, False: 3]
  ------------------
 1588|  1.45k|	SEXP next = WEAKREF_NEXT(s);
  ------------------
  |  | 1420|  1.45k|#define WEAKREF_NEXT(w) VECTOR_ELT_0(w, 3)
  |  |  ------------------
  |  |  |  |   80|  1.45k|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  |  |  ------------------
  |  |  |  |  |  |  420|  1.45k|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1589|  1.45k|	if (IS_READY_TO_FINALIZE(s)) {
  ------------------
  |  | 1405|  1.45k|#define IS_READY_TO_FINALIZE(s) ((s)->sxpinfo.gp & READY_TO_FINALIZE_MASK)
  |  |  ------------------
  |  |  |  | 1401|  1.45k|#define READY_TO_FINALIZE_MASK 1
  |  |  ------------------
  |  |  |  Branch (1405:33): [True: 65, False: 1.39k]
  |  |  ------------------
  ------------------
 1590|       |	    /**** use R_ToplevelExec here? */
 1591|     65|	    RCNTXT thiscontext;
 1592|     65|	    RCNTXT * volatile saveToplevelContext;
 1593|     65|	    volatile int savestack;
 1594|     65|	    volatile SEXP topExp, oldHStack, oldRStack, oldRVal;
 1595|     65|	    volatile Rboolean oldvis;
 1596|     65|	    PROTECT(oldHStack = R_HandlerStack);
  ------------------
  |  |  357|     65|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1597|     65|	    PROTECT(oldRStack = R_RestartStack);
  ------------------
  |  |  357|     65|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1598|     65|	    PROTECT(oldRVal = R_ReturnedValue);
  ------------------
  |  |  357|     65|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1599|     65|	    oldvis = R_Visible;
 1600|     65|	    R_HandlerStack = R_NilValue;
 1601|     65|	    R_RestartStack = R_NilValue;
 1602|       |
 1603|     65|	    finalizer_run = TRUE;
 1604|       |
 1605|       |	    /* A top level context is established for the finalizer to
 1606|       |	       insure that any errors that might occur do not spill
 1607|       |	       into the call that triggered the collection. */
 1608|     65|	    begincontext(&thiscontext, CTXT_TOPLEVEL, R_NilValue, R_GlobalEnv,
  ------------------
  |  | 1864|     65|# define begincontext		Rf_begincontext
  ------------------
 1609|     65|			 R_BaseEnv, R_NilValue, R_NilValue);
 1610|     65|	    saveToplevelContext = R_ToplevelContext;
 1611|     65|	    PROTECT(topExp = R_CurrentExpr);
  ------------------
  |  |  357|     65|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1612|     65|	    savestack = R_PPStackTop;
 1613|       |	    /* The value of 'next' is protected to make it safe
 1614|       |	       for this routine to be called recursively from a
 1615|       |	       gc triggered by a finalizer. */
 1616|     65|	    PROTECT(next);
  ------------------
  |  |  357|     65|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1617|     65|	    if (! SETJMP(thiscontext.cjmpbuf)) {
  ------------------
  |  | 1162|     65|# define SETJMP(x) sigsetjmp(x,0)
  ------------------
  |  Branch (1617:10): [True: 65, False: 0]
  ------------------
 1618|     65|		R_GlobalContext = R_ToplevelContext = &thiscontext;
 1619|       |
 1620|       |		/* The entry in the weak reference list is removed
 1621|       |		   before running the finalizer.  This insures that a
 1622|       |		   finalizer is run only once, even if running it
 1623|       |		   raises an error. */
 1624|     65|		if (last == R_NilValue)
  ------------------
  |  Branch (1624:7): [True: 29, False: 36]
  ------------------
 1625|     29|		    R_weak_refs = next;
 1626|     36|		else
 1627|     36|		    SET_WEAKREF_NEXT(last, next);
  ------------------
  |  | 1421|     36|#define SET_WEAKREF_NEXT(w, n) SET_VECTOR_ELT(w, 3, n)
  ------------------
 1628|     65|		R_RunWeakRefFinalizer(s);
 1629|     65|	    }
 1630|     65|	    endcontext(&thiscontext);
  ------------------
  |  | 1895|     65|# define endcontext		Rf_endcontext
  ------------------
 1631|     65|	    UNPROTECT(1); /* next */
  ------------------
  |  |  358|     65|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1632|     65|	    R_ToplevelContext = saveToplevelContext;
 1633|     65|	    R_PPStackTop = savestack;
 1634|     65|	    R_CurrentExpr = topExp;
 1635|     65|	    R_HandlerStack = oldHStack;
 1636|     65|	    R_RestartStack = oldRStack;
 1637|     65|	    R_ReturnedValue = oldRVal;
 1638|     65|	    R_Visible = oldvis;
 1639|     65|	    UNPROTECT(4);/* topExp, oldRVal, oldRStack, oldHStack */
  ------------------
  |  |  358|     65|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1640|     65|	}
 1641|  1.39k|	else last = s;
 1642|  1.45k|	s = next;
 1643|  1.45k|    }
 1644|      3|    running = FALSE;
 1645|      3|    R_finalizers_pending = FALSE;
 1646|      3|    return finalizer_run;
 1647|      3|}
memory.c:init_gctorture:
 2113|      2|{
 2114|      2|    char *arg = getenv("R_GCTORTURE");
 2115|      2|    if (arg != NULL) {
  ------------------
  |  Branch (2115:9): [True: 0, False: 2]
  ------------------
 2116|      0|	int gap = atoi(arg);
 2117|      0|	if (gap > 0) {
  ------------------
  |  Branch (2117:6): [True: 0, False: 0]
  ------------------
 2118|      0|	    gc_force_wait = gc_force_gap = gap;
 2119|      0|	    arg = getenv("R_GCTORTURE_WAIT");
 2120|      0|	    if (arg != NULL) {
  ------------------
  |  Branch (2120:10): [True: 0, False: 0]
  ------------------
 2121|      0|		int wait = atoi(arg);
 2122|      0|		if (wait > 0)
  ------------------
  |  Branch (2122:7): [True: 0, False: 0]
  ------------------
 2123|      0|		    gc_force_wait = wait;
 2124|      0|	    }
 2125|      0|#ifdef PROTECTCHECK
 2126|      0|	    arg = getenv("R_GCTORTURE_INHIBIT_RELEASE");
 2127|      0|	    if (arg != NULL) {
  ------------------
  |  Branch (2127:10): [True: 0, False: 0]
  ------------------
 2128|      0|		int inhibit = atoi(arg);
 2129|      0|		if (inhibit > 0) gc_inhibit_release = TRUE;
  ------------------
  |  Branch (2129:7): [True: 0, False: 0]
  ------------------
 2130|      0|		else gc_inhibit_release = FALSE;
 2131|      0|	    }
 2132|      0|#endif
 2133|      0|	}
 2134|      0|    }
 2135|      2|}
memory.c:init_gc_grow_settings:
  357|      2|{
  358|      2|    char *arg;
  359|       |
  360|      2|    arg = getenv("R_GC_MEM_GROW");
  361|      2|    if (arg != NULL) {
  ------------------
  |  Branch (361:9): [True: 0, False: 2]
  ------------------
  362|      0|	int which = (int) atof(arg);
  363|      0|	switch (which) {
  ------------------
  |  Branch (363:10): [True: 0, False: 0]
  ------------------
  364|      0|	case 0: /* very conservative -- the SMALL_MEMORY settings */
  ------------------
  |  Branch (364:2): [True: 0, False: 0]
  ------------------
  365|      0|	    R_NGrowIncrFrac = 0.0;
  366|      0|	    R_VGrowIncrFrac = 0.0;
  367|      0|	    break;
  368|      0|	case 1: /* default */
  ------------------
  |  Branch (368:2): [True: 0, False: 0]
  ------------------
  369|      0|	    break;
  370|      0|	case 2: /* somewhat aggressive */
  ------------------
  |  Branch (370:2): [True: 0, False: 0]
  ------------------
  371|      0|	    R_NGrowIncrFrac = 0.3;
  372|      0|	    R_VGrowIncrFrac = 0.3;
  373|      0|	    break;
  374|      0|	case 3: /* more aggressive */
  ------------------
  |  Branch (374:2): [True: 0, False: 0]
  ------------------
  375|      0|	    R_NGrowIncrFrac = 0.4;
  376|      0|	    R_VGrowIncrFrac = 0.4;
  377|      0|	    R_NGrowFrac = 0.5;
  378|      0|	    R_VGrowFrac = 0.5;
  379|      0|	    break;
  380|      0|	}
  381|      0|    }
  382|      2|    arg = getenv("R_GC_GROWFRAC");
  383|      2|    if (arg != NULL) {
  ------------------
  |  Branch (383:9): [True: 0, False: 2]
  ------------------
  384|      0|	double frac = atof(arg);
  385|      0|	if (0.35 <= frac && frac <= 0.75) {
  ------------------
  |  Branch (385:6): [True: 0, False: 0]
  |  Branch (385:22): [True: 0, False: 0]
  ------------------
  386|      0|	    R_NGrowFrac = frac;
  387|      0|	    R_VGrowFrac = frac;
  388|      0|	}
  389|      0|    }
  390|      2|    arg = getenv("R_GC_GROWINCRFRAC");
  391|      2|    if (arg != NULL) {
  ------------------
  |  Branch (391:9): [True: 0, False: 2]
  ------------------
  392|      0|	double frac = atof(arg);
  393|      0|	if (0.05 <= frac && frac <= 0.80) {
  ------------------
  |  Branch (393:6): [True: 0, False: 0]
  |  Branch (393:22): [True: 0, False: 0]
  ------------------
  394|      0|	    R_NGrowIncrFrac = frac;
  395|      0|	    R_VGrowIncrFrac = frac;
  396|      0|	}
  397|      0|    }
  398|      2|    arg = getenv("R_GC_NGROWINCRFRAC");
  399|      2|    if (arg != NULL) {
  ------------------
  |  Branch (399:9): [True: 0, False: 2]
  ------------------
  400|      0|	double frac = atof(arg);
  401|      0|	if (0.05 <= frac && frac <= 0.80)
  ------------------
  |  Branch (401:6): [True: 0, False: 0]
  |  Branch (401:22): [True: 0, False: 0]
  ------------------
  402|      0|	    R_NGrowIncrFrac = frac;
  403|      0|    }
  404|      2|    arg = getenv("R_GC_VGROWINCRFRAC");
  405|      2|    if (arg != NULL) {
  ------------------
  |  Branch (405:9): [True: 0, False: 2]
  ------------------
  406|      0|	double frac = atof(arg);
  407|      0|	if (0.05 <= frac && frac <= 0.80)
  ------------------
  |  Branch (407:6): [True: 0, False: 0]
  |  Branch (407:22): [True: 0, False: 0]
  ------------------
  408|      0|	    R_VGrowIncrFrac = frac;
  409|      0|    }
  410|      2|}
memory.c:GetNewPage:
  994|   184k|{
  995|   184k|    SEXP s, base;
  996|   184k|    char *data;
  997|   184k|    PAGE_HEADER *page;
  998|   184k|    int node_size, page_count, i;  // FIXME: longer type?
  999|       |
 1000|   184k|    node_size = NODE_SIZE(node_class);
  ------------------
  |  |  592|   184k|  ((c) == 0 ? sizeof(SEXPREC) : \
  |  |  ------------------
  |  |  |  Branch (592:4): [True: 161k, False: 22.5k]
  |  |  ------------------
  |  |  593|   184k|   sizeof(SEXPREC_ALIGN) + NodeClassSize[c] * sizeof(VECREC))
  ------------------
 1001|   184k|    page_count = (R_PAGE_SIZE - sizeof(PAGE_HEADER)) / node_size;
  ------------------
  |  |  588|   184k|  (((BASE_PAGE_SIZE - sizeof(PAGE_HEADER)) / sizeof(SEXPREC)) \
  |  |  ------------------
  |  |  |  |  583|   184k|# define BASE_PAGE_SIZE 8000
  |  |  ------------------
  |  |  589|   184k|   * sizeof(SEXPREC) \
  |  |  590|   184k|   + sizeof(PAGE_HEADER))
  ------------------
 1002|       |
 1003|   184k|    page = malloc(R_PAGE_SIZE);
  ------------------
  |  |  588|   184k|  (((BASE_PAGE_SIZE - sizeof(PAGE_HEADER)) / sizeof(SEXPREC)) \
  |  |  ------------------
  |  |  |  |  583|   184k|# define BASE_PAGE_SIZE 8000
  |  |  ------------------
  |  |  589|   184k|   * sizeof(SEXPREC) \
  |  |  590|   184k|   + sizeof(PAGE_HEADER))
  ------------------
 1004|   184k|    if (page == NULL) {
  ------------------
  |  Branch (1004:9): [True: 0, False: 184k]
  ------------------
 1005|      0|	R_gc_no_finalizers(0);
 1006|      0|	page = malloc(R_PAGE_SIZE);
  ------------------
  |  |  588|      0|  (((BASE_PAGE_SIZE - sizeof(PAGE_HEADER)) / sizeof(SEXPREC)) \
  |  |  ------------------
  |  |  |  |  583|      0|# define BASE_PAGE_SIZE 8000
  |  |  ------------------
  |  |  589|      0|   * sizeof(SEXPREC) \
  |  |  590|      0|   + sizeof(PAGE_HEADER))
  ------------------
 1007|      0|	if (page == NULL)
  ------------------
  |  Branch (1007:6): [True: 0, False: 0]
  ------------------
 1008|      0|	    mem_err_malloc((R_size_t) R_PAGE_SIZE);
  ------------------
  |  |  588|      0|  (((BASE_PAGE_SIZE - sizeof(PAGE_HEADER)) / sizeof(SEXPREC)) \
  |  |  ------------------
  |  |  |  |  583|      0|# define BASE_PAGE_SIZE 8000
  |  |  ------------------
  |  |  589|      0|   * sizeof(SEXPREC) \
  |  |  590|      0|   + sizeof(PAGE_HEADER))
  ------------------
 1009|      0|    }
 1010|       |#ifdef R_MEMORY_PROFILING
 1011|       |    R_ReportNewPage();
 1012|       |#endif
 1013|   184k|    page->next = R_GenHeap[node_class].pages;
 1014|   184k|    R_GenHeap[node_class].pages = page;
 1015|   184k|    R_GenHeap[node_class].PageCount++;
 1016|       |
 1017|   184k|    data = PAGE_DATA(page);
  ------------------
  |  |  595|   184k|#define PAGE_DATA(p) ((void *) (p + 1))
  ------------------
 1018|   184k|    base = R_GenHeap[node_class].New;
 1019|  25.4M|    for (i = 0; i < page_count; i++, data += node_size) {
  ------------------
  |  Branch (1019:17): [True: 25.2M, False: 184k]
  ------------------
 1020|  25.2M|	s = (SEXP) data;
 1021|  25.2M|	R_GenHeap[node_class].AllocCount++;
 1022|  25.2M|	SNAP_NODE(s, base);
  ------------------
  |  |  657|  25.2M|#define SNAP_NODE(s,t) do { \
  |  |  658|  25.2M|  SEXP sn__n__ = (s); \
  |  |  659|  25.2M|  SEXP next = (t); \
  |  |  660|  25.2M|  SEXP prev = PREV_NODE(next); \
  |  |  ------------------
  |  |  |  |  640|  25.2M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  |  |  661|  25.2M|  SET_NEXT_NODE(sn__n__, next); \
  |  |  ------------------
  |  |  |  |  641|  25.2M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  25.2M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  662|  25.2M|  SET_PREV_NODE(next, sn__n__); \
  |  |  ------------------
  |  |  |  |  642|  25.2M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  25.2M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  663|  25.2M|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  ------------------
  |  |  |  |  641|  25.2M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  25.2M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  664|  25.2M|  SET_PREV_NODE(sn__n__, prev); \
  |  |  ------------------
  |  |  |  |  642|  25.2M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  25.2M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  665|  25.2M|} while (0)
  |  |  ------------------
  |  |  |  Branch (665:10): [Folded, False: 25.2M]
  |  |  ------------------
  ------------------
 1023|       |#if  VALGRIND_LEVEL > 1
 1024|       |	if (NodeClassSize[node_class] > 0)
 1025|       |	    VALGRIND_MAKE_MEM_NOACCESS(STDVEC_DATAPTR(s), NodeClassSize[node_class]*sizeof(VECREC));
 1026|       |#endif
 1027|  25.2M|	s->sxpinfo = UnmarkedNodeTemplate.sxpinfo;
 1028|  25.2M|	INIT_REFCNT(s);
  ------------------
  |  |  982|  25.2M|#define INIT_REFCNT(x) do {			\
  |  |  983|  25.2M|	SEXP __x__ = (x);			\
  |  |  984|  25.2M|	SET_REFCNT(__x__, 0);			\
  |  |  ------------------
  |  |  |  |  256|  25.2M|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  25.2M|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  985|  25.2M|	SET_TRACKREFS(__x__, TRUE);		\
  |  |  ------------------
  |  |  |  |  260|  25.2M|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  |  |  986|  25.2M|    } while (0)
  |  |  ------------------
  |  |  |  Branch (986:14): [Folded, False: 25.2M]
  |  |  ------------------
  ------------------
 1029|  25.2M|	SET_NODE_CLASS(s, node_class);
  ------------------
  |  |  546|  25.2M|#define SET_NODE_CLASS(s,v) (((s)->sxpinfo.gccls) = (v))
  ------------------
 1030|  25.2M|#ifdef PROTECTCHECK
 1031|  25.2M|	SET_TYPEOF(s, NEWSXP);
  ------------------
  |  |  238|  25.2M|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 1032|  25.2M|#endif
 1033|  25.2M|	base = s;
 1034|  25.2M|	R_GenHeap[node_class].Free = s;
 1035|  25.2M|    }
 1036|   184k|}
memory.c:CHK:
  158|  5.82G|{
  159|       |    /* **** NULL check because of R_CurrentExpr */
  160|  5.82G|    if (x != NULL && TYPEOF(x) == FREESXP) {
  ------------------
  |  |  233|  5.82G|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if (x != NULL && TYPEOF(x) == FREESXP) {
  ------------------
  |  |  142|  5.82G|#define FREESXP     31    /* node released by GC */
  ------------------
  |  Branch (160:9): [True: 5.82G, False: 51]
  |  Branch (160:22): [True: 0, False: 5.82G]
  ------------------
  161|       |	/* An R error here would be caught by the fuzz harness's top-level
  162|       |	   context and look like any other rejected input.  This is memory
  163|       |	   corruption, so stop where it is found. */
  164|      0|	REprintf("unprotected object (%p) encountered (was %s)\n",
  165|      0|		 (void *)x, sexptype2char(OLDTYPE(x)));
  ------------------
  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  ------------------
              		 (void *)x, sexptype2char(OLDTYPE(x)));
  ------------------
  |  |  154|      0|#define OLDTYPE(s) LEVELS(s)
  |  |  ------------------
  |  |  |  |  236|      0|#define LEVELS(x)	((x)->sxpinfo.gp)
  |  |  ------------------
  ------------------
  166|      0|	abort();
  167|      0|    }
  168|  5.82G|    return x;
  169|  5.82G|}
memory.c:allocSExpNonCons:
 2506|  8.68k|{
 2507|  8.68k|    SEXP s;
 2508|  8.68k|    if (FORCE_GC || NO_FREE_NODES()) {
  ------------------
  |  |  241|  17.3k|#define FORCE_GC (gc_pending || (gc_force_wait > 0 ? (--gc_force_wait > 0 ? 0 : (gc_force_wait = gc_force_gap, 1)) : 0))
  |  |  ------------------
  |  |  |  Branch (241:19): [True: 0, False: 8.68k]
  |  |  |  Branch (241:33): [True: 0, False: 8.68k]
  |  |  |  Branch (241:34): [True: 0, False: 8.68k]
  |  |  |  Branch (241:55): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  if (FORCE_GC || NO_FREE_NODES()) {
  ------------------
  |  |  857|  8.68k|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 0, False: 8.68k]
  |  |  ------------------
  ------------------
 2509|      0|	R_gc_internal(0);
 2510|      0|	if (NO_FREE_NODES())
  ------------------
  |  |  857|      0|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2511|      0|	    mem_err_cons();
 2512|      0|    }
 2513|  8.68k|    GET_FREE_NODE(s);
  ------------------
  |  |  858|  8.68k|#define GET_FREE_NODE(s) CLASS_GET_FREE_NODE(0,s)
  |  |  ------------------
  |  |  |  |  846|  8.68k|#define CLASS_GET_FREE_NODE(c,s) do { \
  |  |  |  |  847|  8.68k|  SEXP __n__ = R_GenHeap[c].Free; \
  |  |  |  |  848|  8.68k|  if (__n__ == R_GenHeap[c].New) { \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (848:7): [True: 39, False: 8.64k]
  |  |  |  |  ------------------
  |  |  |  |  849|     39|    GetNewPage(c); \
  |  |  |  |  850|     39|    __n__ = R_GenHeap[c].Free; \
  |  |  |  |  851|     39|  } \
  |  |  |  |  852|  8.68k|  R_GenHeap[c].Free = NEXT_NODE(__n__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  8.68k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  |  |  853|  8.68k|  R_NodesInUse++; \
  |  |  |  |  854|  8.68k|  (s) = __n__; \
  |  |  |  |  855|  8.68k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (855:10): [Folded, False: 8.68k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2514|  8.68k|    s->sxpinfo = UnmarkedNodeTemplate.sxpinfo;
 2515|  8.68k|    INIT_REFCNT(s);
  ------------------
  |  |  982|  8.68k|#define INIT_REFCNT(x) do {			\
  |  |  983|  8.68k|	SEXP __x__ = (x);			\
  |  |  984|  8.68k|	SET_REFCNT(__x__, 0);			\
  |  |  ------------------
  |  |  |  |  256|  8.68k|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|  8.68k|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  985|  8.68k|	SET_TRACKREFS(__x__, TRUE);		\
  |  |  ------------------
  |  |  |  |  260|  8.68k|#  define SET_TRACKREFS(x,v) ((x)->sxpinfo.spare = ! (v))
  |  |  ------------------
  |  |  986|  8.68k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (986:14): [Folded, False: 8.68k]
  |  |  ------------------
  ------------------
 2516|  8.68k|    SET_TYPEOF(s, t);
  ------------------
  |  |  238|  8.68k|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 2517|  8.68k|    TAG(s) = R_NilValue;
  ------------------
  |  |  440|  8.68k|#define TAG(e)		((e)->u.listsxp.tagval)
  ------------------
 2518|  8.68k|    ATTRIB(s) = R_NilValue;
  ------------------
  |  |  230|  8.68k|#define ATTRIB(x)	((x)->attrib)
  ------------------
 2519|  8.68k|    return s;
 2520|  8.68k|}
memory.c:allocFormalsList:
 3073|     11|{
 3074|     11|    SEXP res = R_NilValue;
 3075|     11|    SEXP n;
 3076|     11|    int i;
 3077|     11|    va_list(syms);
 3078|     11|    va_start(syms, nargs);
 3079|       |
 3080|     42|    for(i = 0; i < nargs; i++) {
  ------------------
  |  Branch (3080:16): [True: 31, False: 11]
  ------------------
 3081|     31|	res = CONS(R_NilValue, res);
  ------------------
  |  |  309|     31|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 3082|     31|    }
 3083|     11|    R_PreserveObject(res);
 3084|       |
 3085|     11|    n = res;
 3086|     42|    for(i = 0; i < nargs; i++) {
  ------------------
  |  Branch (3086:16): [True: 31, False: 11]
  ------------------
 3087|     31|	SET_TAG(n, (SEXP) va_arg(syms, SEXP));
 3088|     31|	MARK_NOT_MUTABLE(n);
  ------------------
  |  |  283|     31|# define MARK_NOT_MUTABLE(x) SET_REFCNT(x, REFCNTMAX)
  |  |  ------------------
  |  |  |  |  256|     31|# define SET_REFCNT(x,v) (REFCNT(x) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  248|     31|# define REFCNT(x) ((x)->sxpinfo.named)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3089|     31|	n = CDR(n);
  ------------------
  |  |  445|     31|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
 3090|     31|    }
 3091|     11|    va_end(syms);
 3092|       |
 3093|     11|    return res;
 3094|     11|}
memory.c:R_gc_internal:
 3232|    318|{
 3233|    318|    R_CHECK_THREAD;
  ------------------
  |  |  566|    318|# define R_CHECK_THREAD R_check_thread(__func__)
  ------------------
 3234|    318|    if (!R_GCEnabled || R_in_gc) {
  ------------------
  |  Branch (3234:9): [True: 0, False: 318]
  |  Branch (3234:25): [True: 0, False: 318]
  ------------------
 3235|      0|      if (R_in_gc)
  ------------------
  |  Branch (3235:11): [True: 0, False: 0]
  ------------------
 3236|      0|        gc_error("*** recursive gc invocation\n");
 3237|      0|      if (NO_FREE_NODES())
  ------------------
  |  |  857|      0|#define NO_FREE_NODES() (R_NodesInUse >= R_NSize)
  |  |  ------------------
  |  |  |  Branch (857:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3238|      0|	R_NSize = R_NodesInUse + 1;
 3239|       |
 3240|      0|      if (num_old_gens_to_collect < NUM_OLD_GENERATIONS &&
  ------------------
  |  |  551|      0|#define NUM_OLD_GENERATIONS 2
  ------------------
  |  Branch (3240:11): [True: 0, False: 0]
  ------------------
 3241|      0|	  VHEAP_FREE() < size_needed + R_MinFreeFrac * R_VSize)
  ------------------
  |  |  596|      0|#define VHEAP_FREE() (R_VSize - R_LargeVallocSize - R_SmallVallocSize)
  ------------------
  |  Branch (3241:4): [True: 0, False: 0]
  ------------------
 3242|      0|	num_old_gens_to_collect++;
 3243|       |
 3244|      0|      if (size_needed > VHEAP_FREE()) {
  ------------------
  |  |  596|      0|#define VHEAP_FREE() (R_VSize - R_LargeVallocSize - R_SmallVallocSize)
  ------------------
  |  Branch (3244:11): [True: 0, False: 0]
  ------------------
 3245|      0|	  R_size_t expand = size_needed - VHEAP_FREE();
  ------------------
  |  |  596|      0|#define VHEAP_FREE() (R_VSize - R_LargeVallocSize - R_SmallVallocSize)
  ------------------
 3246|      0|	  if (R_VSize + expand > R_MaxVSize)
  ------------------
  |  Branch (3246:8): [True: 0, False: 0]
  ------------------
 3247|      0|	      mem_err_heap(size_needed);
 3248|      0|	  R_VSize += expand;
 3249|      0|      }
 3250|       |
 3251|      0|      gc_pending = TRUE;
 3252|      0|      return;
 3253|      0|    }
 3254|    318|    gc_pending = FALSE;
 3255|       |
 3256|    318|    R_size_t onsize = R_NSize /* can change during collection */;
 3257|    318|    double ncells, vcells, vfrac, nfrac;
 3258|    318|    SEXPTYPE first_bad_sexp_type = 0;
 3259|    318|#ifdef PROTECTCHECK
 3260|    318|    SEXPTYPE first_bad_sexp_type_old_type = 0;
 3261|    318|#endif
 3262|    318|    SEXP first_bad_sexp_type_sexp = NULL;
 3263|    318|    int first_bad_sexp_type_line = 0;
 3264|    318|    int gens_collected = 0;
 3265|       |
 3266|       |#ifdef IMMEDIATE_FINALIZERS
 3267|       |    Rboolean first = TRUE;
 3268|       | again:
 3269|       |#endif
 3270|       |
 3271|    318|    gc_count++;
 3272|       |
 3273|    318|    R_N_maxused = R_MAX(R_N_maxused, R_NodesInUse);
  ------------------
  |  | 3204|    318|#define R_MAX(a,b) (a) < (b) ? (b) : (a)
  |  |  ------------------
  |  |  |  Branch (3204:20): [True: 3, False: 315]
  |  |  ------------------
  ------------------
 3274|    318|    R_V_maxused = R_MAX(R_V_maxused, R_VSize - VHEAP_FREE());
  ------------------
  |  | 3204|    318|#define R_MAX(a,b) (a) < (b) ? (b) : (a)
  |  |  ------------------
  |  |  |  Branch (3204:20): [True: 2, False: 316]
  |  |  ------------------
  ------------------
 3275|       |
 3276|    318|    BEGIN_SUSPEND_INTERRUPTS {
  ------------------
  |  | 2543|    318|#define BEGIN_SUSPEND_INTERRUPTS do { \
  |  | 2544|    318|    Rboolean __oldsusp__ = R_interrupts_suspended; \
  |  | 2545|    318|    R_interrupts_suspended = TRUE;
  ------------------
 3277|    318|	R_in_gc = TRUE;
 3278|    318|	gc_start_timing();
 3279|    318|	gens_collected = RunGenCollect(size_needed);
 3280|    318|	gc_end_timing();
 3281|    318|	R_in_gc = FALSE;
 3282|    318|    } END_SUSPEND_INTERRUPTS;
  ------------------
  |  | 2546|    318|#define END_SUSPEND_INTERRUPTS R_interrupts_suspended = __oldsusp__; \
  |  | 2547|    318|    if (R_interrupts_pending && ! R_interrupts_suspended) \
  |  |  ------------------
  |  |  |  Branch (2547:9): [True: 0, False: 318]
  |  |  |  Branch (2547:33): [True: 0, False: 0]
  |  |  ------------------
  |  | 2548|    318|        onintr(); \
  |  |  ------------------
  |  |  |  | 1963|      0|# define onintr			Rf_onintr
  |  |  ------------------
  |  | 2549|    318|} while(0)
  |  |  ------------------
  |  |  |  Branch (2549:9): [Folded, False: 318]
  |  |  ------------------
  ------------------
 3283|       |
 3284|    318|    if (R_check_constants > 2 ||
  ------------------
  |  Branch (3284:9): [True: 0, False: 318]
  ------------------
 3285|    318|	    (R_check_constants > 1 && gens_collected == NUM_OLD_GENERATIONS))
  ------------------
  |  |  551|      0|#define NUM_OLD_GENERATIONS 2
  ------------------
  |  Branch (3285:7): [True: 0, False: 318]
  |  Branch (3285:32): [True: 0, False: 0]
  ------------------
 3286|      0|	R_checkConstants(TRUE);
 3287|       |
 3288|    318|    if (gc_reporting) {
  ------------------
  |  Branch (3288:9): [True: 0, False: 318]
  ------------------
 3289|      0|	REprintf("Garbage collection %d = %d", gc_count, gen_gc_counts[0]);
 3290|      0|	for (int i = 0; i < NUM_OLD_GENERATIONS; i++)
  ------------------
  |  |  551|      0|#define NUM_OLD_GENERATIONS 2
  ------------------
  |  Branch (3290:18): [True: 0, False: 0]
  ------------------
 3291|      0|	    REprintf("+%d", gen_gc_counts[i + 1]);
 3292|      0|	REprintf(" (level %d) ... ", gens_collected);
 3293|      0|	DEBUG_GC_SUMMARY(gens_collected == NUM_OLD_GENERATIONS);
 3294|      0|    }
 3295|       |
 3296|    318|    if (bad_sexp_type_seen != 0 && first_bad_sexp_type == 0) {
  ------------------
  |  Branch (3296:9): [True: 0, False: 318]
  |  Branch (3296:36): [True: 0, False: 0]
  ------------------
 3297|      0|	first_bad_sexp_type = bad_sexp_type_seen;
 3298|      0|#ifdef PROTECTCHECK
 3299|      0|	first_bad_sexp_type_old_type = bad_sexp_type_old_type;
 3300|      0|#endif
 3301|      0|	first_bad_sexp_type_sexp = bad_sexp_type_sexp;
 3302|      0|	first_bad_sexp_type_line = bad_sexp_type_line;
 3303|      0|    }
 3304|       |
 3305|    318|    if (gc_reporting) {
  ------------------
  |  Branch (3305:9): [True: 0, False: 318]
  ------------------
 3306|      0|	ncells = onsize - R_Collected;
 3307|      0|	nfrac = (100.0 * ncells) / R_NSize;
 3308|       |	/* We try to make this consistent with the results returned by gc */
 3309|      0|	ncells = 0.1*ceil(10*ncells * sizeof(SEXPREC)/Mega);
  ------------------
  |  | 1050|      0|#define Mega 1048576.    /* Misnomer !! 1 MiB (mebibyte) := 2^20 (= 1048576) Bytes */
  ------------------
 3310|      0|	REprintf("\n%.1f %s of cons cells used (%d%%)\n",
 3311|      0|		 ncells, "Mbytes", (int) (nfrac + 0.5));
 3312|      0|	vcells = R_VSize - VHEAP_FREE();
  ------------------
  |  |  596|      0|#define VHEAP_FREE() (R_VSize - R_LargeVallocSize - R_SmallVallocSize)
  ------------------
 3313|      0|	vfrac = (100.0 * vcells) / R_VSize;
 3314|      0|	vcells = 0.1*ceil(10*vcells * vsfac/Mega);
  ------------------
  |  | 1050|      0|#define Mega 1048576.    /* Misnomer !! 1 MiB (mebibyte) := 2^20 (= 1048576) Bytes */
  ------------------
 3315|      0|	REprintf("%.1f %s of vectors used (%d%%)\n",
 3316|      0|		 vcells, "Mbytes", (int) (vfrac + 0.5));
 3317|      0|    }
 3318|       |
 3319|       |#ifdef IMMEDIATE_FINALIZERS
 3320|       |    if (first) {
 3321|       |	first = FALSE;
 3322|       |	/* Run any eligible finalizers.  The return result of
 3323|       |	   RunFinalizers is TRUE if any finalizers are actually run.
 3324|       |	   There is a small chance that running finalizers here may
 3325|       |	   chew up enough memory to make another immediate collection
 3326|       |	   necessary.  If so, we jump back to the beginning and run
 3327|       |	   the collection, but on this second pass we do not run
 3328|       |	   finalizers. */
 3329|       |	if (RunFinalizers() &&
 3330|       |	    (NO_FREE_NODES() || size_needed > VHEAP_FREE()))
 3331|       |	    goto again;
 3332|       |    }
 3333|       |#endif
 3334|       |
 3335|    318|    if (first_bad_sexp_type != 0) {
  ------------------
  |  Branch (3335:9): [True: 0, False: 318]
  ------------------
 3336|      0|	char msg[256];
 3337|      0|#ifdef PROTECTCHECK
 3338|      0|	if (first_bad_sexp_type == FREESXP)
  ------------------
  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  ------------------
  |  Branch (3338:6): [True: 0, False: 0]
  ------------------
 3339|      0|	    snprintf(msg, 256,
 3340|      0|	          "GC encountered a node (%p) with type FREESXP (was %s)"
 3341|      0|		  " at memory.c:%d",
 3342|      0|		  (void *) first_bad_sexp_type_sexp,
 3343|      0|		  sexptype2char(first_bad_sexp_type_old_type),
  ------------------
  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  ------------------
 3344|      0|		  first_bad_sexp_type_line);
 3345|      0|	else
 3346|      0|	    snprintf(msg, 256,
 3347|      0|		     "GC encountered a node (%p) with an unknown SEXP type: %d"
 3348|      0|		     " at memory.c:%d",
 3349|      0|		     (void *) first_bad_sexp_type_sexp,
 3350|      0|		     first_bad_sexp_type,
 3351|      0|		     first_bad_sexp_type_line);
 3352|       |#else
 3353|       |	snprintf(msg, 256,
 3354|       |		 "GC encountered a node (%p) with an unknown SEXP type: %d"
 3355|       |		 " at memory.c:%d",
 3356|       |		 (void *)first_bad_sexp_type_sexp,
 3357|       |		 first_bad_sexp_type,
 3358|       |		 first_bad_sexp_type_line);
 3359|       |	gc_error(msg);
 3360|       |#endif
 3361|      0|    }
 3362|       |
 3363|       |    /* sanity check on logical scalar values */
 3364|    318|    if (R_TrueValue != NULL && LOGICAL(R_TrueValue)[0] != TRUE) {
  ------------------
  |  |  423|    318|#define LOGICAL(x)	((int *) DATAPTR(x))
  ------------------
  |  Branch (3364:9): [True: 318, False: 0]
  |  Branch (3364:32): [True: 0, False: 318]
  ------------------
 3365|      0|	LOGICAL(R_TrueValue)[0] = TRUE;
  ------------------
  |  |  423|      0|#define LOGICAL(x)	((int *) DATAPTR(x))
  ------------------
 3366|      0|	gc_error("internal TRUE value has been modified");
 3367|      0|    }
 3368|    318|    if (R_FalseValue != NULL && LOGICAL(R_FalseValue)[0] != FALSE) {
  ------------------
  |  |  423|    318|#define LOGICAL(x)	((int *) DATAPTR(x))
  ------------------
  |  Branch (3368:9): [True: 318, False: 0]
  |  Branch (3368:33): [True: 0, False: 318]
  ------------------
 3369|      0|	LOGICAL(R_FalseValue)[0] = FALSE;
  ------------------
  |  |  423|      0|#define LOGICAL(x)	((int *) DATAPTR(x))
  ------------------
 3370|      0|	gc_error("internal FALSE value has been modified");
 3371|      0|    }
 3372|    318|    if (R_LogicalNAValue != NULL &&
  ------------------
  |  Branch (3372:9): [True: 318, False: 0]
  ------------------
 3373|    318|	LOGICAL(R_LogicalNAValue)[0] != NA_LOGICAL) {
  ------------------
  |  |  423|    318|#define LOGICAL(x)	((int *) DATAPTR(x))
  ------------------
              	LOGICAL(R_LogicalNAValue)[0] != NA_LOGICAL) {
  ------------------
  |  |   55|    318|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (3373:2): [True: 0, False: 318]
  ------------------
 3374|      0|	LOGICAL(R_LogicalNAValue)[0] = NA_LOGICAL;
  ------------------
  |  |  423|      0|#define LOGICAL(x)	((int *) DATAPTR(x))
  ------------------
              	LOGICAL(R_LogicalNAValue)[0] = NA_LOGICAL;
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
 3375|      0|	gc_error("internal logical NA value has been modified");
 3376|      0|    }
 3377|    318|}
memory.c:gc_start_timing:
 3177|    318|{
 3178|    318|    if (gctime_enabled)
  ------------------
  |  Branch (3178:9): [True: 0, False: 318]
  ------------------
 3179|      0|	R_getProcTime(gcstarttimes);
 3180|    318|}
memory.c:RunGenCollect:
 1721|    318|{
 1722|    318|    int i, gen, gens_collected;
 1723|    318|    RCNTXT *ctxt;
 1724|    318|    SEXP s;
 1725|    318|    SEXP forwarded_nodes;
 1726|       |
 1727|    318|    bad_sexp_type_seen = 0;
 1728|       |
 1729|       |    /* determine number of generations to collect */
 1730|    339|    while (num_old_gens_to_collect < NUM_OLD_GENERATIONS) {
  ------------------
  |  |  551|    339|#define NUM_OLD_GENERATIONS 2
  ------------------
  |  Branch (1730:12): [True: 335, False: 4]
  ------------------
 1731|    335|	if (collect_counts[num_old_gens_to_collect]-- <= 0) {
  ------------------
  |  Branch (1731:6): [True: 21, False: 314]
  ------------------
 1732|     21|	    collect_counts[num_old_gens_to_collect] =
 1733|     21|		collect_counts_max[num_old_gens_to_collect];
 1734|     21|	    num_old_gens_to_collect++;
 1735|     21|	}
 1736|    314|	else break;
 1737|    335|    }
 1738|       |
 1739|    318|#ifdef PROTECTCHECK
 1740|    318|    num_old_gens_to_collect = NUM_OLD_GENERATIONS;
  ------------------
  |  |  551|    318|#define NUM_OLD_GENERATIONS 2
  ------------------
 1741|    318|#endif
 1742|       |
 1743|    318| again:
 1744|    318|    gens_collected = num_old_gens_to_collect;
 1745|       |
 1746|    318|#ifndef EXPEL_OLD_TO_NEW
 1747|       |    /* eliminate old-to-new references in generations to collect by
 1748|       |       transferring referenced nodes to referring generation */
 1749|    954|    for (gen = 0; gen < num_old_gens_to_collect; gen++) {
  ------------------
  |  Branch (1749:19): [True: 636, False: 318]
  ------------------
 1750|  5.72k|	for (i = 0; i < NUM_NODE_CLASSES; i++) {
  ------------------
  |  |  531|  5.72k|#define NUM_NODE_CLASSES 8
  ------------------
  |  Branch (1750:14): [True: 5.08k, False: 636]
  ------------------
 1751|  5.08k|	    s = NEXT_NODE(R_GenHeap[i].OldToNew[gen]);
  ------------------
  |  |  639|  5.08k|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1752|  7.13k|	    while (s != R_GenHeap[i].OldToNew[gen]) {
  ------------------
  |  Branch (1752:13): [True: 2.04k, False: 5.08k]
  ------------------
 1753|  2.04k|		SEXP next = NEXT_NODE(s);
  ------------------
  |  |  639|  2.04k|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1754|  2.04k|		DO_CHILDREN(s, AgeNodeAndChildren, gen);
  ------------------
  |  |  779|  2.04k|    DO_CHILDREN4(__n__,dc__action__,dc__action__,dc__extra__)
  |  |  ------------------
  |  |  |  |  710|  2.04k|#define DO_CHILDREN4(__n__,dc__action__,dc__str__action__,dc__extra__) do { \
  |  |  |  |  711|  2.04k|  if (HAS_GENUINE_ATTRIB(__n__)) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  696|  2.04k|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  2.04k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|  4.09k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  230|  2.04k|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (696:6): [True: 2.04k, False: 0]
  |  |  |  |  |  |  |  Branch (696:30): [True: 24, False: 2.02k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  697|  2.04k|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|     24|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  120|     48|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (697:7): [True: 24, False: 0]
  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  712|  2.04k|    dc__action__(ATTRIB(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  230|     24|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  ------------------
  |  |  |  |  713|  2.04k|  if (ALTREP(__n__)) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  242|  2.04k|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (242:25): [True: 0, False: 2.04k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  714|      0|	  dc__action__(TAG(__n__), dc__extra__);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  440|      0|#define TAG(e)		((e)->u.listsxp.tagval)
  |  |  |  |  ------------------
  |  |  |  |  715|      0|	  dc__action__(CAR(__n__), dc__extra__);	\
  |  |  |  |  716|      0|	  dc__action__(CDR(__n__), dc__extra__);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  445|      0|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  |  |  ------------------
  |  |  |  |  717|      0|      }							\
  |  |  |  |  718|  2.04k|  else \
  |  |  |  |  719|  2.04k|  switch (TYPEOF(__n__)) { \
  |  |  |  |  ------------------
  |  |  |  |  |  |  233|  2.04k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  ------------------
  |  |  |  |  720|      0|  case NILSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (720:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  721|      0|  case BUILTINSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (721:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  722|      0|  case SPECIALSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (722:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  723|      0|  case CHARSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (723:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  724|      0|  case LGLSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (724:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  725|      0|  case INTSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (725:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  726|      0|  case REALSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  727|      0|  case CPLXSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (727:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  728|      3|  case WEAKREFSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|      3|#define WEAKREFSXP  23    /* weak reference */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (728:3): [True: 3, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  729|      3|  case RAWSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  136|      3|#define RAWSXP      24    /* raw bytes */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (729:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  730|      3|  case OBJSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  137|      3|#define OBJSXP      25    /* object, non-vector  */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (730:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  731|      3|    break; \
  |  |  |  |  732|    220|  case STRSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|    220|#define STRSXP	    16	  /* string vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (732:3): [True: 220, False: 1.82k]
  |  |  |  |  ------------------
  |  |  |  |  733|    220|    { \
  |  |  |  |  734|    220|      R_xlen_t i; \
  |  |  |  |  735|    440|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  407|    440|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (735:19): [True: 220, False: 220]
  |  |  |  |  ------------------
  |  |  |  |  736|    220|	dc__str__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   80|    220|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  420|    220|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  737|    220|    } \
  |  |  |  |  738|    220|    break; \
  |  |  |  |  739|      3|  case EXPRSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (739:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  740|    356|  case VECSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  131|    356|#define VECSXP	    19	  /* generic vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (740:3): [True: 356, False: 1.69k]
  |  |  |  |  ------------------
  |  |  |  |  741|    356|    { \
  |  |  |  |  742|    356|      R_xlen_t i; \
  |  |  |  |  743|  14.6M|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  407|  14.6M|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (743:19): [True: 14.6M, False: 356]
  |  |  |  |  ------------------
  |  |  |  |  744|  14.6M|	dc__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   80|  14.6M|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  420|  14.6M|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  745|    356|    } \
  |  |  |  |  746|    356|    break; \
  |  |  |  |  747|    484|  case ENVSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  115|    484|#define ENVSXP	     4	  /* environments */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (747:3): [True: 484, False: 1.56k]
  |  |  |  |  ------------------
  |  |  |  |  748|    484|    dc__action__(FRAME(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  532|    484|#define FRAME(x)	((x)->u.envsxp.frame)
  |  |  |  |  ------------------
  |  |  |  |  749|    484|    dc__action__(ENCLOS(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  533|    484|#define ENCLOS(x)	((x)->u.envsxp.enclos)
  |  |  |  |  ------------------
  |  |  |  |  750|    484|    dc__action__(HASHTAB(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  534|    484|#define HASHTAB(x)	((x)->u.envsxp.hashtab)
  |  |  |  |  ------------------
  |  |  |  |  751|    484|    break; \
  |  |  |  |  752|    388|  case LISTSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  113|    388|#define LISTSXP	     2	  /* lists of dotted pairs */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (752:3): [True: 388, False: 1.65k]
  |  |  |  |  ------------------
  |  |  |  |  753|    762|  case PROMSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  116|    762|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (753:3): [True: 374, False: 1.67k]
  |  |  |  |  ------------------
  |  |  |  |  754|    762|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  440|    762|#define TAG(e)		((e)->u.listsxp.tagval)
  |  |  |  |  ------------------
  |  |  |  |  755|    762|    if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  ------------------
  |  |  |  |  |  |   37|  1.52k|# define BOXED_BINDING_CELLS 0
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (37:30): [Folded, False: 762]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                   if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  463|    762|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (755:32): [True: 762, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  756|    762|      dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  441|    762|#define CAR0(e)		((e)->u.listsxp.carval)
  |  |  |  |  ------------------
  |  |  |  |  757|    762|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  445|    762|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  |  |  ------------------
  |  |  |  |  758|    762|    break; \
  |  |  |  |  759|    388|  case CLOSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (759:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  760|      1|  case LANGSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      1|#define LANGSXP	     6	  /* language constructs (special lists) */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (760:3): [True: 1, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  761|      1|  case DOTSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  127|      1|#define DOTSXP	    17	  /* dot-dot-dot object */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (761:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  762|    221|  case SYMSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|    221|#define SYMSXP	     1	  /* symbols */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (762:3): [True: 220, False: 1.82k]
  |  |  |  |  ------------------
  |  |  |  |  763|    221|  case BCODESXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  133|    221|#define BCODESXP    21    /* byte code */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (763:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  764|    221|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  440|    221|#define TAG(e)		((e)->u.listsxp.tagval)
  |  |  |  |  ------------------
  |  |  |  |  765|    221|    dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  441|    221|#define CAR0(e)		((e)->u.listsxp.carval)
  |  |  |  |  ------------------
  |  |  |  |  766|    221|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  445|    221|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  |  |  ------------------
  |  |  |  |  767|    221|    break; \
  |  |  |  |  768|    221|  case EXTPTRSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  134|      0|#define EXTPTRSXP   22    /* external pointer */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (768:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  769|      0|    dc__action__(EXTPTR_PROT(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  442|      0|#define EXTPTR_PROT(x)	CDR(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  445|      0|#define CDR(e)		((e)->u.listsxp.cdrval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  770|      0|    dc__action__(EXTPTR_TAG(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  443|      0|#define EXTPTR_TAG(x)	TAG(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  440|      0|#define TAG(e)		((e)->u.listsxp.tagval)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  771|      0|    break; \
  |  |  |  |  772|    221|  FREE_FORWARD_CASE \
  |  |  |  |  ------------------
  |  |  |  |  |  |  705|      0|#define FREE_FORWARD_CASE case FREESXP: if (gc_inhibit_release) break;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (705:27): [True: 0, False: 2.04k]
  |  |  |  |  |  |  |  Branch (705:45): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  773|      0|  default: \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (773:3): [True: 0, False: 2.04k]
  |  |  |  |  ------------------
  |  |  |  |  774|      0|    register_bad_sexp_type(__n__, __LINE__);		\
  |  |  |  |  775|  2.04k|  } \
  |  |  |  |  776|  2.04k|} while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (776:9): [Folded, False: 2.04k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1755|  2.04k|		UNSNAP_NODE(s);
  ------------------
  |  |  648|  2.04k|#define UNSNAP_NODE(s) do { \
  |  |  649|  2.04k|  SEXP un__n__ = (s); \
  |  |  650|  2.04k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  ------------------
  |  |  |  |  639|  2.04k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  |  |  651|  2.04k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  ------------------
  |  |  |  |  640|  2.04k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  |  |  652|  2.04k|  SET_NEXT_NODE(prev, next); \
  |  |  ------------------
  |  |  |  |  641|  2.04k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  2.04k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  653|  2.04k|  SET_PREV_NODE(next, prev); \
  |  |  ------------------
  |  |  |  |  642|  2.04k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  2.04k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  654|  2.04k|} while(0)
  |  |  ------------------
  |  |  |  Branch (654:9): [Folded, False: 2.04k]
  |  |  ------------------
  ------------------
 1756|  2.04k|		if (NODE_GENERATION(s) != gen)
  ------------------
  |  |  559|  2.04k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  ------------------
  |  Branch (1756:7): [True: 0, False: 2.04k]
  ------------------
 1757|      0|		    gc_error("****snapping into wrong generation\n");
 1758|  2.04k|		SNAP_NODE(s, R_GenHeap[i].Old[gen]);
  ------------------
  |  |  657|  2.04k|#define SNAP_NODE(s,t) do { \
  |  |  658|  2.04k|  SEXP sn__n__ = (s); \
  |  |  659|  2.04k|  SEXP next = (t); \
  |  |  660|  2.04k|  SEXP prev = PREV_NODE(next); \
  |  |  ------------------
  |  |  |  |  640|  2.04k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  |  |  661|  2.04k|  SET_NEXT_NODE(sn__n__, next); \
  |  |  ------------------
  |  |  |  |  641|  2.04k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  2.04k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  662|  2.04k|  SET_PREV_NODE(next, sn__n__); \
  |  |  ------------------
  |  |  |  |  642|  2.04k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  2.04k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  663|  2.04k|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  ------------------
  |  |  |  |  641|  2.04k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  2.04k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  664|  2.04k|  SET_PREV_NODE(sn__n__, prev); \
  |  |  ------------------
  |  |  |  |  642|  2.04k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  2.04k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  665|  2.04k|} while (0)
  |  |  ------------------
  |  |  |  Branch (665:10): [Folded, False: 2.04k]
  |  |  ------------------
  ------------------
 1759|  2.04k|		s = next;
 1760|  2.04k|	    }
 1761|  5.08k|	}
 1762|    636|    }
 1763|    318|#endif
 1764|       |
 1765|    318|    DEBUG_CHECK_NODE_COUNTS("at start");
 1766|       |
 1767|       |    /* unmark all marked nodes in old generations to be collected and
 1768|       |       move to New space */
 1769|    954|    for (gen = 0; gen < num_old_gens_to_collect; gen++) {
  ------------------
  |  Branch (1769:19): [True: 636, False: 318]
  ------------------
 1770|  5.72k|	for (i = 0; i < NUM_NODE_CLASSES; i++) {
  ------------------
  |  |  531|  5.72k|#define NUM_NODE_CLASSES 8
  ------------------
  |  Branch (1770:14): [True: 5.08k, False: 636]
  ------------------
 1771|  5.08k|	    R_GenHeap[i].OldCount[gen] = 0;
 1772|  5.08k|	    s = NEXT_NODE(R_GenHeap[i].Old[gen]);
  ------------------
  |  |  639|  5.08k|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1773|   116M|	    while (s != R_GenHeap[i].Old[gen]) {
  ------------------
  |  Branch (1773:13): [True: 116M, False: 5.08k]
  ------------------
 1774|   116M|		SEXP next = NEXT_NODE(s);
  ------------------
  |  |  639|   116M|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1775|   116M|		if (gen < NUM_OLD_GENERATIONS - 1)
  ------------------
  |  |  551|   116M|#define NUM_OLD_GENERATIONS 2
  ------------------
  |  Branch (1775:7): [True: 400k, False: 116M]
  ------------------
 1776|   400k|		    SET_NODE_GENERATION(s, gen + 1);
  ------------------
  |  |  560|   400k|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  ------------------
 1777|   116M|		UNMARK_NODE(s);
  ------------------
  |  |  270|   116M|#define UNMARK_NODE(s) (MARK(s)=0)
  |  |  ------------------
  |  |  |  |  232|   116M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  ------------------
  ------------------
 1778|   116M|		s = next;
 1779|   116M|	    }
 1780|  5.08k|	    if (NEXT_NODE(R_GenHeap[i].Old[gen]) != R_GenHeap[i].Old[gen])
  ------------------
  |  |  639|  5.08k|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
  |  Branch (1780:10): [True: 3.54k, False: 1.54k]
  ------------------
 1781|  3.54k|		BULK_MOVE(R_GenHeap[i].Old[gen], R_GenHeap[i].New);
  ------------------
  |  |  668|  3.54k|#define BULK_MOVE(from_peg,to_peg) do { \
  |  |  669|  3.54k|  SEXP __from__ = (from_peg); \
  |  |  670|  3.54k|  SEXP __to__ = (to_peg); \
  |  |  671|  3.54k|  SEXP first_old = NEXT_NODE(__from__); \
  |  |  ------------------
  |  |  |  |  639|  3.54k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  |  |  672|  3.54k|  SEXP last_old = PREV_NODE(__from__); \
  |  |  ------------------
  |  |  |  |  640|  3.54k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  |  |  673|  3.54k|  SEXP first_new = NEXT_NODE(__to__); \
  |  |  ------------------
  |  |  |  |  639|  3.54k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  |  |  674|  3.54k|  SET_PREV_NODE(first_old, __to__); \
  |  |  ------------------
  |  |  |  |  642|  3.54k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  3.54k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  675|  3.54k|  SET_NEXT_NODE(__to__, first_old); \
  |  |  ------------------
  |  |  |  |  641|  3.54k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  3.54k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  676|  3.54k|  SET_PREV_NODE(first_new, last_old); \
  |  |  ------------------
  |  |  |  |  642|  3.54k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  3.54k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  677|  3.54k|  SET_NEXT_NODE(last_old, first_new); \
  |  |  ------------------
  |  |  |  |  641|  3.54k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  3.54k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  678|  3.54k|  SET_NEXT_NODE(__from__, __from__); \
  |  |  ------------------
  |  |  |  |  641|  3.54k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  3.54k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  679|  3.54k|  SET_PREV_NODE(__from__, __from__); \
  |  |  ------------------
  |  |  |  |  642|  3.54k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  3.54k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  680|  3.54k|} while (0);
  |  |  ------------------
  |  |  |  Branch (680:10): [Folded, False: 3.54k]
  |  |  ------------------
  ------------------
 1782|  5.08k|	}
 1783|    636|    }
 1784|       |
 1785|    318|    forwarded_nodes = NULL;
 1786|       |
 1787|    318|#ifndef EXPEL_OLD_TO_NEW
 1788|       |    /* scan nodes in uncollected old generations with old-to-new pointers */
 1789|    318|    for (gen = num_old_gens_to_collect; gen < NUM_OLD_GENERATIONS; gen++)
  ------------------
  |  |  551|    318|#define NUM_OLD_GENERATIONS 2
  ------------------
  |  Branch (1789:41): [True: 0, False: 318]
  ------------------
 1790|      0|	for (i = 0; i < NUM_NODE_CLASSES; i++)
  ------------------
  |  |  531|      0|#define NUM_NODE_CLASSES 8
  ------------------
  |  Branch (1790:14): [True: 0, False: 0]
  ------------------
 1791|      0|	    for (s = NEXT_NODE(R_GenHeap[i].OldToNew[gen]);
  ------------------
  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1792|      0|		 s != R_GenHeap[i].OldToNew[gen];
  ------------------
  |  Branch (1792:4): [True: 0, False: 0]
  ------------------
 1793|      0|		 s = NEXT_NODE(s))
  ------------------
  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1794|      0|		FORWARD_CHILDREN(s);
  ------------------
  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  ------------------
  |  |  |  |  710|    318|#define DO_CHILDREN4(__n__,dc__action__,dc__str__action__,dc__extra__) do { \
  |  |  |  |  711|      0|  if (HAS_GENUINE_ATTRIB(__n__)) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  696|      0|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  230|      0|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (696:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (696:30): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  697|      0|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (697:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  712|      0|    dc__action__(ATTRIB(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  713|      0|  if (ALTREP(__n__)) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  242|      0|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (242:25): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  714|      0|	  dc__action__(TAG(__n__), dc__extra__);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  715|      0|	  dc__action__(CAR(__n__), dc__extra__);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  716|      0|	  dc__action__(CDR(__n__), dc__extra__);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  717|      0|      }							\
  |  |  |  |  718|      0|  else \
  |  |  |  |  719|      0|  switch (TYPEOF(__n__)) { \
  |  |  |  |  ------------------
  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  ------------------
  |  |  |  |  720|      0|  case NILSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (720:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  721|      0|  case BUILTINSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (721:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  722|      0|  case SPECIALSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (722:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  723|      0|  case CHARSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (723:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  724|      0|  case LGLSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (724:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  725|      0|  case INTSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (725:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  726|      0|  case REALSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  727|      0|  case CPLXSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (727:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  728|      0|  case WEAKREFSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|      0|#define WEAKREFSXP  23    /* weak reference */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (728:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  729|      0|  case RAWSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (729:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  730|      0|  case OBJSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (730:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  731|      0|    break; \
  |  |  |  |  732|      0|  case STRSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (732:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  733|      0|    { \
  |  |  |  |  734|      0|      R_xlen_t i; \
  |  |  |  |  735|      0|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (735:19): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  736|      0|	dc__str__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  826|      0|#define FC_PROCESS_CHARSXP(__n__,__dummy__) PROCESS_CHARSXP(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  825|      0|#define PROCESS_CHARSXP(__n__) FORWARD_AND_PROCESS_ONE_NODE(__n__, CHARSXP)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  812|      0|#define FORWARD_AND_PROCESS_ONE_NODE(s, tp) do {	\
  |  |  |  |  |  |  |  |  |  |  |  |  813|      0|	SEXP fpn__n__ = (s);				\
  |  |  |  |  |  |  |  |  |  |  |  |  814|      0|	int __tp__ = (tp);				\
  |  |  |  |  |  |  |  |  |  |  |  |  815|      0|	if (fpn__n__ && ! NODE_IS_MARKED(fpn__n__)) {	\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (815:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (815:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  816|      0|	    if (TYPEOF(fpn__n__) == __tp__ &&		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (816:10): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  817|      0|		! HAS_GENUINE_ATTRIB(fpn__n__)) {	\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  696|      0|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  230|      0|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (696:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (696:30): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  697|      0|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (697:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  818|      0|		MARK_AND_UNSNAP_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  819|      0|		PROCESS_ONE_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  803|      0|#define PROCESS_ONE_NODE(s) do {				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  804|      0|	SEXP pn__n__ = (s);					\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  805|      0|	int __cls__ = NODE_CLASS(pn__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  806|      0|	int __gen__ = NODE_GENERATION(pn__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  807|      0|	SNAP_NODE(pn__n__, R_GenHeap[__cls__].Old[__gen__]);	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  657|      0|#define SNAP_NODE(s,t) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  658|      0|  SEXP sn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  659|      0|  SEXP next = (t); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  660|      0|  SEXP prev = PREV_NODE(next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  661|      0|  SET_NEXT_NODE(sn__n__, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  662|      0|  SET_PREV_NODE(next, sn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  663|      0|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  664|      0|  SET_PREV_NODE(sn__n__, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  665|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (665:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  808|      0|	R_GenHeap[__cls__].OldCount[__gen__]++;			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  809|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (809:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  820|      0|	    }						\
  |  |  |  |  |  |  |  |  |  |  |  |  821|      0|	    else FORWARD_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  822|      0|	}						\
  |  |  |  |  |  |  |  |  |  |  |  |  823|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (823:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  737|      0|    } \
  |  |  |  |  738|      0|    break; \
  |  |  |  |  739|      0|  case EXPRSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (739:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  740|      0|  case VECSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (740:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  741|      0|    { \
  |  |  |  |  742|      0|      R_xlen_t i; \
  |  |  |  |  743|      0|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (743:19): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  744|      0|	dc__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  745|      0|    } \
  |  |  |  |  746|      0|    break; \
  |  |  |  |  747|      0|  case ENVSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (747:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  748|      0|    dc__action__(FRAME(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  749|      0|    dc__action__(ENCLOS(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  750|      0|    dc__action__(HASHTAB(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  751|      0|    break; \
  |  |  |  |  752|      0|  case LISTSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (752:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  753|      0|  case PROMSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (753:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  754|      0|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  755|      0|    if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  ------------------
  |  |  |  |  |  |   37|      0|# define BOXED_BINDING_CELLS 0
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (37:30): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                   if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  463|      0|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (755:32): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  756|      0|      dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  757|      0|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  758|      0|    break; \
  |  |  |  |  759|      0|  case CLOSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (759:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  760|      0|  case LANGSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (760:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  761|      0|  case DOTSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (761:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  762|      0|  case SYMSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (762:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  763|      0|  case BCODESXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  133|      0|#define BCODESXP    21    /* byte code */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (763:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  764|      0|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  765|      0|    dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  766|      0|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  767|      0|    break; \
  |  |  |  |  768|      0|  case EXTPTRSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  134|      0|#define EXTPTRSXP   22    /* external pointer */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (768:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  769|      0|    dc__action__(EXTPTR_PROT(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  770|      0|    dc__action__(EXTPTR_TAG(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  771|      0|    break; \
  |  |  |  |  772|      0|  FREE_FORWARD_CASE \
  |  |  |  |  ------------------
  |  |  |  |  |  |  705|      0|#define FREE_FORWARD_CASE case FREESXP: if (gc_inhibit_release) break;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (705:27): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (705:45): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  773|      0|  default: \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (773:3): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  774|      0|    register_bad_sexp_type(__n__, __LINE__);		\
  |  |  |  |  775|      0|  } \
  |  |  |  |  776|      0|} while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (776:9): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1795|    318|#endif
 1796|       |
 1797|       |    /* forward all roots */
 1798|    318|    FORWARD_NODE(R_NilValue);	           /* Builtin constants */
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1799|    318|    FORWARD_NODE(NA_STRING);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1800|    318|    FORWARD_NODE(R_BlankString);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1801|    318|    FORWARD_NODE(R_BlankScalarString);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1802|    318|    FORWARD_NODE(R_CurrentExpression);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1803|    318|    FORWARD_NODE(R_UnboundValue);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1804|    318|    FORWARD_NODE(R_RestartToken);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1805|    318|    FORWARD_NODE(R_MissingArg);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1806|    318|    FORWARD_NODE(R_InBCInterpreter);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1807|       |
 1808|    318|    FORWARD_NODE(R_GlobalEnv);	           /* Global environment */
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1809|    318|    FORWARD_NODE(R_BaseEnv);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1810|    318|    FORWARD_NODE(R_EmptyEnv);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1811|    318|    FORWARD_NODE(R_Warnings);	           /* Warnings, if any */
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 0, False: 318]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1812|    318|    FORWARD_NODE(R_ReturnedValue);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 0, False: 318]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1813|       |
 1814|    318|    FORWARD_NODE(R_HandlerStack);          /* Condition handler stack */
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 3, False: 315]
  |  |  ------------------
  |  |  797|      3|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      3|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      3|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      3|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      3|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      3|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      3|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      3|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      6|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 3]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      3|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      3|}
  |  |  |  |  ------------------
  |  |  |  |  790|      3|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      3|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      3|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      3|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      3|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      3|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      3|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      3|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      3|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      3|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      3|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      3|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      3|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      3|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      3|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      3|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      3|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 3]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      3|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 3]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      3|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      3|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      3|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      3|    forwarded_nodes = fn__n__; \
  |  |  800|      3|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1815|    318|    FORWARD_NODE(R_RestartStack);          /* Available restarts stack */
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 102, False: 216]
  |  |  ------------------
  |  |  797|    102|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    102|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    102|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    102|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    102|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    102|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    102|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    102|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    204|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 102]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    102|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    102|}
  |  |  |  |  ------------------
  |  |  |  |  790|    102|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    102|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    102|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    102|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    102|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    102|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    102|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    102|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    102|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    102|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    102|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    102|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    102|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    102|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    102|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    102|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    102|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 102]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    102|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 102]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    102|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    102|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    102|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    102|    forwarded_nodes = fn__n__; \
  |  |  800|    102|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1816|       |
 1817|    318|    FORWARD_NODE(R_BCbody);                /* Current byte code object */
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1818|    318|    FORWARD_NODE(R_Srcref);                /* Current source reference */
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 0, False: 318]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1819|    318|    FORWARD_NODE(R_ParseErrorFile);        /* Source file of the last parse error */
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 0, False: 318]
  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1820|       |
 1821|    318|    FORWARD_NODE(R_TrueValue);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1822|    318|    FORWARD_NODE(R_FalseValue);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1823|    318|    FORWARD_NODE(R_LogicalNAValue);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1824|       |
 1825|    318|    FORWARD_NODE(R_print.na_string);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 0, False: 318]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1826|    318|    FORWARD_NODE(R_print.na_string_noquote);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1827|       |
 1828|    318|    if (R_SymbolTable != NULL)             /* in case of GC during startup */
  ------------------
  |  Branch (1828:9): [True: 318, False: 0]
  ------------------
 1829|  15.6M|	for (i = 0; i < HSIZE; i++) {      /* Symbol table */
  ------------------
  |  | 1174|  15.6M|#define HSIZE	  49157	/* The size of the hash table for symbols */
  ------------------
  |  Branch (1829:14): [True: 15.6M, False: 318]
  ------------------
 1830|  15.6M|	    FORWARD_NODE(R_SymbolTable[i]);
  ------------------
  |  |  794|  15.6M|#define FORWARD_NODE(s) do { \
  |  |  795|  15.6M|  SEXP fn__n__ = (s); \
  |  |  796|  15.6M|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  15.6M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  15.6M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 15.6M, False: 0]
  |  |  |  Branch (796:18): [True: 2.10M, False: 13.5M]
  |  |  ------------------
  |  |  797|  2.10M|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|  2.10M|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|  2.10M|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|  2.10M|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|  2.10M|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|  2.10M|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|  2.10M|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  2.10M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|  4.20M|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 2.10M]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|  2.10M|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|  2.10M|}
  |  |  |  |  ------------------
  |  |  |  |  790|  2.10M|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|  2.10M|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  2.10M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|  2.10M|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|  2.10M|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|  2.10M|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|  2.10M|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|  2.10M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|  2.10M|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|  2.10M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|  2.10M|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|  2.10M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|  2.10M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|  2.10M|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|  2.10M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|  2.10M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|  2.10M|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 2.10M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|  2.10M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 2.10M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|  2.10M|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|  2.10M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  2.10M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|  2.10M|    forwarded_nodes = fn__n__; \
  |  |  800|  2.10M|  } \
  |  |  801|  15.6M|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 15.6M]
  |  |  ------------------
  ------------------
 1831|  15.6M|	    SEXP s;
 1832|  17.8M|	    for (s = R_SymbolTable[i]; s != R_NilValue; s = CDR(s))
  ------------------
  |  |  445|  2.26M|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
  |  Branch (1832:33): [True: 2.26M, False: 15.6M]
  ------------------
 1833|  2.26M|		if (ATTRIB(CAR(s)) != R_NilValue)
  ------------------
  |  |  230|  2.26M|#define ATTRIB(x)	((x)->attrib)
  ------------------
  |  Branch (1833:7): [True: 0, False: 2.26M]
  ------------------
 1834|      0|		    gc_error("****found a symbol with attributes\n");
 1835|  15.6M|	}
 1836|       |
 1837|    318|    if (R_CurrentExpr != NULL)	           /* Current expression */
  ------------------
  |  Branch (1837:9): [True: 318, False: 0]
  ------------------
 1838|    318|	FORWARD_NODE(R_CurrentExpr);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1839|       |
 1840|  20.6k|    for (i = 0; i < R_MaxDevices; i++) {   /* Device display lists */
  ------------------
  |  | 2390|  20.6k|#define R_MaxDevices 64
  ------------------
  |  Branch (1840:17): [True: 20.3k, False: 318]
  ------------------
 1841|  20.3k|	pGEDevDesc gdd = GEgetDevice(i);
 1842|  20.3k|	if (gdd) {
  ------------------
  |  Branch (1842:6): [True: 318, False: 20.0k]
  ------------------
 1843|    318|	    FORWARD_NODE(gdd->displayList);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 0, False: 318]
  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1844|    318|	    FORWARD_NODE(gdd->savedSnapshot);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 0, False: 318]
  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1845|    318|	    if (gdd->dev)
  ------------------
  |  Branch (1845:10): [True: 0, False: 318]
  ------------------
 1846|      0|		FORWARD_NODE(gdd->dev->eventEnv);
  ------------------
  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1847|    318|	}
 1848|  20.3k|    }
 1849|       |
 1850|  2.88k|    for (ctxt = R_GlobalContext ; ctxt != NULL ; ctxt = ctxt->nextcontext) {
  ------------------
  |  Branch (1850:35): [True: 2.57k, False: 318]
  ------------------
 1851|  2.57k|	FORWARD_NODE(ctxt->conexit);       /* on.exit expressions */
  ------------------
  |  |  794|  2.57k|#define FORWARD_NODE(s) do { \
  |  |  795|  2.57k|  SEXP fn__n__ = (s); \
  |  |  796|  2.57k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  2.57k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  2.57k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 2.57k, False: 0]
  |  |  |  Branch (796:18): [True: 2, False: 2.56k]
  |  |  ------------------
  |  |  797|      2|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      2|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      2|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      2|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      2|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      2|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      2|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      2|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      4|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 2]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      2|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      2|}
  |  |  |  |  ------------------
  |  |  |  |  790|      2|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      2|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      2|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      2|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      2|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      2|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      2|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      2|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      2|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      2|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      2|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      2|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      2|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      2|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      2|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      2|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      2|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 2]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      2|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      2|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      2|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      2|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      2|    forwarded_nodes = fn__n__; \
  |  |  800|      2|  } \
  |  |  801|  2.57k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 2.57k]
  |  |  ------------------
  ------------------
 1852|  2.57k|	FORWARD_NODE(ctxt->promargs);	   /* promises supplied to closure */
  ------------------
  |  |  794|  2.57k|#define FORWARD_NODE(s) do { \
  |  |  795|  2.57k|  SEXP fn__n__ = (s); \
  |  |  796|  2.57k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  2.57k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  2.57k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 2.57k, False: 0]
  |  |  |  Branch (796:18): [True: 1.93k, False: 641]
  |  |  ------------------
  |  |  797|  1.93k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|  1.93k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|  1.93k|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|  1.93k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|  1.93k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|  1.93k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|  1.93k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  1.93k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|  3.86k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 1.93k]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|  1.93k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|  1.93k|}
  |  |  |  |  ------------------
  |  |  |  |  790|  1.93k|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|  1.93k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  1.93k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|  1.93k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|  1.93k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|  1.93k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|  1.93k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|  1.93k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|  1.93k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|  1.93k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|  1.93k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|  1.93k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|  1.93k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|  1.93k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|  1.93k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|  1.93k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|  1.93k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 1.93k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|  1.93k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 1.93k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|  1.93k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|  1.93k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  1.93k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|  1.93k|    forwarded_nodes = fn__n__; \
  |  |  800|  1.93k|  } \
  |  |  801|  2.57k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 2.57k]
  |  |  ------------------
  ------------------
 1853|  2.57k|	FORWARD_NODE(ctxt->callfun);       /* the closure called */
  ------------------
  |  |  794|  2.57k|#define FORWARD_NODE(s) do { \
  |  |  795|  2.57k|  SEXP fn__n__ = (s); \
  |  |  796|  2.57k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  2.57k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  2.57k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 2.57k, False: 0]
  |  |  |  Branch (796:18): [True: 1.93k, False: 641]
  |  |  ------------------
  |  |  797|  1.93k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|  1.93k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|  1.93k|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|  1.93k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|  1.93k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|  1.93k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|  1.93k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  1.93k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|  3.86k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 1.93k]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|  1.93k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|  1.93k|}
  |  |  |  |  ------------------
  |  |  |  |  790|  1.93k|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|  1.93k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  1.93k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|  1.93k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|  1.93k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|  1.93k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|  1.93k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|  1.93k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|  1.93k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|  1.93k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|  1.93k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|  1.93k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|  1.93k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|  1.93k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|  1.93k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|  1.93k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|  1.93k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 1.93k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|  1.93k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 1.93k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|  1.93k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|  1.93k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  1.93k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|  1.93k|    forwarded_nodes = fn__n__; \
  |  |  800|  1.93k|  } \
  |  |  801|  2.57k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 2.57k]
  |  |  ------------------
  ------------------
 1854|  2.57k|	FORWARD_NODE(ctxt->sysparent);     /* calling environment */
  ------------------
  |  |  794|  2.57k|#define FORWARD_NODE(s) do { \
  |  |  795|  2.57k|  SEXP fn__n__ = (s); \
  |  |  796|  2.57k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  2.57k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  2.57k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 2.57k, False: 0]
  |  |  |  Branch (796:18): [True: 1.22k, False: 1.34k]
  |  |  ------------------
  |  |  797|  1.22k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|  1.22k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|  1.22k|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|  1.22k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|  1.22k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|  1.22k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|  1.22k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  1.22k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|  2.45k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 1.22k]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|  1.22k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|  1.22k|}
  |  |  |  |  ------------------
  |  |  |  |  790|  1.22k|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|  1.22k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  1.22k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|  1.22k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|  1.22k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|  1.22k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|  1.22k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|  1.22k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|  1.22k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|  1.22k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|  1.22k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|  1.22k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|  1.22k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|  1.22k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|  1.22k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|  1.22k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|  1.22k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 1.22k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|  1.22k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 1.22k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|  1.22k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|  1.22k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  1.22k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|  1.22k|    forwarded_nodes = fn__n__; \
  |  |  800|  1.22k|  } \
  |  |  801|  2.57k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 2.57k]
  |  |  ------------------
  ------------------
 1855|  2.57k|	FORWARD_NODE(ctxt->call);          /* the call */
  ------------------
  |  |  794|  2.57k|#define FORWARD_NODE(s) do { \
  |  |  795|  2.57k|  SEXP fn__n__ = (s); \
  |  |  796|  2.57k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  2.57k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  2.57k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 2.57k, False: 0]
  |  |  |  Branch (796:18): [True: 1.92k, False: 644]
  |  |  ------------------
  |  |  797|  1.92k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|  1.92k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|  1.92k|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|  1.92k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|  1.92k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|  1.92k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|  1.92k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  1.92k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|  3.85k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 1.92k]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|  1.92k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|  1.92k|}
  |  |  |  |  ------------------
  |  |  |  |  790|  1.92k|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|  1.92k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  1.92k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|  1.92k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|  1.92k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|  1.92k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|  1.92k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|  1.92k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|  1.92k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|  1.92k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|  1.92k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|  1.92k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|  1.92k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|  1.92k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|  1.92k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|  1.92k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|  1.92k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 1.92k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|  1.92k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 1.92k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|  1.92k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|  1.92k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  1.92k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|  1.92k|    forwarded_nodes = fn__n__; \
  |  |  800|  1.92k|  } \
  |  |  801|  2.57k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 2.57k]
  |  |  ------------------
  ------------------
 1856|  2.57k|	FORWARD_NODE(ctxt->cloenv);        /* the closure environment */
  ------------------
  |  |  794|  2.57k|#define FORWARD_NODE(s) do { \
  |  |  795|  2.57k|  SEXP fn__n__ = (s); \
  |  |  796|  2.57k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  2.57k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  2.57k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 2.57k, False: 0]
  |  |  |  Branch (796:18): [True: 705, False: 1.86k]
  |  |  ------------------
  |  |  797|    705|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    705|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    705|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    705|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    705|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    705|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    705|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    705|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|  1.41k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 705]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    705|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    705|}
  |  |  |  |  ------------------
  |  |  |  |  790|    705|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    705|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    705|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    705|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    705|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    705|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    705|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    705|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    705|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    705|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    705|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    705|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    705|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    705|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    705|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    705|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    705|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 705]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    705|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 705]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    705|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    705|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    705|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    705|    forwarded_nodes = fn__n__; \
  |  |  800|    705|  } \
  |  |  801|  2.57k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 2.57k]
  |  |  ------------------
  ------------------
 1857|  2.57k|	FORWARD_NODE(ctxt->bcbody);        /* the current byte code object */
  ------------------
  |  |  794|  2.57k|#define FORWARD_NODE(s) do { \
  |  |  795|  2.57k|  SEXP fn__n__ = (s); \
  |  |  796|  2.57k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  1.61k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  1.61k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 1.61k, False: 957]
  |  |  |  Branch (796:18): [True: 1.60k, False: 9]
  |  |  ------------------
  |  |  797|  1.60k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|  1.60k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|  1.60k|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|  1.60k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|  1.60k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|  1.60k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|  1.60k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  1.60k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|  3.21k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 1.60k]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|  1.60k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|  1.60k|}
  |  |  |  |  ------------------
  |  |  |  |  790|  1.60k|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|  1.60k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  1.60k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|  1.60k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|  1.60k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|  1.60k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|  1.60k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|  1.60k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|  1.60k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|  1.60k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|  1.60k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|  1.60k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|  1.60k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|  1.60k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|  1.60k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|  1.60k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|  1.60k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 1.60k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|  1.60k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 1.60k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|  1.60k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|  1.60k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  1.60k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|  1.60k|    forwarded_nodes = fn__n__; \
  |  |  800|  1.60k|  } \
  |  |  801|  2.57k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 2.57k]
  |  |  ------------------
  ------------------
 1858|  2.57k|	FORWARD_NODE(ctxt->handlerstack);  /* the condition handler stack */
  ------------------
  |  |  794|  2.57k|#define FORWARD_NODE(s) do { \
  |  |  795|  2.57k|  SEXP fn__n__ = (s); \
  |  |  796|  2.57k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  2.57k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  2.57k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 2.57k, False: 0]
  |  |  |  Branch (796:18): [True: 2, False: 2.56k]
  |  |  ------------------
  |  |  797|      2|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      2|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      2|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      2|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      2|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      2|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      2|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      2|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      4|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 2]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      2|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      2|}
  |  |  |  |  ------------------
  |  |  |  |  790|      2|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      2|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      2|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      2|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      2|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      2|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      2|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      2|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      2|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      2|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      2|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      2|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      2|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      2|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      2|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      2|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      2|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 2]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      2|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      2|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      2|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      2|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      2|    forwarded_nodes = fn__n__; \
  |  |  800|      2|  } \
  |  |  801|  2.57k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 2.57k]
  |  |  ------------------
  ------------------
 1859|  2.57k|	FORWARD_NODE(ctxt->restartstack);  /* the available restarts stack */
  ------------------
  |  |  794|  2.57k|#define FORWARD_NODE(s) do { \
  |  |  795|  2.57k|  SEXP fn__n__ = (s); \
  |  |  796|  2.57k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  2.57k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  2.57k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 2.57k, False: 0]
  |  |  |  Branch (796:18): [True: 0, False: 2.57k]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|  2.57k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 2.57k]
  |  |  ------------------
  ------------------
 1860|  2.57k|	FORWARD_NODE(ctxt->srcref);	   /* the current source reference */
  ------------------
  |  |  794|  2.57k|#define FORWARD_NODE(s) do { \
  |  |  795|  2.57k|  SEXP fn__n__ = (s); \
  |  |  796|  2.57k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  2.57k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  2.57k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 2.57k, False: 0]
  |  |  |  Branch (796:18): [True: 0, False: 2.57k]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|  2.57k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 2.57k]
  |  |  ------------------
  ------------------
 1861|  2.57k|	if (ctxt->returnValue.tag == 0)    /* For on.exit calls */
  ------------------
  |  Branch (1861:6): [True: 2.57k, False: 0]
  ------------------
 1862|  2.57k|	    FORWARD_NODE(ctxt->returnValue.u.sxpval);
  ------------------
  |  |  794|  2.57k|#define FORWARD_NODE(s) do { \
  |  |  795|  2.57k|  SEXP fn__n__ = (s); \
  |  |  796|  2.57k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 0, False: 2.57k]
  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|  2.57k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 2.57k]
  |  |  ------------------
  ------------------
 1863|  2.57k|    }
 1864|       |
 1865|    318|    FORWARD_NODE(R_PreciousList);
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 318, False: 0]
  |  |  |  Branch (796:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  800|    318|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1866|       |
 1867|  19.2k|    for (i = 0; i < R_PPStackTop; i++)	   /* Protected pointers */
  ------------------
  |  Branch (1867:17): [True: 18.9k, False: 318]
  ------------------
 1868|  18.9k|	FORWARD_NODE(R_PPStack[i]);
  ------------------
  |  |  794|  19.2k|#define FORWARD_NODE(s) do { \
  |  |  795|  18.9k|  SEXP fn__n__ = (s); \
  |  |  796|  18.9k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  18.9k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  18.9k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 18.9k, False: 0]
  |  |  |  Branch (796:18): [True: 12.8k, False: 6.11k]
  |  |  ------------------
  |  |  797|  12.8k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|  12.8k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|  12.8k|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|  12.8k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|  12.8k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|  12.8k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|  12.8k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  12.8k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|  25.6k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 12.8k]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|  12.8k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|  12.8k|}
  |  |  |  |  ------------------
  |  |  |  |  790|  12.8k|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|  12.8k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  12.8k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|  12.8k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|  12.8k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|  12.8k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|  12.8k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|  12.8k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|  12.8k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|  12.8k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|  12.8k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|  12.8k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|  12.8k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|  12.8k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|  12.8k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|  12.8k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|  12.8k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 12.8k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|  12.8k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 12.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|  12.8k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|  12.8k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  12.8k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|  12.8k|    forwarded_nodes = fn__n__; \
  |  |  800|  12.8k|  } \
  |  |  801|  18.9k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 18.9k]
  |  |  ------------------
  ------------------
 1869|       |
 1870|    318|    FORWARD_NODE(R_VStack);		   /* R_alloc stack */
  ------------------
  |  |  794|    318|#define FORWARD_NODE(s) do { \
  |  |  795|    318|  SEXP fn__n__ = (s); \
  |  |  796|    318|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 0, False: 318]
  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1871|       |
 1872|  85.7k|    for (R_bcstack_t *sp = R_BCNodeStackBase; sp < R_BCNodeStackTop; sp++) {
  ------------------
  |  Branch (1872:47): [True: 85.3k, False: 318]
  ------------------
 1873|  85.3k|	if (sp->tag == RAWMEM_TAG)
  ------------------
  |  | 1401|  85.3k|# define RAWMEM_TAG 254
  ------------------
  |  Branch (1873:6): [True: 3.29k, False: 82.1k]
  ------------------
 1874|  3.29k|	    sp += sp->u.ival;
 1875|  82.1k|	else if (sp->tag == 0 || IS_PARTIAL_SXP_TAG(sp->tag))
  ------------------
  |  | 1400|  74.7k|# define IS_PARTIAL_SXP_TAG(x) ((x) & PARTIALSXP_MASK)
  |  |  ------------------
  |  |  |  | 1399|  74.7k|# define PARTIALSXP_MASK (~255)
  |  |  ------------------
  |  |  |  Branch (1400:32): [True: 72.0k, False: 2.70k]
  |  |  ------------------
  ------------------
  |  Branch (1875:11): [True: 7.35k, False: 74.7k]
  ------------------
 1876|  79.4k|	    FORWARD_NODE(sp->u.sxpval);
  ------------------
  |  |  794|  79.4k|#define FORWARD_NODE(s) do { \
  |  |  795|  79.4k|  SEXP fn__n__ = (s); \
  |  |  796|  79.4k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  79.4k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  79.4k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 79.4k, False: 0]
  |  |  |  Branch (796:18): [True: 6.16k, False: 73.2k]
  |  |  ------------------
  |  |  797|  6.16k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|  6.16k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|  6.16k|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|  6.16k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|  6.16k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|  6.16k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|  6.16k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  6.16k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|  12.3k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 6.16k]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|  6.16k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|  6.16k|}
  |  |  |  |  ------------------
  |  |  |  |  790|  6.16k|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|  6.16k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  6.16k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|  6.16k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|  6.16k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|  6.16k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|  6.16k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|  6.16k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|  6.16k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|  6.16k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|  6.16k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|  6.16k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|  6.16k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|  6.16k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|  6.16k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|  6.16k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|  6.16k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 6.16k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|  6.16k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 6.16k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|  6.16k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|  6.16k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  6.16k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|  6.16k|    forwarded_nodes = fn__n__; \
  |  |  800|  6.16k|  } \
  |  |  801|  79.4k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 79.4k]
  |  |  ------------------
  ------------------
 1877|  85.3k|    }
 1878|       |
 1879|       |    /* main processing loop */
 1880|    318|    PROCESS_NODES();
  ------------------
  |  | 1711|    318|#define PROCESS_NODES() do { \
  |  | 1712|   115M|    while (forwarded_nodes != NULL) { \
  |  |  ------------------
  |  |  |  Branch (1712:12): [True: 115M, False: 318]
  |  |  ------------------
  |  | 1713|   115M|	SEXP s = forwarded_nodes; \
  |  | 1714|   115M|	forwarded_nodes = NEXT_NODE(forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  639|   115M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  |  | 1715|   115M|	PROCESS_ONE_NODE(s); \
  |  |  ------------------
  |  |  |  |  803|   115M|#define PROCESS_ONE_NODE(s) do {				\
  |  |  |  |  804|   115M|	SEXP pn__n__ = (s);					\
  |  |  |  |  805|   115M|	int __cls__ = NODE_CLASS(pn__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  545|   115M|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  ------------------
  |  |  |  |  806|   115M|	int __gen__ = NODE_GENERATION(pn__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|   115M|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  807|   115M|	SNAP_NODE(pn__n__, R_GenHeap[__cls__].Old[__gen__]);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  657|   115M|#define SNAP_NODE(s,t) do { \
  |  |  |  |  |  |  658|   115M|  SEXP sn__n__ = (s); \
  |  |  |  |  |  |  659|   115M|  SEXP next = (t); \
  |  |  |  |  |  |  660|   115M|  SEXP prev = PREV_NODE(next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|   115M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  661|   115M|  SET_NEXT_NODE(sn__n__, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|   115M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|   115M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  662|   115M|  SET_PREV_NODE(next, sn__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|   115M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|   115M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  663|   115M|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|   115M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|   115M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  664|   115M|  SET_PREV_NODE(sn__n__, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|   115M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|   115M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  665|   115M|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (665:10): [Folded, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  808|   115M|	R_GenHeap[__cls__].OldCount[__gen__]++;			\
  |  |  |  |  809|   115M|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (809:14): [Folded, False: 115M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1716|   115M|	FORWARD_CHILDREN(s); \
  |  |  ------------------
  |  |  |  |  829|   115M|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |  710|   115M|#define DO_CHILDREN4(__n__,dc__action__,dc__str__action__,dc__extra__) do { \
  |  |  |  |  |  |  711|   115M|  if (HAS_GENUINE_ATTRIB(__n__)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  696|   115M|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|   115M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  142|   230M|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  230|   115M|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (696:6): [True: 115M, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (696:30): [True: 7.86M, False: 107M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  697|   115M|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|  7.86M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  120|  15.7M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|  71.0k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  120|  71.0k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (697:7): [True: 7.79M, False: 71.0k]
  |  |  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 71.0k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  712|   115M|    dc__action__(ATTRIB(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|   115M|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|  7.79M|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|  7.79M|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|  7.79M|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|  7.79M|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|  7.79M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  7.79M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 7.79M, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 7.79M, False: 4]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|  7.79M|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|  7.79M|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|  7.79M|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|  7.79M|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|  7.79M|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|  7.79M|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|  7.79M|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  7.79M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|  15.5M|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 7.79M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|  7.79M|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|  7.79M|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|  7.79M|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|  7.79M|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  7.79M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|  7.79M|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|  7.79M|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|  7.79M|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|  7.79M|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  7.79M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|  7.79M|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  7.79M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|  7.79M|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  7.79M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  7.79M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|  7.79M|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|  7.79M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  7.79M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|  7.79M|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 7.79M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|  7.79M|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 7.79M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|  7.79M|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  7.79M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  7.79M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|  7.79M|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|  7.79M|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|  7.79M|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 7.79M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  713|   115M|  if (ALTREP(__n__)) {					\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  242|   115M|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (242:25): [True: 1.26k, False: 115M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  714|  1.26k|	  dc__action__(TAG(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|  1.26k|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|  1.26k|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|  1.26k|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|  1.26k|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|  1.26k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|  1.26k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  1.26k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 1.26k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 316, False: 950]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|    316|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|    316|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|    316|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|    316|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|    316|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|    316|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|    316|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|    316|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|    632|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 316]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|    316|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|    316|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|    316|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|    316|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|    316|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|    316|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|    316|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|    316|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|    316|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|    316|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|    316|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|    316|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|    316|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|    316|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|    316|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|    316|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|    316|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|    316|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|    316|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 316]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|    316|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 316]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|    316|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|    316|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|    316|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|    316|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|    316|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|  1.26k|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 1.26k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  715|  1.26k|	  dc__action__(CAR(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|  1.26k|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|  1.26k|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|  1.26k|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|  1.26k|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|  1.26k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|  1.26k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  1.26k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 1.26k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 1.26k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|  1.26k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|  1.26k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|  1.26k|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|  1.26k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|  1.26k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|  1.26k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|  1.26k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  1.26k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|  2.53k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 1.26k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|  1.26k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|  1.26k|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|  1.26k|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|  1.26k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  1.26k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|  1.26k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|  1.26k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|  1.26k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|  1.26k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  1.26k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|  1.26k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  1.26k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|  1.26k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  1.26k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  1.26k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|  1.26k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|  1.26k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  1.26k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|  1.26k|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 1.26k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|  1.26k|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 1.26k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|  1.26k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  1.26k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  1.26k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|  1.26k|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|  1.26k|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|  1.26k|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 1.26k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  716|  1.26k|	  dc__action__(CDR(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|  1.26k|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|  1.26k|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|  1.26k|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|  1.26k|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|  1.26k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|  1.26k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  1.26k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 1.26k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 318, False: 948]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|    318|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|    318|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|    318|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|    318|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|    318|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|  1.26k|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 1.26k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  717|  1.26k|      }							\
  |  |  |  |  |  |  718|   115M|  else \
  |  |  |  |  |  |  719|   115M|  switch (TYPEOF(__n__)) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|   115M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  720|    318|  case NILSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  111|    318|#define NILSXP	     0	  /* nil = NULL */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (720:3): [True: 318, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  721|   229k|  case BUILTINSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  119|   229k|#define BUILTINSXP   8	  /* builtin non-special forms */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (721:3): [True: 228k, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  722|   245k|  case SPECIALSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  118|   245k|#define SPECIALSXP   7	  /* special forms */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (722:3): [True: 15.9k, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  723|  1.58M|  case CHARSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  120|  1.58M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (723:3): [True: 1.33M, False: 114M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  724|  3.76M|  case LGLSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  121|  3.76M|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (724:3): [True: 2.18M, False: 113M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  725|  14.2M|  case INTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  123|  14.2M|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (725:3): [True: 10.4M, False: 104M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  726|  15.0M|  case REALSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|  15.0M|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:3): [True: 759k, False: 114M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  727|  15.0M|  case CPLXSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  125|  15.0M|#define CPLXSXP	    15	  /* complex variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (727:3): [True: 318, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  728|  15.2M|  case WEAKREFSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  135|  15.2M|#define WEAKREFSXP  23    /* weak reference */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (728:3): [True: 247k, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  729|  15.2M|  case RAWSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  136|  15.2M|#define RAWSXP      24    /* raw bytes */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (729:3): [True: 4.24k, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  730|  15.5M|  case OBJSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  137|  15.5M|#define OBJSXP      25    /* object, non-vector  */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (730:3): [True: 299k, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  731|  15.5M|    break; \
  |  |  |  |  |  |  732|  15.2M|  case STRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  126|  15.2M|#define STRSXP	    16	  /* string vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (732:3): [True: 15.2M, False: 100M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  733|  15.2M|    { \
  |  |  |  |  |  |  734|  15.2M|      R_xlen_t i; \
  |  |  |  |  |  |  735|  39.6M|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  407|  39.6M|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (735:19): [True: 24.4M, False: 15.2M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  736|  15.2M|	dc__str__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|  15.2M|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  826|  15.2M|#define FC_PROCESS_CHARSXP(__n__,__dummy__) PROCESS_CHARSXP(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  825|  24.4M|#define PROCESS_CHARSXP(__n__) FORWARD_AND_PROCESS_ONE_NODE(__n__, CHARSXP)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  812|  39.6M|#define FORWARD_AND_PROCESS_ONE_NODE(s, tp) do {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  813|  24.4M|	SEXP fpn__n__ = (s);				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  814|  24.4M|	int __tp__ = (tp);				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  815|  24.4M|	if (fpn__n__ && ! NODE_IS_MARKED(fpn__n__)) {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|  24.4M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  24.4M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (815:6): [True: 24.4M, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (815:18): [True: 1.29M, False: 23.1M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  816|  1.29M|	    if (TYPEOF(fpn__n__) == __tp__ &&		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  1.29M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (816:10): [True: 1.29M, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  817|  1.29M|		! HAS_GENUINE_ATTRIB(fpn__n__)) {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  696|  1.29M|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  1.29M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|  2.59M|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  230|  1.29M|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (696:6): [True: 1.29M, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (696:30): [True: 80.8k, False: 1.21M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  697|  1.29M|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  80.8k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  120|   161k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  80.8k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  120|  80.8k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (697:7): [True: 0, False: 80.8k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 80.8k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  818|  1.29M|		MARK_AND_UNSNAP_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|  1.29M|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|  1.29M|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|  1.29M|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|  1.29M|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|  1.29M|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|  1.29M|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  1.29M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|  2.59M|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 1.29M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|  1.29M|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|  1.29M|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|  1.29M|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|  1.29M|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  1.29M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|  1.29M|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|  1.29M|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|  1.29M|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|  1.29M|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  1.29M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|  1.29M|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  1.29M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|  1.29M|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  1.29M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  1.29M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|  1.29M|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|  1.29M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  1.29M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|  1.29M|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 1.29M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|  1.29M|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 1.29M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  819|  1.29M|		PROCESS_ONE_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  803|  1.29M|#define PROCESS_ONE_NODE(s) do {				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  804|  1.29M|	SEXP pn__n__ = (s);					\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  805|  1.29M|	int __cls__ = NODE_CLASS(pn__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  545|  1.29M|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  806|  1.29M|	int __gen__ = NODE_GENERATION(pn__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  559|  1.29M|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  807|  1.29M|	SNAP_NODE(pn__n__, R_GenHeap[__cls__].Old[__gen__]);	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  657|  1.29M|#define SNAP_NODE(s,t) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  658|  1.29M|  SEXP sn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  659|  1.29M|  SEXP next = (t); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  660|  1.29M|  SEXP prev = PREV_NODE(next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  1.29M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  661|  1.29M|  SET_NEXT_NODE(sn__n__, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  1.29M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  1.29M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  662|  1.29M|  SET_PREV_NODE(next, sn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|  1.29M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  1.29M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  663|  1.29M|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  1.29M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  1.29M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  664|  1.29M|  SET_PREV_NODE(sn__n__, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|  1.29M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  1.29M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  665|  1.29M|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (665:10): [Folded, False: 1.29M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  808|  1.29M|	R_GenHeap[__cls__].OldCount[__gen__]++;			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  809|  1.29M|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (809:14): [Folded, False: 1.29M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  820|  1.29M|	    }						\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  821|  1.29M|	    else FORWARD_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  822|  1.29M|	}						\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  823|  24.4M|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (823:14): [Folded, False: 24.4M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  737|  15.2M|    } \
  |  |  |  |  |  |  738|  15.2M|    break; \
  |  |  |  |  |  |  739|  15.2M|  case EXPRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  132|    318|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (739:3): [True: 318, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  740|  5.04M|  case VECSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  131|  5.04M|#define VECSXP	    19	  /* generic vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (740:3): [True: 5.04M, False: 110M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  741|  5.04M|    { \
  |  |  |  |  |  |  742|  5.04M|      R_xlen_t i; \
  |  |  |  |  |  |  743|  44.5M|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  407|  44.5M|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (743:19): [True: 39.5M, False: 5.04M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  744|  5.04M|	dc__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|  5.04M|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|  39.5M|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|  44.5M|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|  39.5M|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|  39.5M|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|  39.5M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  39.5M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 39.5M, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 24.1M, False: 15.3M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|  24.1M|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|  24.1M|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|  24.1M|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|  24.1M|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|  24.1M|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|  24.1M|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|  24.1M|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  24.1M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|  48.2M|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 24.1M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|  24.1M|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|  24.1M|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|  24.1M|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|  24.1M|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  24.1M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|  24.1M|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|  24.1M|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|  24.1M|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|  24.1M|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  24.1M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|  24.1M|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  24.1M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|  24.1M|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  24.1M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  24.1M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|  24.1M|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|  24.1M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  24.1M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|  24.1M|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 24.1M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|  24.1M|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 24.1M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|  24.1M|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  24.1M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  24.1M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|  24.1M|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|  24.1M|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|  39.5M|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 39.5M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  745|  5.04M|    } \
  |  |  |  |  |  |  746|  5.04M|    break; \
  |  |  |  |  |  |  747|   327k|  case ENVSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  115|   327k|#define ENVSXP	     4	  /* environments */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (747:3): [True: 327k, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  748|   327k|    dc__action__(FRAME(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|   327k|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|   327k|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|   327k|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|   327k|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|   327k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|   327k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|   327k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 327k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 210k, False: 117k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|   210k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|   210k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|   210k|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|   210k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|   210k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|   210k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|   210k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|   210k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|   420k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 210k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|   210k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|   210k|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|   210k|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|   210k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|   210k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|   210k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|   210k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|   210k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|   210k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|   210k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|   210k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|   210k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|   210k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|   210k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|   210k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|   210k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|   210k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|   210k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|   210k|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 210k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|   210k|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 210k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|   210k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|   210k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|   210k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|   210k|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|   210k|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|   327k|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 327k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  749|   327k|    dc__action__(ENCLOS(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|   327k|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|   327k|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|   327k|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|   327k|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|   327k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|   327k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|   327k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 327k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 16.1k, False: 311k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|  16.1k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|  16.1k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|  16.1k|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|  16.1k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|  16.1k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|  16.1k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|  16.1k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  16.1k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|  32.3k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 16.1k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|  16.1k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|  16.1k|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|  16.1k|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|  16.1k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  16.1k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|  16.1k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|  16.1k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|  16.1k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|  16.1k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  16.1k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|  16.1k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  16.1k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|  16.1k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  16.1k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  16.1k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|  16.1k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|  16.1k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  16.1k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|  16.1k|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 16.1k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|  16.1k|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 16.1k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|  16.1k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  16.1k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  16.1k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|  16.1k|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|  16.1k|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|   327k|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 327k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  750|   327k|    dc__action__(HASHTAB(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|   327k|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|   327k|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|   327k|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|   327k|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|   327k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|   327k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|   327k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 327k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 115k, False: 212k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|   115k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|   115k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|   115k|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|   115k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|   115k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|   115k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|   115k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|   115k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|   230k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 115k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|   115k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|   115k|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|   115k|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|   115k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|   115k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|   115k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|   115k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|   115k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|   115k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|   115k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|   115k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|   115k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|   115k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|   115k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|   115k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|   115k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|   115k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|   115k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|   115k|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 115k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|   115k|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 115k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|   115k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|   115k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|   115k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|   115k|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|   115k|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|   327k|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 327k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  751|   327k|    break; \
  |  |  |  |  |  |  752|  54.5M|  case LISTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|  54.5M|#define LISTSXP	     2	  /* lists of dotted pairs */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (752:3): [True: 54.5M, False: 60.9M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  753|  56.5M|  case PROMSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  116|  56.5M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (753:3): [True: 1.99M, False: 113M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  754|  56.5M|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|  56.5M|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|  56.5M|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|  56.5M|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|  56.5M|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|  56.5M|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|  56.5M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  56.5M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 56.5M, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 1.67M, False: 54.8M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|  1.67M|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|  1.67M|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|  1.67M|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|  1.67M|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|  1.67M|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|  1.67M|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|  1.67M|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  1.67M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|  3.35M|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 1.67M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|  1.67M|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|  1.67M|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|  1.67M|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|  1.67M|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  1.67M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|  1.67M|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|  1.67M|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|  1.67M|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|  1.67M|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  1.67M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|  1.67M|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  1.67M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|  1.67M|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  1.67M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  1.67M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|  1.67M|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|  1.67M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  1.67M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|  1.67M|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 1.67M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|  1.67M|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 1.67M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|  1.67M|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  1.67M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  1.67M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|  1.67M|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|  1.67M|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|  56.5M|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 56.5M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  755|  56.5M|    if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   37|   113M|# define BOXED_BINDING_CELLS 0
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (37:30): [Folded, False: 56.5M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  463|  56.5M|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (755:32): [True: 56.5M, False: 1.37k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  756|  56.5M|      dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|  56.5M|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|  56.5M|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|  56.5M|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|  56.5M|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|  56.5M|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|  56.5M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  56.5M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 56.5M, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 23.6M, False: 32.8M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|  23.6M|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|  23.6M|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|  23.6M|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|  23.6M|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|  23.6M|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|  23.6M|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|  23.6M|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  23.6M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|  47.3M|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 23.6M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|  23.6M|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|  23.6M|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|  23.6M|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|  23.6M|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  23.6M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|  23.6M|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|  23.6M|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|  23.6M|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|  23.6M|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  23.6M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|  23.6M|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  23.6M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|  23.6M|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  23.6M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  23.6M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|  23.6M|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|  23.6M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  23.6M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|  23.6M|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 23.6M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|  23.6M|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 23.6M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|  23.6M|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  23.6M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  23.6M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|  23.6M|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|  23.6M|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|  56.5M|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 56.5M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  757|  56.5M|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|  56.5M|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|  56.5M|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|  56.5M|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|  56.5M|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|  56.5M|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|  56.5M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  56.5M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 56.5M, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 27.8M, False: 28.6M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|  27.8M|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|  27.8M|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|  27.8M|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|  27.8M|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|  27.8M|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|  27.8M|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|  27.8M|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  27.8M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|  55.7M|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 27.8M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|  27.8M|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|  27.8M|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|  27.8M|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|  27.8M|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  27.8M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|  27.8M|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|  27.8M|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|  27.8M|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|  27.8M|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  27.8M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|  27.8M|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  27.8M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|  27.8M|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  27.8M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  27.8M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|  27.8M|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|  27.8M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  27.8M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|  27.8M|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 27.8M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|  27.8M|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 27.8M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|  27.8M|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  27.8M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  27.8M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|  27.8M|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|  27.8M|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|  56.5M|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 56.5M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  758|  56.5M|    break; \
  |  |  |  |  |  |  759|  54.5M|  case CLOSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|  1.12M|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (759:3): [True: 1.12M, False: 114M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  760|  15.9M|  case LANGSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  117|  15.9M|#define LANGSXP	     6	  /* language constructs (special lists) */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (760:3): [True: 14.8M, False: 100M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  761|  15.9M|  case DOTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  127|  15.9M|#define DOTSXP	    17	  /* dot-dot-dot object */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (761:3): [True: 572, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  762|  18.2M|  case SYMSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|  18.2M|#define SYMSXP	     1	  /* symbols */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (762:3): [True: 2.26M, False: 113M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  763|  22.4M|  case BCODESXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  133|  22.4M|#define BCODESXP    21    /* byte code */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (763:3): [True: 4.21M, False: 111M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  764|  22.4M|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|  22.4M|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|  22.4M|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|  22.4M|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|  22.4M|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|  22.4M|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|  22.4M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  22.4M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 22.4M, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 103k, False: 22.3M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|   103k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|   103k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|   103k|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|   103k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|   103k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|   103k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|   103k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|   103k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|   206k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 103k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|   103k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|   103k|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|   103k|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|   103k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|   103k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|   103k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|   103k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|   103k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|   103k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|   103k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|   103k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|   103k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|   103k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|   103k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|   103k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|   103k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|   103k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|   103k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|   103k|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 103k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|   103k|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 103k]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|   103k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|   103k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|   103k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|   103k|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|   103k|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|  22.4M|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 22.4M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  765|  22.4M|    dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|  22.4M|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|  22.4M|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|  22.4M|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|  22.4M|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|  22.4M|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|  22.4M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  22.4M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 22.4M, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 7.31M, False: 15.1M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|  7.31M|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|  7.31M|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|  7.31M|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|  7.31M|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|  7.31M|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|  7.31M|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|  7.31M|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  7.31M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|  14.6M|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 7.31M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|  7.31M|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|  7.31M|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|  7.31M|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|  7.31M|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  7.31M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|  7.31M|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|  7.31M|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|  7.31M|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|  7.31M|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  7.31M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|  7.31M|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  7.31M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|  7.31M|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  7.31M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  7.31M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|  7.31M|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|  7.31M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  7.31M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|  7.31M|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 7.31M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|  7.31M|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 7.31M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|  7.31M|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  7.31M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  7.31M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|  7.31M|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|  7.31M|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|  22.4M|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 22.4M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  766|  22.4M|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|  22.4M|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|  22.4M|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|  22.4M|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|  22.4M|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|  22.4M|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|  22.4M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  22.4M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 22.4M, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 20.4M, False: 2.01M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|  20.4M|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|  20.4M|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|  20.4M|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|  20.4M|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|  20.4M|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|  20.4M|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|  20.4M|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|  20.4M|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|  40.9M|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 20.4M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|  20.4M|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|  20.4M|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|  20.4M|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|  20.4M|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  20.4M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|  20.4M|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|  20.4M|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|  20.4M|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|  20.4M|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  20.4M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|  20.4M|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  20.4M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|  20.4M|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  20.4M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  20.4M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|  20.4M|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|  20.4M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  20.4M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|  20.4M|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 20.4M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|  20.4M|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 20.4M]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|  20.4M|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|  20.4M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  20.4M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|  20.4M|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|  20.4M|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|  22.4M|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 22.4M]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  767|  22.4M|    break; \
  |  |  |  |  |  |  768|  18.2M|  case EXTPTRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  134|   311k|#define EXTPTRSXP   22    /* external pointer */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (768:3): [True: 311k, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  769|   311k|    dc__action__(EXTPTR_PROT(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|   311k|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|   311k|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|   311k|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|   311k|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|   311k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|   311k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|   311k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 311k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 311k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|   311k|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 311k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  770|   311k|    dc__action__(EXTPTR_TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|   311k|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|   311k|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|   311k|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|   311k|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|   311k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|   311k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|   311k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 311k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 954, False: 310k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|    954|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|    954|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|    954|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|    954|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|    954|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|    954|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|    954|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|    954|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|  1.90k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 954]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|    954|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|    954|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|    954|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|    954|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|    954|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|    954|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|    954|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|    954|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|    954|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|    954|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|    954|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|    954|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|    954|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|    954|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|    954|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|    954|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|    954|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|    954|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|    954|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 954]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|    954|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 954]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|    954|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|    954|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|    954|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|    954|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|    954|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|   311k|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 311k]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  771|   311k|    break; \
  |  |  |  |  |  |  772|  18.2M|  FREE_FORWARD_CASE \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  705|      0|#define FREE_FORWARD_CASE case FREESXP: if (gc_inhibit_release) break;
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (705:27): [True: 0, False: 115M]
  |  |  |  |  |  |  |  |  |  Branch (705:45): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  773|      0|  default: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (773:3): [True: 0, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  774|      0|    register_bad_sexp_type(__n__, __LINE__);		\
  |  |  |  |  |  |  775|   115M|  } \
  |  |  |  |  |  |  776|   115M|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (776:9): [Folded, False: 115M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1717|   115M|    } \
  |  | 1718|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (1718:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1881|       |
 1882|       |    /* identify weakly reachable nodes */
 1883|    318|    {
 1884|    318|	Rboolean recheck_weak_refs;
 1885|    636|	do {
 1886|    636|	    recheck_weak_refs = FALSE;
 1887|   741k|	    for (s = R_weak_refs; s != R_NilValue; s = WEAKREF_NEXT(s)) {
  ------------------
  |  | 1420|   741k|#define WEAKREF_NEXT(w) VECTOR_ELT_0(w, 3)
  |  |  ------------------
  |  |  |  |   80|   741k|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  |  |  ------------------
  |  |  |  |  |  |  420|   741k|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1887:28): [True: 741k, False: 636]
  ------------------
 1888|   741k|		if (NODE_IS_MARKED(WEAKREF_KEY(s))) {
  ------------------
  |  |  268|   741k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  ------------------
  |  |  |  |  232|   741k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  ------------------
  |  |  |  Branch (268:27): [True: 741k, False: 130]
  |  |  ------------------
  ------------------
 1889|   741k|		    if (! NODE_IS_MARKED(WEAKREF_VALUE(s))) {
  ------------------
  |  |  268|   741k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  ------------------
  |  |  |  |  232|   741k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  ------------------
  ------------------
  |  Branch (1889:11): [True: 0, False: 741k]
  ------------------
 1890|      0|			recheck_weak_refs = TRUE;
 1891|      0|			FORWARD_NODE(WEAKREF_VALUE(s));
  ------------------
  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1892|      0|		    }
 1893|   741k|		    if (! NODE_IS_MARKED(WEAKREF_FINALIZER(s))) {
  ------------------
  |  |  268|   741k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  ------------------
  |  |  |  |  232|   741k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  ------------------
  ------------------
  |  Branch (1893:11): [True: 122k, False: 618k]
  ------------------
 1894|   122k|			recheck_weak_refs = TRUE;
 1895|   122k|			FORWARD_NODE(WEAKREF_FINALIZER(s));
  ------------------
  |  |  794|   122k|#define FORWARD_NODE(s) do { \
  |  |  795|   122k|  SEXP fn__n__ = (s); \
  |  |  796|   122k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|   122k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|   122k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 122k, False: 0]
  |  |  |  Branch (796:18): [True: 122k, False: 0]
  |  |  ------------------
  |  |  797|   122k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|   122k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|   122k|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|   122k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|   122k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|   122k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|   122k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|   122k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|   245k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 122k]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|   122k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|   122k|}
  |  |  |  |  ------------------
  |  |  |  |  790|   122k|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|   122k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|   122k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|   122k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|   122k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|   122k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|   122k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|   122k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|   122k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|   122k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|   122k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|   122k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|   122k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|   122k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|   122k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|   122k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|   122k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|   122k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 122k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|   122k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|   122k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|   122k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|   122k|    forwarded_nodes = fn__n__; \
  |  |  800|   122k|  } \
  |  |  801|   122k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 122k]
  |  |  ------------------
  ------------------
 1896|   122k|		    }
 1897|   741k|		}
 1898|   741k|	    }
 1899|    636|	    PROCESS_NODES();
  ------------------
  |  | 1711|    636|#define PROCESS_NODES() do { \
  |  | 1712|   123k|    while (forwarded_nodes != NULL) { \
  |  |  ------------------
  |  |  |  Branch (1712:12): [True: 122k, False: 636]
  |  |  ------------------
  |  | 1713|   122k|	SEXP s = forwarded_nodes; \
  |  | 1714|   122k|	forwarded_nodes = NEXT_NODE(forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  639|   122k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  |  | 1715|   122k|	PROCESS_ONE_NODE(s); \
  |  |  ------------------
  |  |  |  |  803|   122k|#define PROCESS_ONE_NODE(s) do {				\
  |  |  |  |  804|   122k|	SEXP pn__n__ = (s);					\
  |  |  |  |  805|   122k|	int __cls__ = NODE_CLASS(pn__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  545|   122k|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  ------------------
  |  |  |  |  806|   122k|	int __gen__ = NODE_GENERATION(pn__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|   122k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  807|   122k|	SNAP_NODE(pn__n__, R_GenHeap[__cls__].Old[__gen__]);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  657|   122k|#define SNAP_NODE(s,t) do { \
  |  |  |  |  |  |  658|   122k|  SEXP sn__n__ = (s); \
  |  |  |  |  |  |  659|   122k|  SEXP next = (t); \
  |  |  |  |  |  |  660|   122k|  SEXP prev = PREV_NODE(next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|   122k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  661|   122k|  SET_NEXT_NODE(sn__n__, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|   122k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|   122k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  662|   122k|  SET_PREV_NODE(next, sn__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|   122k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|   122k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  663|   122k|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|   122k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|   122k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  664|   122k|  SET_PREV_NODE(sn__n__, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|   122k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|   122k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  665|   122k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (665:10): [Folded, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  808|   122k|	R_GenHeap[__cls__].OldCount[__gen__]++;			\
  |  |  |  |  809|   122k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (809:14): [Folded, False: 122k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1716|   122k|	FORWARD_CHILDREN(s); \
  |  |  ------------------
  |  |  |  |  829|   122k|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |  710|   122k|#define DO_CHILDREN4(__n__,dc__action__,dc__str__action__,dc__extra__) do { \
  |  |  |  |  |  |  711|   122k|  if (HAS_GENUINE_ATTRIB(__n__)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  696|   122k|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|   122k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  142|   245k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  230|   122k|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (696:6): [True: 122k, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (696:30): [True: 0, False: 122k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  697|   122k|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (697:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  712|   122k|    dc__action__(ATTRIB(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|   122k|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  713|   122k|  if (ALTREP(__n__)) {					\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  242|   122k|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (242:25): [True: 0, False: 122k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  714|      0|	  dc__action__(TAG(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  715|      0|	  dc__action__(CAR(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  716|      0|	  dc__action__(CDR(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  717|      0|      }							\
  |  |  |  |  |  |  718|   122k|  else \
  |  |  |  |  |  |  719|   122k|  switch (TYPEOF(__n__)) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|   122k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  720|      0|  case NILSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (720:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  721|      0|  case BUILTINSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (721:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  722|      0|  case SPECIALSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (722:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  723|      0|  case CHARSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (723:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  724|      0|  case LGLSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (724:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  725|      0|  case INTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (725:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  726|      0|  case REALSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  727|      0|  case CPLXSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (727:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  728|      0|  case WEAKREFSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  135|      0|#define WEAKREFSXP  23    /* weak reference */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (728:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  729|   122k|  case RAWSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  136|   122k|#define RAWSXP      24    /* raw bytes */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (729:3): [True: 122k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  730|   122k|  case OBJSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  137|   122k|#define OBJSXP      25    /* object, non-vector  */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (730:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  731|   122k|    break; \
  |  |  |  |  |  |  732|   122k|  case STRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (732:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  733|      0|    { \
  |  |  |  |  |  |  734|      0|      R_xlen_t i; \
  |  |  |  |  |  |  735|      0|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (735:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  736|      0|	dc__str__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  826|      0|#define FC_PROCESS_CHARSXP(__n__,__dummy__) PROCESS_CHARSXP(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  825|      0|#define PROCESS_CHARSXP(__n__) FORWARD_AND_PROCESS_ONE_NODE(__n__, CHARSXP)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  812|      0|#define FORWARD_AND_PROCESS_ONE_NODE(s, tp) do {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  813|      0|	SEXP fpn__n__ = (s);				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  814|      0|	int __tp__ = (tp);				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  815|      0|	if (fpn__n__ && ! NODE_IS_MARKED(fpn__n__)) {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (815:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (815:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  816|      0|	    if (TYPEOF(fpn__n__) == __tp__ &&		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (816:10): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  817|      0|		! HAS_GENUINE_ATTRIB(fpn__n__)) {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  696|      0|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  230|      0|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (696:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (696:30): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  697|      0|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (697:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  818|      0|		MARK_AND_UNSNAP_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  819|      0|		PROCESS_ONE_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  803|      0|#define PROCESS_ONE_NODE(s) do {				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  804|      0|	SEXP pn__n__ = (s);					\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  805|      0|	int __cls__ = NODE_CLASS(pn__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  806|      0|	int __gen__ = NODE_GENERATION(pn__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  807|      0|	SNAP_NODE(pn__n__, R_GenHeap[__cls__].Old[__gen__]);	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  657|      0|#define SNAP_NODE(s,t) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  658|      0|  SEXP sn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  659|      0|  SEXP next = (t); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  660|      0|  SEXP prev = PREV_NODE(next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  661|      0|  SET_NEXT_NODE(sn__n__, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  662|      0|  SET_PREV_NODE(next, sn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  663|      0|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  664|      0|  SET_PREV_NODE(sn__n__, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  665|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (665:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  808|      0|	R_GenHeap[__cls__].OldCount[__gen__]++;			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  809|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (809:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  820|      0|	    }						\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  821|      0|	    else FORWARD_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  822|      0|	}						\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  823|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (823:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  737|      0|    } \
  |  |  |  |  |  |  738|      0|    break; \
  |  |  |  |  |  |  739|   122k|  case EXPRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (739:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  740|      0|  case VECSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (740:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  741|      0|    { \
  |  |  |  |  |  |  742|      0|      R_xlen_t i; \
  |  |  |  |  |  |  743|      0|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (743:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  744|      0|	dc__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  745|      0|    } \
  |  |  |  |  |  |  746|      0|    break; \
  |  |  |  |  |  |  747|      0|  case ENVSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (747:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  748|      0|    dc__action__(FRAME(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  749|      0|    dc__action__(ENCLOS(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  750|      0|    dc__action__(HASHTAB(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  751|      0|    break; \
  |  |  |  |  |  |  752|      0|  case LISTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (752:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  753|      0|  case PROMSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (753:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  754|      0|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  755|      0|    if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   37|      0|# define BOXED_BINDING_CELLS 0
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (37:30): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  463|      0|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (755:32): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  756|      0|      dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  757|      0|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  758|      0|    break; \
  |  |  |  |  |  |  759|      0|  case CLOSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (759:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  760|      0|  case LANGSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (760:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  761|      0|  case DOTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (761:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  762|      0|  case SYMSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (762:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  763|      0|  case BCODESXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  133|      0|#define BCODESXP    21    /* byte code */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (763:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  764|      0|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  765|      0|    dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  766|      0|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  767|      0|    break; \
  |  |  |  |  |  |  768|      0|  case EXTPTRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  134|      0|#define EXTPTRSXP   22    /* external pointer */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (768:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  769|      0|    dc__action__(EXTPTR_PROT(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  770|      0|    dc__action__(EXTPTR_TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  771|      0|    break; \
  |  |  |  |  |  |  772|      0|  FREE_FORWARD_CASE \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  705|      0|#define FREE_FORWARD_CASE case FREESXP: if (gc_inhibit_release) break;
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (705:27): [True: 0, False: 122k]
  |  |  |  |  |  |  |  |  |  Branch (705:45): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  773|      0|  default: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (773:3): [True: 0, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  774|      0|    register_bad_sexp_type(__n__, __LINE__);		\
  |  |  |  |  |  |  775|   122k|  } \
  |  |  |  |  |  |  776|   122k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (776:9): [Folded, False: 122k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1717|   122k|    } \
  |  | 1718|    636|} while (0)
  |  |  ------------------
  |  |  |  Branch (1718:10): [Folded, False: 636]
  |  |  ------------------
  ------------------
 1900|    636|	} while (recheck_weak_refs);
  ------------------
  |  Branch (1900:11): [True: 318, False: 318]
  ------------------
 1901|    318|    }
 1902|       |
 1903|       |    /* mark nodes ready for finalizing */
 1904|    318|    CheckFinalizers();
 1905|       |
 1906|       |    /* process the weak reference chain */
 1907|   370k|    for (s = R_weak_refs; s != R_NilValue; s = WEAKREF_NEXT(s)) {
  ------------------
  |  | 1420|   370k|#define WEAKREF_NEXT(w) VECTOR_ELT_0(w, 3)
  |  |  ------------------
  |  |  |  |   80|   370k|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  |  |  ------------------
  |  |  |  |  |  |  420|   370k|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1907:27): [True: 370k, False: 318]
  ------------------
 1908|   370k|	FORWARD_NODE(s);
  ------------------
  |  |  794|   370k|#define FORWARD_NODE(s) do { \
  |  |  795|   370k|  SEXP fn__n__ = (s); \
  |  |  796|   370k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|   370k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|   370k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 370k, False: 0]
  |  |  |  Branch (796:18): [True: 123k, False: 247k]
  |  |  ------------------
  |  |  797|   123k|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|   123k|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|   123k|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|   123k|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|   123k|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|   123k|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|   123k|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|   123k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|   246k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 123k]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|   123k|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|   123k|}
  |  |  |  |  ------------------
  |  |  |  |  790|   123k|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|   123k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|   123k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|   123k|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|   123k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|   123k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|   123k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|   123k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|   123k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|   123k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|   123k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|   123k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|   123k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|   123k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|   123k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|   123k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|   123k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|   123k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 123k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|   123k|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|   123k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|   123k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|   123k|    forwarded_nodes = fn__n__; \
  |  |  800|   123k|  } \
  |  |  801|   370k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 370k]
  |  |  ------------------
  ------------------
 1909|   370k|	FORWARD_NODE(WEAKREF_KEY(s));
  ------------------
  |  |  794|   370k|#define FORWARD_NODE(s) do { \
  |  |  795|   370k|  SEXP fn__n__ = (s); \
  |  |  796|   370k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|   370k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|   370k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 370k, False: 0]
  |  |  |  Branch (796:18): [True: 65, False: 370k]
  |  |  ------------------
  |  |  797|     65|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|     65|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|     65|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|     65|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|     65|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|     65|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|     65|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|     65|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    130|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 65]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|     65|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|     65|}
  |  |  |  |  ------------------
  |  |  |  |  790|     65|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|     65|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|     65|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|     65|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|     65|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|     65|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|     65|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|     65|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|     65|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|     65|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|     65|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|     65|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|     65|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|     65|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|     65|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|     65|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|     65|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 65]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|     65|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 65]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|     65|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|     65|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|     65|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|     65|    forwarded_nodes = fn__n__; \
  |  |  800|     65|  } \
  |  |  801|   370k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 370k]
  |  |  ------------------
  ------------------
 1910|   370k|	FORWARD_NODE(WEAKREF_VALUE(s));
  ------------------
  |  |  794|   370k|#define FORWARD_NODE(s) do { \
  |  |  795|   370k|  SEXP fn__n__ = (s); \
  |  |  796|   370k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|   370k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|   370k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 370k, False: 0]
  |  |  |  Branch (796:18): [True: 0, False: 370k]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|   370k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 370k]
  |  |  ------------------
  ------------------
 1911|   370k|	FORWARD_NODE(WEAKREF_FINALIZER(s));
  ------------------
  |  |  794|   370k|#define FORWARD_NODE(s) do { \
  |  |  795|   370k|  SEXP fn__n__ = (s); \
  |  |  796|   370k|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|   370k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|   370k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 370k, False: 0]
  |  |  |  Branch (796:18): [True: 63, False: 370k]
  |  |  ------------------
  |  |  797|     63|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|     63|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|     63|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|     63|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|     63|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|     63|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|     63|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|     63|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    126|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 63]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|     63|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|     63|}
  |  |  |  |  ------------------
  |  |  |  |  790|     63|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|     63|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|     63|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|     63|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|     63|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|     63|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|     63|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|     63|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|     63|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|     63|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|     63|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|     63|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|     63|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|     63|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|     63|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|     63|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|     63|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 63]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|     63|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 63]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|     63|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|     63|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|     63|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|     63|    forwarded_nodes = fn__n__; \
  |  |  800|     63|  } \
  |  |  801|   370k|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 370k]
  |  |  ------------------
  ------------------
 1912|   370k|    }
 1913|    318|    PROCESS_NODES();
  ------------------
  |  | 1711|    318|#define PROCESS_NODES() do { \
  |  | 1712|   123k|    while (forwarded_nodes != NULL) { \
  |  |  ------------------
  |  |  |  Branch (1712:12): [True: 123k, False: 318]
  |  |  ------------------
  |  | 1713|   123k|	SEXP s = forwarded_nodes; \
  |  | 1714|   123k|	forwarded_nodes = NEXT_NODE(forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  639|   123k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  |  | 1715|   123k|	PROCESS_ONE_NODE(s); \
  |  |  ------------------
  |  |  |  |  803|   123k|#define PROCESS_ONE_NODE(s) do {				\
  |  |  |  |  804|   123k|	SEXP pn__n__ = (s);					\
  |  |  |  |  805|   123k|	int __cls__ = NODE_CLASS(pn__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  545|   123k|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  ------------------
  |  |  |  |  806|   123k|	int __gen__ = NODE_GENERATION(pn__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|   123k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  807|   123k|	SNAP_NODE(pn__n__, R_GenHeap[__cls__].Old[__gen__]);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  657|   123k|#define SNAP_NODE(s,t) do { \
  |  |  |  |  |  |  658|   123k|  SEXP sn__n__ = (s); \
  |  |  |  |  |  |  659|   123k|  SEXP next = (t); \
  |  |  |  |  |  |  660|   123k|  SEXP prev = PREV_NODE(next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|   123k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  661|   123k|  SET_NEXT_NODE(sn__n__, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|   123k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|   123k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  662|   123k|  SET_PREV_NODE(next, sn__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|   123k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|   123k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  663|   123k|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|   123k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|   123k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  664|   123k|  SET_PREV_NODE(sn__n__, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|   123k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|   123k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  665|   123k|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (665:10): [Folded, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  808|   123k|	R_GenHeap[__cls__].OldCount[__gen__]++;			\
  |  |  |  |  809|   123k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (809:14): [Folded, False: 123k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1716|   123k|	FORWARD_CHILDREN(s); \
  |  |  ------------------
  |  |  |  |  829|   123k|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |  710|   123k|#define DO_CHILDREN4(__n__,dc__action__,dc__str__action__,dc__extra__) do { \
  |  |  |  |  |  |  711|   123k|  if (HAS_GENUINE_ATTRIB(__n__)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  696|   123k|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|   123k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  142|   246k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  230|   123k|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (696:6): [True: 123k, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (696:30): [True: 2, False: 123k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  697|   123k|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|      2|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  120|      4|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (697:7): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  712|   123k|    dc__action__(ATTRIB(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|   123k|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      2|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      2|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      2|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      2|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      2|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      2|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      2|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      2|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      2|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      2|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      2|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      2|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      2|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      2|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      4|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      2|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      2|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      2|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      2|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      2|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      2|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      2|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      2|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      2|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      2|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      2|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      2|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      2|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      2|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      2|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      2|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      2|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      2|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      2|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      2|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      2|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      2|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      2|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      2|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      2|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      2|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  713|   123k|  if (ALTREP(__n__)) {					\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  242|   123k|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (242:25): [True: 0, False: 123k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  714|      0|	  dc__action__(TAG(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  715|      0|	  dc__action__(CAR(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  716|      0|	  dc__action__(CDR(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  717|      0|      }							\
  |  |  |  |  |  |  718|   123k|  else \
  |  |  |  |  |  |  719|   123k|  switch (TYPEOF(__n__)) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|   123k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  720|      0|  case NILSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (720:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  721|      0|  case BUILTINSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (721:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  722|      0|  case SPECIALSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (722:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  723|      0|  case CHARSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (723:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  724|      0|  case LGLSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (724:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  725|      0|  case INTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (725:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  726|      0|  case REALSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  727|      0|  case CPLXSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (727:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  728|   123k|  case WEAKREFSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  135|   123k|#define WEAKREFSXP  23    /* weak reference */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (728:3): [True: 123k, False: 132]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  729|   123k|  case RAWSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  136|   123k|#define RAWSXP      24    /* raw bytes */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (729:3): [True: 63, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  730|   123k|  case OBJSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  137|   123k|#define OBJSXP      25    /* object, non-vector  */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (730:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  731|   123k|    break; \
  |  |  |  |  |  |  732|   123k|  case STRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  126|      2|#define STRSXP	    16	  /* string vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (732:3): [True: 2, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  733|      2|    { \
  |  |  |  |  |  |  734|      2|      R_xlen_t i; \
  |  |  |  |  |  |  735|      4|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  407|      4|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (735:19): [True: 2, False: 2]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  736|      2|	dc__str__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      2|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  826|      2|#define FC_PROCESS_CHARSXP(__n__,__dummy__) PROCESS_CHARSXP(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  825|      2|#define PROCESS_CHARSXP(__n__) FORWARD_AND_PROCESS_ONE_NODE(__n__, CHARSXP)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  812|      4|#define FORWARD_AND_PROCESS_ONE_NODE(s, tp) do {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  813|      2|	SEXP fpn__n__ = (s);				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  814|      2|	int __tp__ = (tp);				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  815|      2|	if (fpn__n__ && ! NODE_IS_MARKED(fpn__n__)) {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      2|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      2|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (815:6): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (815:18): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  816|      0|	    if (TYPEOF(fpn__n__) == __tp__ &&		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (816:10): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  817|      0|		! HAS_GENUINE_ATTRIB(fpn__n__)) {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  696|      0|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  230|      0|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (696:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (696:30): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  697|      0|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (697:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  818|      0|		MARK_AND_UNSNAP_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  819|      0|		PROCESS_ONE_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  803|      0|#define PROCESS_ONE_NODE(s) do {				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  804|      0|	SEXP pn__n__ = (s);					\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  805|      0|	int __cls__ = NODE_CLASS(pn__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  806|      0|	int __gen__ = NODE_GENERATION(pn__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  807|      0|	SNAP_NODE(pn__n__, R_GenHeap[__cls__].Old[__gen__]);	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  657|      0|#define SNAP_NODE(s,t) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  658|      0|  SEXP sn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  659|      0|  SEXP next = (t); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  660|      0|  SEXP prev = PREV_NODE(next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  661|      0|  SET_NEXT_NODE(sn__n__, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  662|      0|  SET_PREV_NODE(next, sn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  663|      0|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  664|      0|  SET_PREV_NODE(sn__n__, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  665|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (665:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  808|      0|	R_GenHeap[__cls__].OldCount[__gen__]++;			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  809|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (809:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  820|      0|	    }						\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  821|      0|	    else FORWARD_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  822|      0|	}						\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  823|      2|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (823:14): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  737|      2|    } \
  |  |  |  |  |  |  738|      2|    break; \
  |  |  |  |  |  |  739|   123k|  case EXPRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (739:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  740|      0|  case VECSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (740:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  741|      0|    { \
  |  |  |  |  |  |  742|      0|      R_xlen_t i; \
  |  |  |  |  |  |  743|      0|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (743:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  744|      0|	dc__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  745|      0|    } \
  |  |  |  |  |  |  746|      0|    break; \
  |  |  |  |  |  |  747|      0|  case ENVSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (747:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  748|      0|    dc__action__(FRAME(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  749|      0|    dc__action__(ENCLOS(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  750|      0|    dc__action__(HASHTAB(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  751|      0|    break; \
  |  |  |  |  |  |  752|      2|  case LISTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|      2|#define LISTSXP	     2	  /* lists of dotted pairs */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (752:3): [True: 2, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  753|      2|  case PROMSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  116|      2|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (753:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  754|      2|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      2|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      2|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      2|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      2|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      2|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      2|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      2|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      2|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  755|      2|    if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   37|      4|# define BOXED_BINDING_CELLS 0
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (37:30): [Folded, False: 2]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  463|      2|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (755:32): [True: 2, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  756|      2|      dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      2|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      2|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      2|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      2|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      2|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      2|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      2|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      2|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      2|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      2|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      2|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      2|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      2|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      2|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      2|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      4|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      2|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      2|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      2|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      2|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      2|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      2|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      2|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      2|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      2|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      2|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      2|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      2|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      2|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      2|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      2|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      2|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      2|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      2|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      2|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      2|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      2|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      2|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      2|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      2|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      2|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      2|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  757|      2|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      2|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      2|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      2|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      2|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      2|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      2|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      2|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 2, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      2|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 2]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  758|      2|    break; \
  |  |  |  |  |  |  759|      2|  case CLOSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (759:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  760|      0|  case LANGSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (760:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  761|      0|  case DOTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (761:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  762|      0|  case SYMSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (762:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  763|      0|  case BCODESXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  133|      0|#define BCODESXP    21    /* byte code */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (763:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  764|      0|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  765|      0|    dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  766|      0|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  767|      0|    break; \
  |  |  |  |  |  |  768|     65|  case EXTPTRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  134|     65|#define EXTPTRSXP   22    /* external pointer */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (768:3): [True: 65, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  769|     65|    dc__action__(EXTPTR_PROT(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|     65|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|     65|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|     65|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|     65|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|     65|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|     65|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|     65|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 65, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 65]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|     65|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 65]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  770|     65|    dc__action__(EXTPTR_TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|     65|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|     65|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|     65|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|     65|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|     65|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|     65|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|     65|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 65, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 65]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|     65|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 65]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  771|     65|    break; \
  |  |  |  |  |  |  772|      0|  FREE_FORWARD_CASE \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  705|      0|#define FREE_FORWARD_CASE case FREESXP: if (gc_inhibit_release) break;
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (705:27): [True: 0, False: 123k]
  |  |  |  |  |  |  |  |  |  Branch (705:45): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  773|      0|  default: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (773:3): [True: 0, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  774|      0|    register_bad_sexp_type(__n__, __LINE__);		\
  |  |  |  |  |  |  775|   123k|  } \
  |  |  |  |  |  |  776|   123k|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (776:9): [Folded, False: 123k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1717|   123k|    } \
  |  | 1718|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (1718:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1914|       |
 1915|    318|    DEBUG_CHECK_NODE_COUNTS("after processing forwarded list");
 1916|       |
 1917|       |    /* process CHARSXP cache */
 1918|    318|    if (R_StringHash != NULL) /* in case of GC during initialization */
  ------------------
  |  Branch (1918:9): [True: 318, False: 0]
  ------------------
 1919|    318|    {
 1920|    318|	SEXP t;
 1921|    318|	int nc = 0;
 1922|  20.8M|	for (i = 0; i < LENGTH(R_StringHash); i++) {
  ------------------
  |  |  403|  20.8M|#define LENGTH(x) LENGTH_EX(x, __FILE__, __LINE__)
  ------------------
  |  Branch (1922:14): [True: 20.8M, False: 318]
  ------------------
 1923|  20.8M|	    s = VECTOR_ELT_0(R_StringHash, i);
  ------------------
  |  |   80|  20.8M|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  ------------------
  |  |  |  |  420|  20.8M|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  ------------------
  ------------------
 1924|  20.8M|	    t = R_NilValue;
 1925|  23.4M|	    while (s != R_NilValue) {
  ------------------
  |  Branch (1925:13): [True: 2.65M, False: 20.8M]
  ------------------
 1926|  2.65M|		if (! NODE_IS_MARKED(CXHEAD(s))) { /* remove unused CHARSXP and cons cell */
  ------------------
  |  |  268|  2.65M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  ------------------
  |  |  |  |  232|  2.65M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  ------------------
  ------------------
  |  Branch (1926:7): [True: 19.0k, False: 2.63M]
  ------------------
 1927|  19.0k|		    if (t == R_NilValue) /* head of list */
  ------------------
  |  Branch (1927:11): [True: 19.0k, False: 32]
  ------------------
 1928|  19.0k|			VECTOR_ELT_0(R_StringHash, i) = CXTAIL(s);
  ------------------
  |  |   80|  19.0k|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  ------------------
  |  |  |  |  420|  19.0k|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  ------------------
  ------------------
              			VECTOR_ELT_0(R_StringHash, i) = CXTAIL(s);
  ------------------
  |  |  972|  19.0k|# define CXTAIL(x) ATTRIB(x)
  |  |  ------------------
  |  |  |  |  230|  19.0k|#define ATTRIB(x)	((x)->attrib)
  |  |  ------------------
  ------------------
 1929|     32|		    else
 1930|     32|			CXTAIL(t) = CXTAIL(s);
  ------------------
  |  |  972|     32|# define CXTAIL(x) ATTRIB(x)
  |  |  ------------------
  |  |  |  |  230|     32|#define ATTRIB(x)	((x)->attrib)
  |  |  ------------------
  ------------------
              			CXTAIL(t) = CXTAIL(s);
  ------------------
  |  |  972|     32|# define CXTAIL(x) ATTRIB(x)
  |  |  ------------------
  |  |  |  |  230|     32|#define ATTRIB(x)	((x)->attrib)
  |  |  ------------------
  ------------------
 1931|  19.0k|		    s = CXTAIL(s);
  ------------------
  |  |  972|  19.0k|# define CXTAIL(x) ATTRIB(x)
  |  |  ------------------
  |  |  |  |  230|  19.0k|#define ATTRIB(x)	((x)->attrib)
  |  |  ------------------
  ------------------
 1932|  19.0k|		    continue;
 1933|  19.0k|		}
 1934|  2.63M|		FORWARD_NODE(s);
  ------------------
  |  |  794|  2.63M|#define FORWARD_NODE(s) do { \
  |  |  795|  2.63M|  SEXP fn__n__ = (s); \
  |  |  796|  2.63M|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  2.63M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  2.63M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 2.63M, False: 0]
  |  |  |  Branch (796:18): [True: 0, False: 2.63M]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|  2.63M|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 2.63M]
  |  |  ------------------
  ------------------
 1935|  2.63M|		FORWARD_NODE(CXHEAD(s));
  ------------------
  |  |  794|  2.63M|#define FORWARD_NODE(s) do { \
  |  |  795|  2.63M|  SEXP fn__n__ = (s); \
  |  |  796|  2.63M|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|  2.63M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  2.63M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 2.63M, False: 0]
  |  |  |  Branch (796:18): [True: 0, False: 2.63M]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|  2.63M|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 2.63M]
  |  |  ------------------
  ------------------
 1936|  2.63M|		t = s;
 1937|  2.63M|		s = CXTAIL(s);
  ------------------
  |  |  972|  2.63M|# define CXTAIL(x) ATTRIB(x)
  |  |  ------------------
  |  |  |  |  230|  2.63M|#define ATTRIB(x)	((x)->attrib)
  |  |  ------------------
  ------------------
 1938|  2.63M|	    }
 1939|  20.8M|	    if(VECTOR_ELT_0(R_StringHash, i) != R_NilValue) nc++;
  ------------------
  |  |   80|  20.8M|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  ------------------
  |  |  |  |  420|  20.8M|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  ------------------
  ------------------
  |  Branch (1939:9): [True: 2.48M, False: 18.3M]
  ------------------
 1940|  20.8M|	}
 1941|    318|	SET_TRUELENGTH(R_StringHash, nc); /* SET_HASHPRI, really */
  ------------------
  |  |  395|    318|#define SET_TRUELENGTH(x,v) do {				\
  |  |  396|    318|	SEXP sl__x__ = (x);					\
  |  |  397|    318|	R_xlen_t sl__v__ = (v);					\
  |  |  398|    318|	if (ALTREP(x)) error("can't set ALTREP truelength");	\
  |  |  ------------------
  |  |  |  |  242|    318|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (242:25): [True: 0, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               	if (ALTREP(x)) error("can't set ALTREP truelength");	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  399|    318|	SET_STDVEC_TRUELENGTH(sl__x__, sl__v__);	\
  |  |  ------------------
  |  |  |  |  394|    318|#define SET_STDVEC_TRUELENGTH(x, v) (STDVEC_TRUELENGTH(x)=(v))
  |  |  |  |  ------------------
  |  |  |  |  |  |  393|    318|#define STDVEC_TRUELENGTH(x) (((VECSEXP) (x))->vecsxp.truelength)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  400|    318|    } while (0)
  |  |  ------------------
  |  |  |  Branch (400:14): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1942|    318|    }
 1943|       |    /* chains are known to be marked so don't need to scan again */
 1944|    318|    FORWARD_AND_PROCESS_ONE_NODE(R_StringHash, VECSXP);
  ------------------
  |  |  812|    318|#define FORWARD_AND_PROCESS_ONE_NODE(s, tp) do {	\
  |  |  813|    318|	SEXP fpn__n__ = (s);				\
  |  |  814|    318|	int __tp__ = (tp);				\
  |  |  815|    318|	if (fpn__n__ && ! NODE_IS_MARKED(fpn__n__)) {	\
  |  |  ------------------
  |  |  |  |  268|    318|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (815:6): [True: 318, False: 0]
  |  |  |  Branch (815:18): [True: 318, False: 0]
  |  |  ------------------
  |  |  816|    318|	    if (TYPEOF(fpn__n__) == __tp__ &&		\
  |  |  ------------------
  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  ------------------
  |  |  |  Branch (816:10): [True: 318, False: 0]
  |  |  ------------------
  |  |  817|    318|		! HAS_GENUINE_ATTRIB(fpn__n__)) {	\
  |  |  ------------------
  |  |  |  |  696|    318|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  ------------------
  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  ------------------
  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  ------------------
  |  |  |  |  |  |  230|    318|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (696:6): [True: 318, False: 0]
  |  |  |  |  |  Branch (696:30): [True: 0, False: 318]
  |  |  |  |  ------------------
  |  |  |  |  697|    318|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  ------------------
  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  ------------------
  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  ------------------
  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  ------------------
  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  ------------------
  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  ------------------
  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  ------------------
  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (697:7): [True: 0, False: 0]
  |  |  |  |  |  Branch (697:31): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  818|    318|		MARK_AND_UNSNAP_NODE(fpn__n__);		\
  |  |  ------------------
  |  |  |  |  787|    318|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|    318|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|    318|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|    318|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|    318|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|    318|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|    318|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|    636|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 318]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|    318|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|    318|}
  |  |  |  |  ------------------
  |  |  |  |  790|    318|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|    318|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|    318|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|    318|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|    318|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|    318|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|    318|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|    318|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|    318|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|    318|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|    318|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  819|    318|		PROCESS_ONE_NODE(fpn__n__);		\
  |  |  ------------------
  |  |  |  |  803|    318|#define PROCESS_ONE_NODE(s) do {				\
  |  |  |  |  804|    318|	SEXP pn__n__ = (s);					\
  |  |  |  |  805|    318|	int __cls__ = NODE_CLASS(pn__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  545|    318|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  ------------------
  |  |  |  |  806|    318|	int __gen__ = NODE_GENERATION(pn__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|    318|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  807|    318|	SNAP_NODE(pn__n__, R_GenHeap[__cls__].Old[__gen__]);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  657|    318|#define SNAP_NODE(s,t) do { \
  |  |  |  |  |  |  658|    318|  SEXP sn__n__ = (s); \
  |  |  |  |  |  |  659|    318|  SEXP next = (t); \
  |  |  |  |  |  |  660|    318|  SEXP prev = PREV_NODE(next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  661|    318|  SET_NEXT_NODE(sn__n__, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  662|    318|  SET_PREV_NODE(next, sn__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  663|    318|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|    318|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|    318|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  664|    318|  SET_PREV_NODE(sn__n__, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|    318|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|    318|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  665|    318|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (665:10): [Folded, False: 318]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  808|    318|	R_GenHeap[__cls__].OldCount[__gen__]++;			\
  |  |  |  |  809|    318|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (809:14): [Folded, False: 318]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  820|    318|	    }						\
  |  |  821|    318|	    else FORWARD_NODE(fpn__n__);		\
  |  |  ------------------
  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  800|      0|  } \
  |  |  |  |  801|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  822|    318|	}						\
  |  |  823|    318|    } while (0)
  |  |  ------------------
  |  |  |  Branch (823:14): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1945|    318|    PROCESS_NODES(); /* probably nothing to process, but just in case ... */
  ------------------
  |  | 1711|    318|#define PROCESS_NODES() do { \
  |  | 1712|    318|    while (forwarded_nodes != NULL) { \
  |  |  ------------------
  |  |  |  Branch (1712:12): [True: 0, False: 318]
  |  |  ------------------
  |  | 1713|      0|	SEXP s = forwarded_nodes; \
  |  | 1714|      0|	forwarded_nodes = NEXT_NODE(forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  |  | 1715|      0|	PROCESS_ONE_NODE(s); \
  |  |  ------------------
  |  |  |  |  803|      0|#define PROCESS_ONE_NODE(s) do {				\
  |  |  |  |  804|      0|	SEXP pn__n__ = (s);					\
  |  |  |  |  805|      0|	int __cls__ = NODE_CLASS(pn__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  ------------------
  |  |  |  |  806|      0|	int __gen__ = NODE_GENERATION(pn__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  807|      0|	SNAP_NODE(pn__n__, R_GenHeap[__cls__].Old[__gen__]);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  657|      0|#define SNAP_NODE(s,t) do { \
  |  |  |  |  |  |  658|      0|  SEXP sn__n__ = (s); \
  |  |  |  |  |  |  659|      0|  SEXP next = (t); \
  |  |  |  |  |  |  660|      0|  SEXP prev = PREV_NODE(next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  661|      0|  SET_NEXT_NODE(sn__n__, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  662|      0|  SET_PREV_NODE(next, sn__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  663|      0|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  664|      0|  SET_PREV_NODE(sn__n__, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  665|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (665:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  808|      0|	R_GenHeap[__cls__].OldCount[__gen__]++;			\
  |  |  |  |  809|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (809:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1716|      0|	FORWARD_CHILDREN(s); \
  |  |  ------------------
  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |  710|      0|#define DO_CHILDREN4(__n__,dc__action__,dc__str__action__,dc__extra__) do { \
  |  |  |  |  |  |  711|      0|  if (HAS_GENUINE_ATTRIB(__n__)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  696|      0|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  230|      0|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (696:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (696:30): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  697|      0|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (697:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  712|      0|    dc__action__(ATTRIB(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  713|      0|  if (ALTREP(__n__)) {					\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  242|      0|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (242:25): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  714|      0|	  dc__action__(TAG(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  715|      0|	  dc__action__(CAR(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  716|      0|	  dc__action__(CDR(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  717|      0|      }							\
  |  |  |  |  |  |  718|      0|  else \
  |  |  |  |  |  |  719|      0|  switch (TYPEOF(__n__)) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  720|      0|  case NILSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (720:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  721|      0|  case BUILTINSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (721:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  722|      0|  case SPECIALSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (722:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  723|      0|  case CHARSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (723:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  724|      0|  case LGLSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (724:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  725|      0|  case INTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (725:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  726|      0|  case REALSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  727|      0|  case CPLXSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (727:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  728|      0|  case WEAKREFSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  135|      0|#define WEAKREFSXP  23    /* weak reference */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (728:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  729|      0|  case RAWSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (729:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  730|      0|  case OBJSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (730:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  731|      0|    break; \
  |  |  |  |  |  |  732|      0|  case STRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (732:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  733|      0|    { \
  |  |  |  |  |  |  734|      0|      R_xlen_t i; \
  |  |  |  |  |  |  735|      0|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (735:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  736|      0|	dc__str__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  826|      0|#define FC_PROCESS_CHARSXP(__n__,__dummy__) PROCESS_CHARSXP(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  825|      0|#define PROCESS_CHARSXP(__n__) FORWARD_AND_PROCESS_ONE_NODE(__n__, CHARSXP)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  812|      0|#define FORWARD_AND_PROCESS_ONE_NODE(s, tp) do {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  813|      0|	SEXP fpn__n__ = (s);				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  814|      0|	int __tp__ = (tp);				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  815|      0|	if (fpn__n__ && ! NODE_IS_MARKED(fpn__n__)) {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (815:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (815:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  816|      0|	    if (TYPEOF(fpn__n__) == __tp__ &&		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (816:10): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  817|      0|		! HAS_GENUINE_ATTRIB(fpn__n__)) {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  696|      0|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  230|      0|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (696:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (696:30): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  697|      0|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (697:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  818|      0|		MARK_AND_UNSNAP_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  819|      0|		PROCESS_ONE_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  803|      0|#define PROCESS_ONE_NODE(s) do {				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  804|      0|	SEXP pn__n__ = (s);					\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  805|      0|	int __cls__ = NODE_CLASS(pn__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  806|      0|	int __gen__ = NODE_GENERATION(pn__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  807|      0|	SNAP_NODE(pn__n__, R_GenHeap[__cls__].Old[__gen__]);	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  657|      0|#define SNAP_NODE(s,t) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  658|      0|  SEXP sn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  659|      0|  SEXP next = (t); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  660|      0|  SEXP prev = PREV_NODE(next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  661|      0|  SET_NEXT_NODE(sn__n__, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  662|      0|  SET_PREV_NODE(next, sn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  663|      0|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  664|      0|  SET_PREV_NODE(sn__n__, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  665|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (665:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  808|      0|	R_GenHeap[__cls__].OldCount[__gen__]++;			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  809|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (809:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  820|      0|	    }						\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  821|      0|	    else FORWARD_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  822|      0|	}						\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  823|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (823:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  737|      0|    } \
  |  |  |  |  |  |  738|      0|    break; \
  |  |  |  |  |  |  739|      0|  case EXPRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (739:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  740|      0|  case VECSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (740:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  741|      0|    { \
  |  |  |  |  |  |  742|      0|      R_xlen_t i; \
  |  |  |  |  |  |  743|      0|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (743:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  744|      0|	dc__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  745|      0|    } \
  |  |  |  |  |  |  746|      0|    break; \
  |  |  |  |  |  |  747|      0|  case ENVSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (747:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  748|      0|    dc__action__(FRAME(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  749|      0|    dc__action__(ENCLOS(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  750|      0|    dc__action__(HASHTAB(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  751|      0|    break; \
  |  |  |  |  |  |  752|      0|  case LISTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (752:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  753|      0|  case PROMSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (753:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  754|      0|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  755|      0|    if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   37|      0|# define BOXED_BINDING_CELLS 0
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (37:30): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  463|      0|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (755:32): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  756|      0|      dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  757|      0|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  758|      0|    break; \
  |  |  |  |  |  |  759|      0|  case CLOSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (759:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  760|      0|  case LANGSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (760:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  761|      0|  case DOTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (761:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  762|      0|  case SYMSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (762:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  763|      0|  case BCODESXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  133|      0|#define BCODESXP    21    /* byte code */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (763:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  764|      0|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  765|      0|    dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  766|      0|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  767|      0|    break; \
  |  |  |  |  |  |  768|      0|  case EXTPTRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  134|      0|#define EXTPTRSXP   22    /* external pointer */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (768:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  769|      0|    dc__action__(EXTPTR_PROT(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  770|      0|    dc__action__(EXTPTR_TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  771|      0|    break; \
  |  |  |  |  |  |  772|      0|  FREE_FORWARD_CASE \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  705|      0|#define FREE_FORWARD_CASE case FREESXP: if (gc_inhibit_release) break;
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (705:27): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (705:45): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  773|      0|  default: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (773:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  774|      0|    register_bad_sexp_type(__n__, __LINE__);		\
  |  |  |  |  |  |  775|      0|  } \
  |  |  |  |  |  |  776|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (776:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1717|      0|    } \
  |  | 1718|    318|} while (0)
  |  |  ------------------
  |  |  |  Branch (1718:10): [Folded, False: 318]
  |  |  ------------------
  ------------------
 1946|       |
 1947|    318|#ifdef PROTECTCHECK
 1948|  2.22k|    for(i=0; i< NUM_SMALL_NODE_CLASSES;i++){
  ------------------
  |  |  540|  2.22k|#define NUM_SMALL_NODE_CLASSES (NUM_NODE_CLASSES - 2)
  |  |  ------------------
  |  |  |  |  531|  2.22k|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
  |  Branch (1948:14): [True: 1.90k, False: 318]
  ------------------
 1949|  1.90k|	s = NEXT_NODE(R_GenHeap[i].New);
  ------------------
  |  |  639|  1.90k|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1950|   109M|	while (s != R_GenHeap[i].New) {
  ------------------
  |  Branch (1950:9): [True: 109M, False: 1.90k]
  ------------------
 1951|   109M|	    SEXP next = NEXT_NODE(s);
  ------------------
  |  |  639|   109M|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1952|   109M|	    if (TYPEOF(s) != NEWSXP) {
  ------------------
  |  |  233|   109M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
              	    if (TYPEOF(s) != NEWSXP) {
  ------------------
  |  |  141|   109M|#define NEWSXP      30    /* fresh node created in new page */
  ------------------
  |  Branch (1952:10): [True: 109M, False: 50.2k]
  ------------------
 1953|   109M|		if (TYPEOF(s) != FREESXP) {
  ------------------
  |  |  233|   109M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
              		if (TYPEOF(s) != FREESXP) {
  ------------------
  |  |  142|   109M|#define FREESXP     31    /* node released by GC */
  ------------------
  |  Branch (1953:7): [True: 108M, False: 1.34M]
  ------------------
 1954|   108M|		    SETOLDTYPE(s, TYPEOF(s));
  ------------------
  |  |  155|   108M|#define SETOLDTYPE(s, t) SETLEVELS(s, t)
  |  |  ------------------
  |  |  |  |  241|   108M|#define SETLEVELS(x,v)	(((x)->sxpinfo.gp)=((unsigned short)v))
  |  |  ------------------
  ------------------
 1955|   108M|		    SET_TYPEOF(s, FREESXP);
  ------------------
  |  |  238|   108M|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 1956|   108M|		    fill_freed_node(s, i);
 1957|   108M|		}
 1958|   109M|		if (gc_inhibit_release)
  ------------------
  |  Branch (1958:7): [True: 0, False: 109M]
  ------------------
 1959|      0|		    FORWARD_NODE(s);
  ------------------
  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1960|   109M|	    }
 1961|   109M|	    s = next;
 1962|   109M|	}
 1963|  1.90k|    }
 1964|    954|    for (i = CUSTOM_NODE_CLASS; i <= LARGE_NODE_CLASS; i++) {
  ------------------
  |  |  539|    318|#define CUSTOM_NODE_CLASS (NUM_NODE_CLASSES - 2)
  |  |  ------------------
  |  |  |  |  531|    318|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
                  for (i = CUSTOM_NODE_CLASS; i <= LARGE_NODE_CLASS; i++) {
  ------------------
  |  |  538|    954|#define LARGE_NODE_CLASS  (NUM_NODE_CLASSES - 1)
  |  |  ------------------
  |  |  |  |  531|    954|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
  |  Branch (1964:33): [True: 636, False: 318]
  ------------------
 1965|    636|	s = NEXT_NODE(R_GenHeap[i].New);
  ------------------
  |  |  639|    636|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1966|  18.1k|	while (s != R_GenHeap[i].New) {
  ------------------
  |  Branch (1966:9): [True: 17.5k, False: 636]
  ------------------
 1967|  17.5k|	    SEXP next = NEXT_NODE(s);
  ------------------
  |  |  639|  17.5k|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1968|  17.5k|	    if (TYPEOF(s) != NEWSXP) {
  ------------------
  |  |  233|  17.5k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
              	    if (TYPEOF(s) != NEWSXP) {
  ------------------
  |  |  141|  17.5k|#define NEWSXP      30    /* fresh node created in new page */
  ------------------
  |  Branch (1968:10): [True: 17.5k, False: 0]
  ------------------
 1969|  17.5k|		if (TYPEOF(s) != FREESXP) {
  ------------------
  |  |  233|  17.5k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
              		if (TYPEOF(s) != FREESXP) {
  ------------------
  |  |  142|  17.5k|#define FREESXP     31    /* node released by GC */
  ------------------
  |  Branch (1969:7): [True: 17.5k, False: 0]
  ------------------
 1970|       |		    /**** could also leave this alone and restore the old
 1971|       |			  node type in ReleaseLargeFreeVectors before
 1972|       |			  calculating size */
 1973|  17.5k|		    if (1 /* CHAR(s) != NULL*/) {
  ------------------
  |  Branch (1973:11): [True: 17.5k, Folded]
  ------------------
 1974|       |			/* see comment in ReleaseLargeFreeVectors */
 1975|  17.5k|			R_size_t size = getVecSizeInVEC(s);
 1976|  17.5k|			SET_STDVEC_LENGTH(s, size);
  ------------------
  |  |  410|  17.5k|#define SET_STDVEC_LENGTH(x,v) do {		\
  |  |  411|  17.5k|	SEXP __x__ = (x);			\
  |  |  412|  17.5k|	R_xlen_t __v__ = (v);			\
  |  |  413|  17.5k|	STDVEC_LENGTH(__x__) = __v__;		\
  |  |  ------------------
  |  |  |  |  392|  17.5k|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |  414|  17.5k|	SETSCALAR(__x__, __v__ == 1 ? 1 : 0);	\
  |  |  ------------------
  |  |  |  |  244|  35.1k|#define SETSCALAR(x, v) (((x)->sxpinfo.scalar) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (244:51): [True: 0, False: 17.5k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  415|  17.5k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (415:14): [Folded, False: 17.5k]
  |  |  ------------------
  ------------------
 1977|  17.5k|		    }
 1978|  17.5k|		    SETOLDTYPE(s, TYPEOF(s));
  ------------------
  |  |  155|  17.5k|#define SETOLDTYPE(s, t) SETLEVELS(s, t)
  |  |  ------------------
  |  |  |  |  241|  17.5k|#define SETLEVELS(x,v)	(((x)->sxpinfo.gp)=((unsigned short)v))
  |  |  ------------------
  ------------------
 1979|  17.5k|		    SET_TYPEOF(s, FREESXP);
  ------------------
  |  |  238|  17.5k|#define SET_TYPEOF(x,v)	(((x)->sxpinfo.type)=(v))
  ------------------
 1980|  17.5k|		}
 1981|  17.5k|		if (gc_inhibit_release)
  ------------------
  |  Branch (1981:7): [True: 0, False: 17.5k]
  ------------------
 1982|      0|		    FORWARD_NODE(s);
  ------------------
  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  ------------------
  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  ------------------
  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  ------------------
  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  838|      0|}
  |  |  |  |  ------------------
  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  800|      0|  } \
  |  |  801|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1983|  17.5k|	    }
 1984|  17.5k|	    s = next;
 1985|  17.5k|	}
 1986|    636|    }
 1987|    318|    if (gc_inhibit_release)
  ------------------
  |  Branch (1987:9): [True: 0, False: 318]
  ------------------
 1988|      0|	PROCESS_NODES();
  ------------------
  |  | 1711|      0|#define PROCESS_NODES() do { \
  |  | 1712|      0|    while (forwarded_nodes != NULL) { \
  |  |  ------------------
  |  |  |  Branch (1712:12): [True: 0, False: 0]
  |  |  ------------------
  |  | 1713|      0|	SEXP s = forwarded_nodes; \
  |  | 1714|      0|	forwarded_nodes = NEXT_NODE(forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  |  | 1715|      0|	PROCESS_ONE_NODE(s); \
  |  |  ------------------
  |  |  |  |  803|      0|#define PROCESS_ONE_NODE(s) do {				\
  |  |  |  |  804|      0|	SEXP pn__n__ = (s);					\
  |  |  |  |  805|      0|	int __cls__ = NODE_CLASS(pn__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  ------------------
  |  |  |  |  806|      0|	int __gen__ = NODE_GENERATION(pn__n__);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  807|      0|	SNAP_NODE(pn__n__, R_GenHeap[__cls__].Old[__gen__]);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  657|      0|#define SNAP_NODE(s,t) do { \
  |  |  |  |  |  |  658|      0|  SEXP sn__n__ = (s); \
  |  |  |  |  |  |  659|      0|  SEXP next = (t); \
  |  |  |  |  |  |  660|      0|  SEXP prev = PREV_NODE(next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  661|      0|  SET_NEXT_NODE(sn__n__, next); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  662|      0|  SET_PREV_NODE(next, sn__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  663|      0|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  664|      0|  SET_PREV_NODE(sn__n__, prev); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  665|      0|} while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (665:10): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  808|      0|	R_GenHeap[__cls__].OldCount[__gen__]++;			\
  |  |  |  |  809|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (809:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1716|      0|	FORWARD_CHILDREN(s); \
  |  |  ------------------
  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  ------------------
  |  |  |  |  |  |  710|      0|#define DO_CHILDREN4(__n__,dc__action__,dc__str__action__,dc__extra__) do { \
  |  |  |  |  |  |  711|      0|  if (HAS_GENUINE_ATTRIB(__n__)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  696|      0|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  230|      0|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (696:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (696:30): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  697|      0|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (697:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  712|      0|    dc__action__(ATTRIB(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  713|      0|  if (ALTREP(__n__)) {					\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  242|      0|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (242:25): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  714|      0|	  dc__action__(TAG(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  715|      0|	  dc__action__(CAR(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  716|      0|	  dc__action__(CDR(__n__), dc__extra__);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  717|      0|      }							\
  |  |  |  |  |  |  718|      0|  else \
  |  |  |  |  |  |  719|      0|  switch (TYPEOF(__n__)) { \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  720|      0|  case NILSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (720:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  721|      0|  case BUILTINSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (721:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  722|      0|  case SPECIALSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (722:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  723|      0|  case CHARSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (723:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  724|      0|  case LGLSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (724:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  725|      0|  case INTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (725:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  726|      0|  case REALSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (726:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  727|      0|  case CPLXSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (727:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  728|      0|  case WEAKREFSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  135|      0|#define WEAKREFSXP  23    /* weak reference */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (728:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  729|      0|  case RAWSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (729:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  730|      0|  case OBJSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (730:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  731|      0|    break; \
  |  |  |  |  |  |  732|      0|  case STRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (732:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  733|      0|    { \
  |  |  |  |  |  |  734|      0|      R_xlen_t i; \
  |  |  |  |  |  |  735|      0|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (735:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  736|      0|	dc__str__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  826|      0|#define FC_PROCESS_CHARSXP(__n__,__dummy__) PROCESS_CHARSXP(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  825|      0|#define PROCESS_CHARSXP(__n__) FORWARD_AND_PROCESS_ONE_NODE(__n__, CHARSXP)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  812|      0|#define FORWARD_AND_PROCESS_ONE_NODE(s, tp) do {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  813|      0|	SEXP fpn__n__ = (s);				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  814|      0|	int __tp__ = (tp);				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  815|      0|	if (fpn__n__ && ! NODE_IS_MARKED(fpn__n__)) {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (815:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (815:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  816|      0|	    if (TYPEOF(fpn__n__) == __tp__ &&		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (816:10): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  817|      0|		! HAS_GENUINE_ATTRIB(fpn__n__)) {	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  696|      0|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  230|      0|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (696:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (696:30): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  697|      0|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (697:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  818|      0|		MARK_AND_UNSNAP_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  819|      0|		PROCESS_ONE_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  803|      0|#define PROCESS_ONE_NODE(s) do {				\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  804|      0|	SEXP pn__n__ = (s);					\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  805|      0|	int __cls__ = NODE_CLASS(pn__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  806|      0|	int __gen__ = NODE_GENERATION(pn__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  807|      0|	SNAP_NODE(pn__n__, R_GenHeap[__cls__].Old[__gen__]);	\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  657|      0|#define SNAP_NODE(s,t) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  658|      0|  SEXP sn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  659|      0|  SEXP next = (t); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  660|      0|  SEXP prev = PREV_NODE(next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  661|      0|  SET_NEXT_NODE(sn__n__, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  662|      0|  SET_PREV_NODE(next, sn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  663|      0|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  664|      0|  SET_PREV_NODE(sn__n__, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  665|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (665:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  808|      0|	R_GenHeap[__cls__].OldCount[__gen__]++;			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  809|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (809:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  820|      0|	    }						\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  821|      0|	    else FORWARD_NODE(fpn__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  822|      0|	}						\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  823|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (823:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  737|      0|    } \
  |  |  |  |  |  |  738|      0|    break; \
  |  |  |  |  |  |  739|      0|  case EXPRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (739:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  740|      0|  case VECSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (740:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  741|      0|    { \
  |  |  |  |  |  |  742|      0|      R_xlen_t i; \
  |  |  |  |  |  |  743|      0|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (743:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  744|      0|	dc__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  745|      0|    } \
  |  |  |  |  |  |  746|      0|    break; \
  |  |  |  |  |  |  747|      0|  case ENVSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (747:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  748|      0|    dc__action__(FRAME(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  749|      0|    dc__action__(ENCLOS(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  750|      0|    dc__action__(HASHTAB(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  751|      0|    break; \
  |  |  |  |  |  |  752|      0|  case LISTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (752:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  753|      0|  case PROMSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (753:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  754|      0|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  755|      0|    if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   37|      0|# define BOXED_BINDING_CELLS 0
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (37:30): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  463|      0|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (755:32): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  756|      0|      dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  757|      0|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  758|      0|    break; \
  |  |  |  |  |  |  759|      0|  case CLOSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (759:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  760|      0|  case LANGSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (760:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  761|      0|  case DOTSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  127|      0|#define DOTSXP	    17	  /* dot-dot-dot object */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (761:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  762|      0|  case SYMSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (762:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  763|      0|  case BCODESXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  133|      0|#define BCODESXP    21    /* byte code */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (763:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  764|      0|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  765|      0|    dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  766|      0|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  767|      0|    break; \
  |  |  |  |  |  |  768|      0|  case EXTPTRSXP: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  134|      0|#define EXTPTRSXP   22    /* external pointer */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (768:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  769|      0|    dc__action__(EXTPTR_PROT(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  770|      0|    dc__action__(EXTPTR_TAG(__n__), dc__extra__); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  829|      0|    DO_CHILDREN4(__n__, FC_FORWARD_NODE, FC_PROCESS_CHARSXP, 0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  827|      0|#define FC_FORWARD_NODE(__n__,__dummy__) FORWARD_NODE(__n__)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  794|      0|#define FORWARD_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  795|      0|  SEXP fn__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  796|      0|  if (fn__n__ && ! NODE_IS_MARKED(fn__n__)) { \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:7): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (796:18): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  797|      0|    MARK_AND_UNSNAP_NODE(fn__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  787|      0|#define MARK_AND_UNSNAP_NODE(s) do {		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  788|      0|	SEXP mu__n__ = (s);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  789|      0|	CHECK_FOR_FREE_NODE(mu__n__);		\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  834|      0|#define CHECK_FOR_FREE_NODE(s) { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  835|      0|    SEXP cf__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  836|      0|    if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |                   if (TYPEOF(cf__n__) == FREESXP && ! gc_inhibit_release) \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (836:39): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  837|      0|	register_bad_sexp_type(cf__n__, __LINE__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  838|      0|}
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  790|      0|	MARK_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  791|      0|	UNSNAP_NODE(mu__n__);			\
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  792|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (792:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  798|      0|    SET_NEXT_NODE(fn__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  799|      0|    forwarded_nodes = fn__n__; \
  |  |  |  |  |  |  |  |  |  |  |  |  800|      0|  } \
  |  |  |  |  |  |  |  |  |  |  |  |  801|      0|} while (0)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  Branch (801:10): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  771|      0|    break; \
  |  |  |  |  |  |  772|      0|  FREE_FORWARD_CASE \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  705|      0|#define FREE_FORWARD_CASE case FREESXP: if (gc_inhibit_release) break;
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (705:27): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (705:45): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  773|      0|  default: \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (773:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  774|      0|    register_bad_sexp_type(__n__, __LINE__);		\
  |  |  |  |  |  |  775|      0|  } \
  |  |  |  |  |  |  776|      0|} while(0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (776:9): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1717|      0|    } \
  |  | 1718|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (1718:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1989|    318|#endif
 1990|       |
 1991|       |    /* release large vector allocations */
 1992|    318|    ReleaseLargeFreeVectors();
 1993|       |
 1994|    318|    DEBUG_CHECK_NODE_COUNTS("after releasing large allocated nodes");
 1995|       |
 1996|       |    /* tell Valgrind about free nodes */
 1997|       |#if VALGRIND_LEVEL > 1
 1998|       |    for(i = 1; i< NUM_NODE_CLASSES; i++) {
 1999|       |	for(s = NEXT_NODE(R_GenHeap[i].New);
 2000|       |	    s != R_GenHeap[i].Free;
 2001|       |	    s = NEXT_NODE(s)) {
 2002|       |	    VALGRIND_MAKE_MEM_NOACCESS(STDVEC_DATAPTR(s),
 2003|       |				       NodeClassSize[i]*sizeof(VECREC));
 2004|       |	}
 2005|       |    }
 2006|       |#endif
 2007|       |
 2008|       |    /* reset Free pointers */
 2009|  2.86k|    for (i = 0; i < NUM_NODE_CLASSES; i++)
  ------------------
  |  |  531|  2.86k|#define NUM_NODE_CLASSES 8
  ------------------
  |  Branch (2009:17): [True: 2.54k, False: 318]
  ------------------
 2010|  2.54k|	R_GenHeap[i].Free = NEXT_NODE(R_GenHeap[i].New);
  ------------------
  |  |  639|  2.86k|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 2011|       |
 2012|       |
 2013|       |    /* update heap statistics */
 2014|    318|    R_Collected = R_NSize;
 2015|    318|    R_SmallVallocSize = 0;
 2016|    954|    for (gen = 0; gen < NUM_OLD_GENERATIONS; gen++) {
  ------------------
  |  |  551|    954|#define NUM_OLD_GENERATIONS 2
  ------------------
  |  Branch (2016:19): [True: 636, False: 318]
  ------------------
 2017|  3.81k|	for (i = 1; i < NUM_SMALL_NODE_CLASSES; i++)
  ------------------
  |  |  540|  3.81k|#define NUM_SMALL_NODE_CLASSES (NUM_NODE_CLASSES - 2)
  |  |  ------------------
  |  |  |  |  531|  3.81k|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
  |  Branch (2017:14): [True: 3.18k, False: 636]
  ------------------
 2018|  3.18k|	    R_SmallVallocSize += R_GenHeap[i].OldCount[gen] * NodeClassSize[i];
 2019|  5.72k|	for (i = 0; i < NUM_NODE_CLASSES; i++)
  ------------------
  |  |  531|  5.72k|#define NUM_NODE_CLASSES 8
  ------------------
  |  Branch (2019:14): [True: 5.08k, False: 636]
  ------------------
 2020|  5.08k|	    R_Collected -= R_GenHeap[i].OldCount[gen];
 2021|    636|    }
 2022|    318|    R_NodesInUse = R_NSize - R_Collected;
 2023|       |
 2024|    318|    if (num_old_gens_to_collect < NUM_OLD_GENERATIONS) {
  ------------------
  |  |  551|    318|#define NUM_OLD_GENERATIONS 2
  ------------------
  |  Branch (2024:9): [True: 0, False: 318]
  ------------------
 2025|      0|	if (R_Collected < R_MinFreeFrac * R_NSize ||
  ------------------
  |  Branch (2025:6): [True: 0, False: 0]
  ------------------
 2026|      0|	    VHEAP_FREE() < size_needed + R_MinFreeFrac * R_VSize) {
  ------------------
  |  |  596|      0|#define VHEAP_FREE() (R_VSize - R_LargeVallocSize - R_SmallVallocSize)
  ------------------
  |  Branch (2026:6): [True: 0, False: 0]
  ------------------
 2027|      0|	    num_old_gens_to_collect++;
 2028|      0|	    if (R_Collected <= 0 || VHEAP_FREE() < size_needed)
  ------------------
  |  |  596|      0|#define VHEAP_FREE() (R_VSize - R_LargeVallocSize - R_SmallVallocSize)
  ------------------
  |  Branch (2028:10): [True: 0, False: 0]
  |  Branch (2028:30): [True: 0, False: 0]
  ------------------
 2029|      0|		goto again;
 2030|      0|	}
 2031|      0|	else num_old_gens_to_collect = 0;
 2032|      0|    }
 2033|    318|    else num_old_gens_to_collect = 0;
 2034|       |
 2035|    318|    gen_gc_counts[gens_collected]++;
 2036|       |
 2037|    318|    if (gens_collected == NUM_OLD_GENERATIONS) {
  ------------------
  |  |  551|    318|#define NUM_OLD_GENERATIONS 2
  ------------------
  |  Branch (2037:9): [True: 318, False: 0]
  ------------------
 2038|       |	/**** do some adjustment for intermediate collections? */
 2039|    318|	AdjustHeapSize(size_needed);
 2040|    318|	TryToReleasePages();
 2041|    318|	DEBUG_CHECK_NODE_COUNTS("after heap adjustment");
 2042|    318|    }
 2043|      0|    else if (gens_collected > 0) {
  ------------------
  |  Branch (2043:14): [True: 0, False: 0]
  ------------------
 2044|      0|	TryToReleasePages();
 2045|      0|	DEBUG_CHECK_NODE_COUNTS("after heap adjustment");
 2046|      0|    }
 2047|    318|#ifdef SORT_NODES
 2048|    318|    if (gens_collected == NUM_OLD_GENERATIONS)
  ------------------
  |  |  551|    318|#define NUM_OLD_GENERATIONS 2
  ------------------
  |  Branch (2048:9): [True: 318, False: 0]
  ------------------
 2049|    318|	SortNodes();
 2050|    318|#endif
 2051|       |
 2052|    318|    return gens_collected;
 2053|    318|}
memory.c:AgeNodeAndChildren:
 1294|  14.6M|{
 1295|  14.6M|    SEXP forwarded_nodes = NULL;
 1296|  14.6M|    AGE_NODE(s, gen);
  ------------------
  |  | 1278|  14.6M|#define AGE_NODE(s,g) do { \
  |  | 1279|  14.6M|  SEXP an__n__ = (s); \
  |  | 1280|  14.6M|  int an__g__ = (g); \
  |  | 1281|  14.6M|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  ------------------
  |  |  |  |  563|  14.6M|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  ------------------
  |  |  |  |  |  |  268|  29.3M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  232|  14.6M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  ------------------
  |  |  |  |  |  |  559|  14.6M|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (563:4): [True: 19.9k, False: 14.6M]
  |  |  |  |  |  Branch (563:27): [True: 3, False: 14.6M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (1281:7): [True: 14.6M, False: 0]
  |  |  ------------------
  |  | 1282|  19.9k|    if (NODE_IS_MARKED(an__n__)) \
  |  |  ------------------
  |  |  |  |  268|  19.9k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  19.9k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (268:27): [True: 3, False: 19.9k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1283|  19.9k|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  ------------------
  |  |  |  |  545|      3|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  ------------------
  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  ------------------
  |  |  |  |  559|      3|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  ------------------
  |  | 1284|  19.9k|    else \
  |  | 1285|  19.9k|      MARK_NODE(an__n__); \
  |  |  ------------------
  |  |  |  |  269|  19.9k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  ------------------
  |  |  |  |  |  |  232|  19.9k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1286|  19.9k|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  ------------------
  |  |  |  |  560|  19.9k|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  ------------------
  |  | 1287|  19.9k|    UNSNAP_NODE(an__n__); \
  |  |  ------------------
  |  |  |  |  648|  19.9k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  649|  19.9k|  SEXP un__n__ = (s); \
  |  |  |  |  650|  19.9k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  19.9k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  |  |  651|  19.9k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  19.9k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  |  |  652|  19.9k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  641|  19.9k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  639|  19.9k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  653|  19.9k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  ------------------
  |  |  |  |  |  |  642|  19.9k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  640|  19.9k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  654|  19.9k|} while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (654:9): [Folded, False: 19.9k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1288|  19.9k|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  ------------------
  |  |  |  |  641|  19.9k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  19.9k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1289|  19.9k|    forwarded_nodes = an__n__; \
  |  | 1290|  19.9k|  } \
  |  | 1291|  14.6M|} while (0)
  |  |  ------------------
  |  |  |  Branch (1291:10): [Folded, False: 14.6M]
  |  |  ------------------
  ------------------
 1297|  14.8M|    while (forwarded_nodes != NULL) {
  ------------------
  |  Branch (1297:12): [True: 139k, False: 14.6M]
  ------------------
 1298|   139k|	s = forwarded_nodes;
 1299|   139k|	forwarded_nodes = NEXT_NODE(forwarded_nodes);
  ------------------
  |  |  639|   139k|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1300|   139k|	if (NODE_GENERATION(s) != gen)
  ------------------
  |  |  559|   139k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  ------------------
  |  Branch (1300:6): [True: 0, False: 139k]
  ------------------
 1301|      0|	    gc_error("****snapping into wrong generation\n");
 1302|   139k|	SNAP_NODE(s, R_GenHeap[NODE_CLASS(s)].Old[gen]);
  ------------------
  |  |  657|   139k|#define SNAP_NODE(s,t) do { \
  |  |  658|   139k|  SEXP sn__n__ = (s); \
  |  |  659|   139k|  SEXP next = (t); \
  |  |  660|   139k|  SEXP prev = PREV_NODE(next); \
  |  |  ------------------
  |  |  |  |  640|   139k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  |  |  661|   139k|  SET_NEXT_NODE(sn__n__, next); \
  |  |  ------------------
  |  |  |  |  641|   139k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|   139k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  662|   139k|  SET_PREV_NODE(next, sn__n__); \
  |  |  ------------------
  |  |  |  |  642|   139k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|   139k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  663|   139k|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  ------------------
  |  |  |  |  641|   139k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|   139k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  664|   139k|  SET_PREV_NODE(sn__n__, prev); \
  |  |  ------------------
  |  |  |  |  642|   139k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|   139k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  665|   139k|} while (0)
  |  |  ------------------
  |  |  |  Branch (665:10): [Folded, False: 139k]
  |  |  ------------------
  ------------------
 1303|   139k|	R_GenHeap[NODE_CLASS(s)].OldCount[gen]++;
  ------------------
  |  |  545|   139k|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  ------------------
 1304|   139k|	DO_CHILDREN(s, AGE_NODE, gen);
  ------------------
  |  |  779|   139k|    DO_CHILDREN4(__n__,dc__action__,dc__action__,dc__extra__)
  |  |  ------------------
  |  |  |  |  710|   139k|#define DO_CHILDREN4(__n__,dc__action__,dc__str__action__,dc__extra__) do { \
  |  |  |  |  711|   139k|  if (HAS_GENUINE_ATTRIB(__n__)) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  696|   139k|    (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|   139k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|   278k|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                   (TYPEOF(x) != FREESXP && ATTRIB(x) != R_NilValue && \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  230|   139k|#define ATTRIB(x)	((x)->attrib)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (696:6): [True: 139k, False: 0]
  |  |  |  |  |  |  |  Branch (696:30): [True: 10.7k, False: 128k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  697|   139k|     (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  10.7k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  120|  21.5k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  233|  2.88k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |                    (TYPEOF(x) != CHARSXP || TYPEOF(ATTRIB(x)) != CHARSXP))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  120|  2.88k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (697:7): [True: 7.90k, False: 2.88k]
  |  |  |  |  |  |  |  Branch (697:31): [True: 0, False: 2.88k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  712|   139k|    dc__action__(ATTRIB(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|  7.90k|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|  7.90k|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|  7.90k|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|  7.90k|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|  7.90k|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|  7.90k|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|  15.8k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  7.90k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 7.90k, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 7.90k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|  7.90k|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|  7.90k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  7.90k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 7.90k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|  7.90k|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|  7.90k|    else \
  |  |  |  |  |  |  |  | 1285|  7.90k|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|  7.90k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  7.90k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|  7.90k|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|  7.90k|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|  7.90k|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|  7.90k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|  7.90k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|  7.90k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  7.90k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|  7.90k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|  7.90k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|  7.90k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|  7.90k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  7.90k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|  7.90k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|  7.90k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  7.90k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|  7.90k|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 7.90k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|  7.90k|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|  7.90k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  7.90k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|  7.90k|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|  7.90k|  } \
  |  |  |  |  |  |  |  | 1291|  7.90k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 7.90k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  713|   139k|  if (ALTREP(__n__)) {					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  242|   139k|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (242:25): [True: 3, False: 139k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  714|      3|	  dc__action__(TAG(__n__), dc__extra__);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|      3|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|      3|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|      3|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|      3|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|      3|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|      3|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      6|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      3|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|      3|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 0, False: 3]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 3]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 3, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|      0|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|      0|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|      0|    else \
  |  |  |  |  |  |  |  | 1285|      0|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|      0|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|      0|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|      0|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|      0|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|      0|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|      0|  } \
  |  |  |  |  |  |  |  | 1291|      3|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 3]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  715|      3|	  dc__action__(CAR(__n__), dc__extra__);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|      3|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|      3|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|      3|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|      3|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|      3|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|      3|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      6|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      3|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 3, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 3, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|      3|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|      3|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|      3|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 3]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|      3|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|      3|    else \
  |  |  |  |  |  |  |  | 1285|      3|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|      3|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|      3|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|      3|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|      3|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|      3|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|      3|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|      3|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|      3|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|      3|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|      3|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|      3|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|      3|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      3|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      3|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|      3|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|      3|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      3|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|      3|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 3]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|      3|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|      3|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|      3|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|      3|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|      3|  } \
  |  |  |  |  |  |  |  | 1291|      3|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 3]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  716|      3|	  dc__action__(CDR(__n__), dc__extra__);	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|      3|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|      3|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|      3|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|      3|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|      3|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|      3|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|      6|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|      3|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|      3|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 0, False: 3]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 3]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 3, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|      0|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|      0|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|      0|    else \
  |  |  |  |  |  |  |  | 1285|      0|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|      0|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|      0|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|      0|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|      0|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|      0|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|      0|  } \
  |  |  |  |  |  |  |  | 1291|      3|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 3]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  717|      3|      }							\
  |  |  |  |  718|   139k|  else \
  |  |  |  |  719|   139k|  switch (TYPEOF(__n__)) { \
  |  |  |  |  ------------------
  |  |  |  |  |  |  233|   139k|#define TYPEOF(x)	((x)->sxpinfo.type)
  |  |  |  |  ------------------
  |  |  |  |  720|      0|  case NILSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (720:3): [True: 0, False: 139k]
  |  |  |  |  ------------------
  |  |  |  |  721|      0|  case BUILTINSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (721:3): [True: 0, False: 139k]
  |  |  |  |  ------------------
  |  |  |  |  722|      0|  case SPECIALSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (722:3): [True: 0, False: 139k]
  |  |  |  |  ------------------
  |  |  |  |  723|  21.7k|  case CHARSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  120|  21.7k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (723:3): [True: 21.7k, False: 117k]
  |  |  |  |  ------------------
  |  |  |  |  724|  23.3k|  case LGLSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  121|  23.3k|#define LGLSXP	    10	  /* logical vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (724:3): [True: 1.67k, False: 137k]
  |  |  |  |  ------------------
  |  |  |  |  725|  36.6k|  case INTSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  123|  36.6k|#define INTSXP	    13	  /* integer vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (725:3): [True: 13.2k, False: 126k]
  |  |  |  |  ------------------
  |  |  |  |  726|  38.2k|  case REALSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  124|  38.2k|#define REALSXP	    14	  /* real variables */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (726:3): [True: 1.59k, False: 137k]
  |  |  |  |  ------------------
  |  |  |  |  727|  38.2k|  case CPLXSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|  38.2k|#define CPLXSXP	    15	  /* complex variables */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (727:3): [True: 0, False: 139k]
  |  |  |  |  ------------------
  |  |  |  |  728|  38.9k|  case WEAKREFSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  135|  38.9k|#define WEAKREFSXP  23    /* weak reference */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (728:3): [True: 710, False: 138k]
  |  |  |  |  ------------------
  |  |  |  |  729|  38.9k|  case RAWSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  136|  38.9k|#define RAWSXP      24    /* raw bytes */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (729:3): [True: 0, False: 139k]
  |  |  |  |  ------------------
  |  |  |  |  730|  38.9k|  case OBJSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  137|  38.9k|#define OBJSXP      25    /* object, non-vector  */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (730:3): [True: 0, False: 139k]
  |  |  |  |  ------------------
  |  |  |  |  731|  38.9k|    break; \
  |  |  |  |  732|  38.9k|  case STRSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  126|  13.0k|#define STRSXP	    16	  /* string vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (732:3): [True: 13.0k, False: 126k]
  |  |  |  |  ------------------
  |  |  |  |  733|  13.0k|    { \
  |  |  |  |  734|  13.0k|      R_xlen_t i; \
  |  |  |  |  735|  43.4k|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  407|  43.4k|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (735:19): [True: 30.4k, False: 13.0k]
  |  |  |  |  ------------------
  |  |  |  |  736|  30.4k|	dc__str__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|  30.4k|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|  43.4k|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|  30.4k|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|  30.4k|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|  30.4k|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|  30.4k|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|  60.9k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  30.4k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|  28.6k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 1.86k, False: 28.6k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 28.6k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 30.4k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|  1.86k|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|  1.86k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  1.86k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 1.86k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|  1.86k|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|  1.86k|    else \
  |  |  |  |  |  |  |  | 1285|  1.86k|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|  1.86k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  1.86k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|  1.86k|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|  1.86k|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|  1.86k|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|  1.86k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|  1.86k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|  1.86k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  1.86k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|  1.86k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|  1.86k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|  1.86k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|  1.86k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  1.86k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|  1.86k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|  1.86k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  1.86k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|  1.86k|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 1.86k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|  1.86k|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|  1.86k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  1.86k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|  1.86k|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|  1.86k|  } \
  |  |  |  |  |  |  |  | 1291|  30.4k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 30.4k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  737|  13.0k|    } \
  |  |  |  |  738|  13.0k|    break; \
  |  |  |  |  739|  38.9k|  case EXPRSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (739:3): [True: 0, False: 139k]
  |  |  |  |  ------------------
  |  |  |  |  740|  6.57k|  case VECSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  131|  6.57k|#define VECSXP	    19	  /* generic vectors */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (740:3): [True: 6.57k, False: 132k]
  |  |  |  |  ------------------
  |  |  |  |  741|  6.57k|    { \
  |  |  |  |  742|  6.57k|      R_xlen_t i; \
  |  |  |  |  743|  54.6k|      for (i = 0; i < XLENGTH(__n__); i++) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  407|  54.6k|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (743:19): [True: 48.1k, False: 6.57k]
  |  |  |  |  ------------------
  |  |  |  |  744|  48.1k|	dc__action__(VECTOR_ELT_0(__n__, i), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|  48.1k|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|  54.6k|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|  48.1k|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|  48.1k|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|  48.1k|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|  48.1k|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|  96.2k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  48.1k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|  18.6k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 29.4k, False: 18.6k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 18.6k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 48.1k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|  29.4k|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|  29.4k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  29.4k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 29.4k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|  29.4k|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|  29.4k|    else \
  |  |  |  |  |  |  |  | 1285|  29.4k|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|  29.4k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  29.4k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|  29.4k|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|  29.4k|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|  29.4k|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|  29.4k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|  29.4k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|  29.4k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  29.4k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|  29.4k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|  29.4k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|  29.4k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|  29.4k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  29.4k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|  29.4k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|  29.4k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  29.4k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|  29.4k|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 29.4k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|  29.4k|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|  29.4k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  29.4k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|  29.4k|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|  29.4k|  } \
  |  |  |  |  |  |  |  | 1291|  48.1k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 48.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  745|  6.57k|    } \
  |  |  |  |  746|  6.57k|    break; \
  |  |  |  |  747|    349|  case ENVSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  115|    349|#define ENVSXP	     4	  /* environments */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (747:3): [True: 349, False: 138k]
  |  |  |  |  ------------------
  |  |  |  |  748|    349|    dc__action__(FRAME(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|    349|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|    349|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|    349|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|    349|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|    349|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|    349|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|    698|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|    349|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|     44|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 305, False: 44]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 44]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 349, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|    305|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|    305|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|    305|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 305]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|    305|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|    305|    else \
  |  |  |  |  |  |  |  | 1285|    305|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|    305|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|    305|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|    305|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|    305|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|    305|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|    305|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|    305|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|    305|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|    305|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|    305|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|    305|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|    305|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|    305|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|    305|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|    305|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|    305|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|    305|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|    305|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 305]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|    305|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|    305|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|    305|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|    305|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|    305|  } \
  |  |  |  |  |  |  |  | 1291|    349|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 349]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  749|    349|    dc__action__(ENCLOS(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|    349|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|    349|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|    349|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|    349|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|    349|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|    349|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|    698|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|    349|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|    339|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 10, False: 339]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 339]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 349, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|     10|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|     10|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|     10|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 10]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|     10|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|     10|    else \
  |  |  |  |  |  |  |  | 1285|     10|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|     10|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|     10|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|     10|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|     10|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|     10|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|     10|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|     10|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|     10|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|     10|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|     10|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|     10|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|     10|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|     10|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|     10|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|     10|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|     10|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|     10|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|     10|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 10]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|     10|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|     10|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|     10|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|     10|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|     10|  } \
  |  |  |  |  |  |  |  | 1291|    349|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 349]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  750|    349|    dc__action__(HASHTAB(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|    349|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|    349|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|    349|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|    349|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|    349|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|    349|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|    698|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|    349|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|    306|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 43, False: 306]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 306]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 349, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|     43|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|     43|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|     43|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 43]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|     43|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|     43|    else \
  |  |  |  |  |  |  |  | 1285|     43|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|     43|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|     43|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|     43|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|     43|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|     43|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|     43|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|     43|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|     43|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|     43|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|     43|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|     43|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|     43|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|     43|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|     43|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|     43|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|     43|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|     43|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|     43|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 43]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|     43|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|     43|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|     43|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|     43|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|     43|  } \
  |  |  |  |  |  |  |  | 1291|    349|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 349]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  751|    349|    break; \
  |  |  |  |  752|  53.2k|  case LISTSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  113|  53.2k|#define LISTSXP	     2	  /* lists of dotted pairs */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (752:3): [True: 53.2k, False: 86.0k]
  |  |  |  |  ------------------
  |  |  |  |  753|  55.9k|  case PROMSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  116|  55.9k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (753:3): [True: 2.70k, False: 136k]
  |  |  |  |  ------------------
  |  |  |  |  754|  55.9k|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|  55.9k|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|  55.9k|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|  55.9k|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|  55.9k|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|  55.9k|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|  55.9k|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|   111k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  55.9k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|  53.8k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 2.05k, False: 53.8k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 53.8k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 55.9k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|  2.05k|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|  2.05k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  2.05k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 2.05k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|  2.05k|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|  2.05k|    else \
  |  |  |  |  |  |  |  | 1285|  2.05k|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|  2.05k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  2.05k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|  2.05k|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|  2.05k|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|  2.05k|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|  2.05k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|  2.05k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|  2.05k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  2.05k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|  2.05k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|  2.05k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|  2.05k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|  2.05k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  2.05k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|  2.05k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|  2.05k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  2.05k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|  2.05k|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 2.05k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|  2.05k|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|  2.05k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  2.05k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|  2.05k|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|  2.05k|  } \
  |  |  |  |  |  |  |  | 1291|  55.9k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 55.9k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  755|  55.9k|    if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  ------------------
  |  |  |  |  |  |   37|   111k|# define BOXED_BINDING_CELLS 0
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (37:30): [Folded, False: 55.9k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                   if (BOXED_BINDING_CELLS || BNDCELL_TAG(__n__) == 0) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  463|  55.9k|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (755:32): [True: 55.9k, False: 22]
  |  |  |  |  ------------------
  |  |  |  |  756|  55.9k|      dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|  55.9k|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|  55.9k|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|  55.9k|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|  55.9k|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|  55.9k|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|  55.9k|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|   111k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  55.9k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|  34.0k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 21.8k, False: 34.0k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 34.0k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 55.9k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|  21.8k|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|  21.8k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  21.8k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 21.8k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|  21.8k|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|  21.8k|    else \
  |  |  |  |  |  |  |  | 1285|  21.8k|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|  21.8k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  21.8k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|  21.8k|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|  21.8k|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|  21.8k|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|  21.8k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|  21.8k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|  21.8k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  21.8k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|  21.8k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|  21.8k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|  21.8k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|  21.8k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  21.8k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|  21.8k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|  21.8k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  21.8k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|  21.8k|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 21.8k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|  21.8k|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|  21.8k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  21.8k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|  21.8k|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|  21.8k|  } \
  |  |  |  |  |  |  |  | 1291|  55.9k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 55.9k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  757|  55.9k|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|  55.9k|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|  55.9k|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|  55.9k|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|  55.9k|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|  55.9k|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|  55.9k|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|   111k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  55.9k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|  28.7k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 27.1k, False: 28.7k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 28.7k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 55.9k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|  27.1k|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|  27.1k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  27.1k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 27.1k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|  27.1k|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|  27.1k|    else \
  |  |  |  |  |  |  |  | 1285|  27.1k|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|  27.1k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  27.1k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|  27.1k|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|  27.1k|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|  27.1k|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|  27.1k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|  27.1k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|  27.1k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  27.1k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|  27.1k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|  27.1k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|  27.1k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|  27.1k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  27.1k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|  27.1k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|  27.1k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  27.1k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|  27.1k|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 27.1k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|  27.1k|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|  27.1k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  27.1k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|  27.1k|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|  27.1k|  } \
  |  |  |  |  |  |  |  | 1291|  55.9k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 55.9k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  758|  55.9k|    break; \
  |  |  |  |  759|  53.2k|  case CLOSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  114|    947|#define CLOSXP	     3	  /* closures */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (759:3): [True: 947, False: 138k]
  |  |  |  |  ------------------
  |  |  |  |  760|  16.1k|  case LANGSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|  16.1k|#define LANGSXP	     6	  /* language constructs (special lists) */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (760:3): [True: 15.1k, False: 124k]
  |  |  |  |  ------------------
  |  |  |  |  761|  16.1k|  case DOTSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  127|  16.1k|#define DOTSXP	    17	  /* dot-dot-dot object */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (761:3): [True: 5, False: 139k]
  |  |  |  |  ------------------
  |  |  |  |  762|  18.4k|  case SYMSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  112|  18.4k|#define SYMSXP	     1	  /* symbols */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (762:3): [True: 2.31k, False: 136k]
  |  |  |  |  ------------------
  |  |  |  |  763|  23.7k|  case BCODESXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  133|  23.7k|#define BCODESXP    21    /* byte code */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (763:3): [True: 5.28k, False: 133k]
  |  |  |  |  ------------------
  |  |  |  |  764|  23.7k|    dc__action__(TAG(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|  23.7k|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|  23.7k|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|  23.7k|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|  23.7k|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|  23.7k|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|  23.7k|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|  47.4k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  23.7k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|  23.6k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 62, False: 23.6k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 23.6k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 23.7k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|     62|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|     62|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|     62|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 62]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|     62|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|     62|    else \
  |  |  |  |  |  |  |  | 1285|     62|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|     62|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|     62|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|     62|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|     62|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|     62|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|     62|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|     62|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|     62|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|     62|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|     62|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|     62|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|     62|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|     62|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|     62|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|     62|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|     62|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|     62|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|     62|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 62]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|     62|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|     62|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|     62|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|     62|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|     62|  } \
  |  |  |  |  |  |  |  | 1291|  23.7k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 23.7k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  765|  23.7k|    dc__action__(CAR0(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|  23.7k|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|  23.7k|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|  23.7k|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|  23.7k|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|  23.7k|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|  23.7k|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|  47.4k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  23.7k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|  15.9k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 7.74k, False: 15.9k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 15.9k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 23.7k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|  7.74k|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|  7.74k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  7.74k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 7.74k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|  7.74k|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|  7.74k|    else \
  |  |  |  |  |  |  |  | 1285|  7.74k|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|  7.74k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  7.74k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|  7.74k|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|  7.74k|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|  7.74k|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|  7.74k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|  7.74k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|  7.74k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  7.74k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|  7.74k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|  7.74k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|  7.74k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|  7.74k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  7.74k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|  7.74k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|  7.74k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  7.74k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|  7.74k|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 7.74k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|  7.74k|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|  7.74k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  7.74k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|  7.74k|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|  7.74k|  } \
  |  |  |  |  |  |  |  | 1291|  23.7k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 23.7k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  766|  23.7k|    dc__action__(CDR(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|  23.7k|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|  23.7k|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|  23.7k|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|  23.7k|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|  23.7k|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|  23.7k|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|  47.4k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|  23.7k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|  2.87k|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 20.8k, False: 2.87k]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 2.87k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 23.7k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|  20.8k|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|  20.8k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  20.8k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 20.8k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|  20.8k|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|  20.8k|    else \
  |  |  |  |  |  |  |  | 1285|  20.8k|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|  20.8k|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|  20.8k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|  20.8k|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|  20.8k|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|  20.8k|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|  20.8k|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|  20.8k|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|  20.8k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  20.8k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|  20.8k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|  20.8k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|  20.8k|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|  20.8k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|  20.8k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|  20.8k|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|  20.8k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|  20.8k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|  20.8k|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 20.8k]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|  20.8k|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|  20.8k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|  20.8k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|  20.8k|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|  20.8k|  } \
  |  |  |  |  |  |  |  | 1291|  23.7k|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 23.7k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  767|  23.7k|    break; \
  |  |  |  |  768|  18.4k|  case EXTPTRSXP: \
  |  |  |  |  ------------------
  |  |  |  |  |  |  134|    714|#define EXTPTRSXP   22    /* external pointer */
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (768:3): [True: 714, False: 138k]
  |  |  |  |  ------------------
  |  |  |  |  769|    714|    dc__action__(EXTPTR_PROT(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|    714|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|    714|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|    714|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|    714|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|    714|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|    714|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|  1.42k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|    714|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|    714|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 0, False: 714]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 714]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 714, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|      0|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|      0|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|      0|    else \
  |  |  |  |  |  |  |  | 1285|      0|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|      0|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|      0|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|      0|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|      0|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|      0|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|      0|  } \
  |  |  |  |  |  |  |  | 1291|    714|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 714]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  770|    714|    dc__action__(EXTPTR_TAG(__n__), dc__extra__); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 1304|    714|	DO_CHILDREN(s, AGE_NODE, gen);
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1278|    714|#define AGE_NODE(s,g) do { \
  |  |  |  |  |  |  |  | 1279|    714|  SEXP an__n__ = (s); \
  |  |  |  |  |  |  |  | 1280|    714|  int an__g__ = (g); \
  |  |  |  |  |  |  |  | 1281|    714|  if (an__n__ && NODE_GEN_IS_YOUNGER(an__n__, an__g__)) { \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  563|    714|  (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  268|  1.42k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  232|    714|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |                 (! NODE_IS_MARKED(s) || NODE_GENERATION(s) < (g))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  559|    714|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:4): [True: 0, False: 714]
  |  |  |  |  |  |  |  |  |  |  |  Branch (563:27): [True: 0, False: 714]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1281:7): [True: 714, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1282|      0|    if (NODE_IS_MARKED(an__n__)) \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  268|      0|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (268:27): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1283|      0|       R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  545|      0|#define NODE_CLASS(s) ((s)->sxpinfo.gccls)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |                      R_GenHeap[NODE_CLASS(an__n__)].OldCount[NODE_GENERATION(an__n__)]--; \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  559|      0|#define NODE_GENERATION(s) ((s)->sxpinfo.gcgen)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1284|      0|    else \
  |  |  |  |  |  |  |  | 1285|      0|      MARK_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  269|      0|#define MARK_NODE(s) (MARK(s)=1)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  232|      0|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1286|      0|    SET_NODE_GENERATION(an__n__, an__g__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  560|      0|#define SET_NODE_GENERATION(s,g) ((s)->sxpinfo.gcgen=(g))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1287|      0|    UNSNAP_NODE(an__n__); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  648|      0|#define UNSNAP_NODE(s) do { \
  |  |  |  |  |  |  |  |  |  |  649|      0|  SEXP un__n__ = (s); \
  |  |  |  |  |  |  |  |  |  |  650|      0|  SEXP next = NEXT_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  651|      0|  SEXP prev = PREV_NODE(un__n__); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  652|      0|  SET_NEXT_NODE(prev, next); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  653|      0|  SET_PREV_NODE(next, prev); \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  642|      0|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  640|      0|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  654|      0|} while(0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (654:9): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1288|      0|    SET_NEXT_NODE(an__n__, forwarded_nodes); \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  641|      0|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  |  639|      0|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  | 1289|      0|    forwarded_nodes = an__n__; \
  |  |  |  |  |  |  |  | 1290|      0|  } \
  |  |  |  |  |  |  |  | 1291|    714|} while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (1291:10): [Folded, False: 714]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  771|    714|    break; \
  |  |  |  |  772|  18.4k|  FREE_FORWARD_CASE \
  |  |  |  |  ------------------
  |  |  |  |  |  |  705|      0|#define FREE_FORWARD_CASE case FREESXP: if (gc_inhibit_release) break;
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  142|      0|#define FREESXP     31    /* node released by GC */
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (705:27): [True: 0, False: 139k]
  |  |  |  |  |  |  |  Branch (705:45): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  773|      0|  default: \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (773:3): [True: 0, False: 139k]
  |  |  |  |  ------------------
  |  |  |  |  774|      0|    register_bad_sexp_type(__n__, __LINE__);		\
  |  |  |  |  775|   139k|  } \
  |  |  |  |  776|   139k|} while(0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (776:9): [Folded, False: 139k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1305|   139k|    }
 1306|  14.6M|}
memory.c:CheckFinalizers:
 1488|    318|{
 1489|    318|    SEXP s;
 1490|    318|    R_finalizers_pending = FALSE;
 1491|   370k|    for (s = R_weak_refs; s != R_NilValue; s = WEAKREF_NEXT(s)) {
  ------------------
  |  | 1420|   370k|#define WEAKREF_NEXT(w) VECTOR_ELT_0(w, 3)
  |  |  ------------------
  |  |  |  |   80|   370k|#define VECTOR_ELT_0(x,i)        ((SEXP *) STDVEC_DATAPTR(x))[i]
  |  |  |  |  ------------------
  |  |  |  |  |  |  420|   370k|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (1491:27): [True: 370k, False: 318]
  ------------------
 1492|   370k|	if (! NODE_IS_MARKED(WEAKREF_KEY(s)) && ! IS_READY_TO_FINALIZE(s))
  ------------------
  |  |  268|   741k|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  ------------------
  |  |  |  |  232|   370k|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  ------------------
  ------------------
              	if (! NODE_IS_MARKED(WEAKREF_KEY(s)) && ! IS_READY_TO_FINALIZE(s))
  ------------------
  |  | 1405|     65|#define IS_READY_TO_FINALIZE(s) ((s)->sxpinfo.gp & READY_TO_FINALIZE_MASK)
  |  |  ------------------
  |  |  |  | 1401|     65|#define READY_TO_FINALIZE_MASK 1
  |  |  ------------------
  ------------------
  |  Branch (1492:6): [True: 65, False: 370k]
  |  Branch (1492:42): [True: 65, False: 0]
  ------------------
 1493|     65|	    SET_READY_TO_FINALIZE(s);
  ------------------
  |  | 1403|     65|#define SET_READY_TO_FINALIZE(s) ((s)->sxpinfo.gp |= READY_TO_FINALIZE_MASK)
  |  |  ------------------
  |  |  |  | 1401|     65|#define READY_TO_FINALIZE_MASK 1
  |  |  ------------------
  ------------------
 1494|   370k|	if (IS_READY_TO_FINALIZE(s))
  ------------------
  |  | 1405|   370k|#define IS_READY_TO_FINALIZE(s) ((s)->sxpinfo.gp & READY_TO_FINALIZE_MASK)
  |  |  ------------------
  |  |  |  | 1401|   370k|#define READY_TO_FINALIZE_MASK 1
  |  |  ------------------
  |  |  |  Branch (1405:33): [True: 65, False: 370k]
  |  |  ------------------
  ------------------
 1495|     65|	    R_finalizers_pending = TRUE;
 1496|   370k|    }
 1497|    318|}
memory.c:fill_freed_node:
 1164|   108M|{
 1165|   108M|    if (node_class == 0)
  ------------------
  |  Branch (1165:9): [True: 90.3M, False: 17.8M]
  ------------------
 1166|  90.3M|	memset(&s->u, FREED_FILL_BYTE, sizeof(s->u));
  ------------------
  |  | 1161|  90.3M|#define FREED_FILL_BYTE 0xDE
  ------------------
 1167|  17.8M|    else if (node_class < NUM_SMALL_NODE_CLASSES)
  ------------------
  |  |  540|  17.8M|#define NUM_SMALL_NODE_CLASSES (NUM_NODE_CLASSES - 2)
  |  |  ------------------
  |  |  |  |  531|  17.8M|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
  |  Branch (1167:14): [True: 17.8M, False: 0]
  ------------------
 1168|  17.8M|	memset(STDVEC_DATAPTR(s), FREED_FILL_BYTE,
  ------------------
  |  |  420|  17.8M|#define STDVEC_DATAPTR(x) ((void *) (((SEXPREC_ALIGN *) (x)) + 1))
  ------------------
              	memset(STDVEC_DATAPTR(s), FREED_FILL_BYTE,
  ------------------
  |  | 1161|  17.8M|#define FREED_FILL_BYTE 0xDE
  ------------------
 1169|  17.8M|	       NodeClassSize[node_class] * sizeof(VECREC));
 1170|   108M|}
memory.c:getVecSizeInVEC:
 1112|  17.5k|{
 1113|       |    /* For a CHARSXP the growable bit is the 'cached' mark and
 1114|       |       TRUELENGTH may hold a hash value. */
 1115|  17.5k|    if (TYPEOF(s) != CHARSXP && IS_GROWABLE(s))
  ------------------
  |  |  233|  17.5k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
                  if (TYPEOF(s) != CHARSXP && IS_GROWABLE(s))
  ------------------
  |  |  120|  35.1k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
                  if (TYPEOF(s) != CHARSXP && IS_GROWABLE(s))
  ------------------
  |  |  384|  16.5k|#define IS_GROWABLE(x) (GROWABLE_BIT_SET(x) && XLENGTH(x) < XTRUELENGTH(x))
  |  |  ------------------
  |  |  |  |  382|  33.1k|#define GROWABLE_BIT_SET(x) ((x)->sxpinfo.gp & GROWABLE_MASK)
  |  |  |  |  ------------------
  |  |  |  |  |  |  937|  16.5k|#define GROWABLE_MASK ((unsigned short)(1<<5))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (382:29): [True: 0, False: 16.5k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define IS_GROWABLE(x) (GROWABLE_BIT_SET(x) && XLENGTH(x) < XTRUELENGTH(x))
  |  |  ------------------
  |  |  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  |  |  ------------------
  |  |  |  Branch (384:48): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1115:9): [True: 16.5k, False: 972]
  ------------------
 1116|      0|	SET_STDVEC_LENGTH(s, XTRUELENGTH(s));
  ------------------
  |  |  410|      0|#define SET_STDVEC_LENGTH(x,v) do {		\
  |  |  411|      0|	SEXP __x__ = (x);			\
  |  |  412|      0|	R_xlen_t __v__ = (v);			\
  |  |  413|      0|	STDVEC_LENGTH(__x__) = __v__;		\
  |  |  ------------------
  |  |  |  |  392|      0|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  |  |  ------------------
  |  |  414|      0|	SETSCALAR(__x__, __v__ == 1 ? 1 : 0);	\
  |  |  ------------------
  |  |  |  |  244|      0|#define SETSCALAR(x, v) (((x)->sxpinfo.scalar) = (v))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (244:51): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  415|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (415:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1117|       |
 1118|  17.5k|    R_size_t size;
 1119|  17.5k|    switch (TYPEOF(s)) {	/* get size in bytes */
  ------------------
  |  |  233|  17.5k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
 1120|    972|    case CHARSXP:
  ------------------
  |  |  120|    972|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (1120:5): [True: 972, False: 16.5k]
  ------------------
 1121|    972|	size = XLENGTH(s) + 1;
  ------------------
  |  |  407|    972|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
 1122|    972|	break;
 1123|  4.58k|    case RAWSXP:
  ------------------
  |  |  136|  4.58k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1123:5): [True: 4.58k, False: 12.9k]
  ------------------
 1124|  4.58k|	size = XLENGTH(s);
  ------------------
  |  |  407|  4.58k|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
 1125|  4.58k|	break;
 1126|    916|    case LGLSXP:
  ------------------
  |  |  121|    916|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1126:5): [True: 916, False: 16.6k]
  ------------------
 1127|  3.73k|    case INTSXP:
  ------------------
  |  |  123|  3.73k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1127:5): [True: 2.82k, False: 14.7k]
  ------------------
 1128|  3.73k|	size = XLENGTH(s) * sizeof(int);
  ------------------
  |  |  407|  3.73k|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
 1129|  3.73k|	break;
 1130|  3.80k|    case REALSXP:
  ------------------
  |  |  124|  3.80k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1130:5): [True: 3.80k, False: 13.7k]
  ------------------
 1131|  3.80k|	size = XLENGTH(s) * sizeof(double);
  ------------------
  |  |  407|  3.80k|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
 1132|  3.80k|	break;
 1133|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1133:5): [True: 0, False: 17.5k]
  ------------------
 1134|      0|	size = XLENGTH(s) * sizeof(Rcomplex);
  ------------------
  |  |  407|      0|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
 1135|      0|	break;
 1136|  1.89k|    case STRSXP:
  ------------------
  |  |  126|  1.89k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1136:5): [True: 1.89k, False: 15.6k]
  ------------------
 1137|  1.89k|    case EXPRSXP:
  ------------------
  |  |  132|  1.89k|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1137:5): [True: 0, False: 17.5k]
  ------------------
 1138|  4.46k|    case VECSXP:
  ------------------
  |  |  131|  4.46k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1138:5): [True: 2.56k, False: 14.9k]
  ------------------
 1139|  4.46k|	size = XLENGTH(s) * sizeof(SEXP);
  ------------------
  |  |  407|  4.46k|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
 1140|  4.46k|	break;
 1141|      0|    default:
  ------------------
  |  Branch (1141:5): [True: 0, False: 17.5k]
  ------------------
 1142|      0|	register_bad_sexp_type(s, __LINE__);
 1143|      0|	size = 0;
 1144|  17.5k|    }
 1145|  17.5k|    return BYTE2VEC(size);
  ------------------
  |  | 1300|  17.5k|#define BYTE2VEC(n)	(((n)>0)?(((n)-1)/sizeof(VECREC)+1):0)
  |  |  ------------------
  |  |  |  Branch (1300:22): [True: 17.5k, False: 0]
  |  |  ------------------
  ------------------
 1146|  17.5k|}
memory.c:ReleaseLargeFreeVectors:
 1174|    318|{
 1175|    954|    for (int node_class = CUSTOM_NODE_CLASS; node_class <= LARGE_NODE_CLASS; node_class++) {
  ------------------
  |  |  539|    318|#define CUSTOM_NODE_CLASS (NUM_NODE_CLASSES - 2)
  |  |  ------------------
  |  |  |  |  531|    318|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
                  for (int node_class = CUSTOM_NODE_CLASS; node_class <= LARGE_NODE_CLASS; node_class++) {
  ------------------
  |  |  538|    954|#define LARGE_NODE_CLASS  (NUM_NODE_CLASSES - 1)
  |  |  ------------------
  |  |  |  |  531|    954|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
  |  Branch (1175:46): [True: 636, False: 318]
  ------------------
 1176|    636|	SEXP s = NEXT_NODE(R_GenHeap[node_class].New);
  ------------------
  |  |  639|    636|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1177|  18.1k|	while (s != R_GenHeap[node_class].New) {
  ------------------
  |  Branch (1177:9): [True: 17.5k, False: 636]
  ------------------
 1178|  17.5k|	    SEXP next = NEXT_NODE(s);
  ------------------
  |  |  639|  17.5k|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1179|  17.5k|	    if (1 /* CHAR(s) != NULL*/) {
  ------------------
  |  Branch (1179:10): [True: 17.5k, Folded]
  ------------------
 1180|       |		/* Consecutive representation of large vectors with header followed
 1181|       |		   by data. An alternative representation (currently not implemented)
 1182|       |		   could have CHAR(s) == NULL. */
 1183|  17.5k|		R_size_t size;
 1184|  17.5k|#ifdef PROTECTCHECK
 1185|  17.5k|		if (TYPEOF(s) == FREESXP)
  ------------------
  |  |  233|  17.5k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
              		if (TYPEOF(s) == FREESXP)
  ------------------
  |  |  142|  17.5k|#define FREESXP     31    /* node released by GC */
  ------------------
  |  Branch (1185:7): [True: 17.5k, False: 0]
  ------------------
 1186|  17.5k|		    size = STDVEC_LENGTH(s);
  ------------------
  |  |  392|  17.5k|#define STDVEC_LENGTH(x) (((VECSEXP) (x))->vecsxp.length)
  ------------------
 1187|      0|		else
 1188|       |		    /* should not get here -- arrange for a warning/error? */
 1189|      0|		    size = getVecSizeInVEC(s);
 1190|       |#else
 1191|       |		size = getVecSizeInVEC(s);
 1192|       |#endif
 1193|  17.5k|		UNSNAP_NODE(s);
  ------------------
  |  |  648|  17.5k|#define UNSNAP_NODE(s) do { \
  |  |  649|  17.5k|  SEXP un__n__ = (s); \
  |  |  650|  17.5k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  ------------------
  |  |  |  |  639|  17.5k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  |  |  651|  17.5k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  ------------------
  |  |  |  |  640|  17.5k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  |  |  652|  17.5k|  SET_NEXT_NODE(prev, next); \
  |  |  ------------------
  |  |  |  |  641|  17.5k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  17.5k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  653|  17.5k|  SET_PREV_NODE(next, prev); \
  |  |  ------------------
  |  |  |  |  642|  17.5k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  17.5k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  654|  17.5k|} while(0)
  |  |  ------------------
  |  |  |  Branch (654:9): [Folded, False: 17.5k]
  |  |  ------------------
  ------------------
 1194|  17.5k|		R_GenHeap[node_class].AllocCount--;
 1195|  17.5k|		if (node_class == LARGE_NODE_CLASS) {
  ------------------
  |  |  538|  17.5k|#define LARGE_NODE_CLASS  (NUM_NODE_CLASSES - 1)
  |  |  ------------------
  |  |  |  |  531|  17.5k|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
  |  Branch (1195:7): [True: 17.5k, False: 0]
  ------------------
 1196|  17.5k|		    R_LargeVallocSize -= size;
 1197|  17.5k|		    free(s);
 1198|  17.5k|		} else {
 1199|      0|		    custom_node_free(s);
 1200|      0|		}
 1201|  17.5k|	    }
 1202|  17.5k|	    s = next;
 1203|  17.5k|	}
 1204|    636|    }
 1205|    318|}
memory.c:AdjustHeapSize:
 1210|    318|{
 1211|    318|    R_size_t R_MinNFree = (R_size_t)(orig_R_NSize * R_MinFreeFrac);
 1212|    318|    R_size_t R_MinVFree = (R_size_t)(orig_R_VSize * R_MinFreeFrac);
 1213|    318|    R_size_t NNeeded = R_NodesInUse + R_MinNFree;
 1214|    318|    R_size_t VNeeded = R_SmallVallocSize + R_LargeVallocSize
 1215|    318|	+ size_needed + R_MinVFree;
 1216|    318|    double node_occup = ((double) NNeeded) / R_NSize;
 1217|    318|    double vect_occup =	((double) VNeeded) / R_VSize;
 1218|       |
 1219|    318|    if (node_occup > R_NGrowFrac) {
  ------------------
  |  Branch (1219:9): [True: 2, False: 316]
  ------------------
 1220|      2|	R_size_t change =
 1221|      2|	    (R_size_t)(R_NGrowIncrMin + R_NGrowIncrFrac * R_NSize);
 1222|       |
 1223|       |	/* for early adjustments grow more aggressively */
 1224|      2|	static R_size_t last_in_use = 0;
 1225|      2|	static int adjust_count = 1;
 1226|      2|	if (adjust_count < 50) {
  ------------------
  |  Branch (1226:6): [True: 2, False: 0]
  ------------------
 1227|      2|	    adjust_count++;
 1228|       |
 1229|       |	    /* A decrease in live nodes contributes no predicted growth. */
 1230|      2|	    double growth = R_NodesInUse > last_in_use
  ------------------
  |  Branch (1230:22): [True: 2, False: 0]
  ------------------
 1231|      2|		? (double)(R_NodesInUse - last_in_use) : 0.0;
 1232|       |
 1233|       |	    /* Try to achieve and occupancy rate of R_NGrowFrac. */
 1234|      2|	    double target = ((double) R_NodesInUse + growth) / R_NGrowFrac;
 1235|      2|	    last_in_use = R_NodesInUse;
 1236|       |
 1237|       |	    /* Exclude out-of-range conversion, including a rounded-up
 1238|       |	       SIZE_MAX. */
 1239|      2|	    if (target < (double) R_SIZE_T_MAX) {
  ------------------
  |  | 1044|      2|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  |  Branch (1239:10): [True: 2, False: 0]
  ------------------
 1240|      2|		R_size_t next_nsize = (R_size_t) target;
 1241|      2|		if (next_nsize > R_NSize && next_nsize - R_NSize > change)
  ------------------
  |  Branch (1241:7): [True: 2, False: 0]
  |  Branch (1241:31): [True: 2, False: 0]
  ------------------
 1242|      2|		    change = next_nsize - R_NSize;
 1243|      2|	    }
 1244|      2|	}
 1245|       |
 1246|      2|	if (R_NSize <= R_MaxNSize && change <= R_MaxNSize - R_NSize)
  ------------------
  |  Branch (1246:6): [True: 2, False: 0]
  |  Branch (1246:31): [True: 2, False: 0]
  ------------------
 1247|      2|	    R_NSize += change;
 1248|      2|    }
 1249|    316|    else if (node_occup < R_NShrinkFrac) {
  ------------------
  |  Branch (1249:14): [True: 0, False: 316]
  ------------------
 1250|      0|	R_NSize -= (R_size_t)(R_NShrinkIncrMin + R_NShrinkIncrFrac * R_NSize);
 1251|      0|	if (R_NSize < NNeeded)
  ------------------
  |  Branch (1251:6): [True: 0, False: 0]
  ------------------
 1252|      0|	    R_NSize = (NNeeded < R_MaxNSize) ? NNeeded: R_MaxNSize;
  ------------------
  |  Branch (1252:16): [True: 0, False: 0]
  ------------------
 1253|      0|	if (R_NSize < orig_R_NSize)
  ------------------
  |  Branch (1253:6): [True: 0, False: 0]
  ------------------
 1254|      0|	    R_NSize = orig_R_NSize;
 1255|      0|    }
 1256|       |
 1257|    318|    if (vect_occup > 1.0 && VNeeded < R_MaxVSize)
  ------------------
  |  Branch (1257:9): [True: 0, False: 318]
  |  Branch (1257:29): [True: 0, False: 0]
  ------------------
 1258|      0|	R_VSize = VNeeded;
 1259|    318|    if (vect_occup > R_VGrowFrac) {
  ------------------
  |  Branch (1259:9): [True: 0, False: 318]
  ------------------
 1260|      0|	R_size_t change = (R_size_t)(R_VGrowIncrMin + R_VGrowIncrFrac * R_VSize);
 1261|      0|	if (R_MaxVSize - R_VSize >= change)
  ------------------
  |  Branch (1261:6): [True: 0, False: 0]
  ------------------
 1262|      0|	    R_VSize += change;
 1263|      0|    }
 1264|    318|    else if (vect_occup < R_VShrinkFrac) {
  ------------------
  |  Branch (1264:14): [True: 318, False: 0]
  ------------------
 1265|    318|	R_VSize -= (R_size_t)(R_VShrinkIncrMin + R_VShrinkIncrFrac * R_VSize);
 1266|    318|	if (R_VSize < VNeeded)
  ------------------
  |  Branch (1266:6): [True: 0, False: 318]
  ------------------
 1267|      0|	    R_VSize = VNeeded;
 1268|    318|	if (R_VSize < orig_R_VSize)
  ------------------
  |  Branch (1268:6): [True: 318, False: 0]
  ------------------
 1269|    318|	    R_VSize = orig_R_VSize;
 1270|    318|    }
 1271|       |
 1272|    318|    DEBUG_ADJUST_HEAP_PRINT(node_occup, vect_occup);
 1273|    318|}
memory.c:TryToReleasePages:
 1058|    318|{
 1059|    318|    SEXP s;
 1060|    318|    int i;
 1061|    318|    static int release_count = 0;
 1062|       |
 1063|    318|    if (release_count == 0) {
  ------------------
  |  Branch (1063:9): [True: 160, False: 158]
  ------------------
 1064|    160|	release_count = R_PageReleaseFreq;
 1065|  1.12k|	for (i = 0; i < NUM_SMALL_NODE_CLASSES; i++) {
  ------------------
  |  |  540|  1.12k|#define NUM_SMALL_NODE_CLASSES (NUM_NODE_CLASSES - 2)
  |  |  ------------------
  |  |  |  |  531|  1.12k|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
  |  Branch (1065:14): [True: 960, False: 160]
  ------------------
 1066|    960|	    PAGE_HEADER *page, *last, *next;
 1067|    960|	    int node_size = NODE_SIZE(i);
  ------------------
  |  |  592|    960|  ((c) == 0 ? sizeof(SEXPREC) : \
  |  |  ------------------
  |  |  |  Branch (592:4): [True: 160, False: 800]
  |  |  ------------------
  |  |  593|    960|   sizeof(SEXPREC_ALIGN) + NodeClassSize[c] * sizeof(VECREC))
  ------------------
 1068|    960|	    int page_count = (R_PAGE_SIZE - sizeof(PAGE_HEADER)) / node_size;
  ------------------
  |  |  588|    960|  (((BASE_PAGE_SIZE - sizeof(PAGE_HEADER)) / sizeof(SEXPREC)) \
  |  |  ------------------
  |  |  |  |  583|    960|# define BASE_PAGE_SIZE 8000
  |  |  ------------------
  |  |  589|    960|   * sizeof(SEXPREC) \
  |  |  590|    960|   + sizeof(PAGE_HEADER))
  ------------------
 1069|    960|	    int maxrel, maxrel_pages, rel_pages, gen;
 1070|       |
 1071|    960|	    maxrel = R_GenHeap[i].AllocCount;
 1072|  2.88k|	    for (gen = 0; gen < NUM_OLD_GENERATIONS; gen++)
  ------------------
  |  |  551|  2.88k|#define NUM_OLD_GENERATIONS 2
  ------------------
  |  Branch (1072:20): [True: 1.92k, False: 960]
  ------------------
 1073|  1.92k|		maxrel -= (int)((1.0 + R_MaxKeepFrac) *
 1074|  1.92k|				R_GenHeap[i].OldCount[gen]);
 1075|    960|	    maxrel_pages = maxrel > 0 ? maxrel / page_count : 0;
  ------------------
  |  Branch (1075:21): [True: 638, False: 322]
  ------------------
 1076|       |
 1077|       |	    /* all nodes in New space should be both free and unmarked */
 1078|    960|	    for (page = R_GenHeap[i].pages, rel_pages = 0, last = NULL;
 1079|   621k|		 rel_pages < maxrel_pages && page != NULL;) {
  ------------------
  |  Branch (1079:4): [True: 620k, False: 796]
  |  Branch (1079:32): [True: 620k, False: 164]
  ------------------
 1080|   620k|		int j, in_use;
 1081|   620k|		char *data = PAGE_DATA(page);
  ------------------
  |  |  595|   620k|#define PAGE_DATA(p) ((void *) (p + 1))
  ------------------
 1082|       |
 1083|   620k|		next = page->next;
 1084|  31.2M|		for (in_use = 0, j = 0; j < page_count;
  ------------------
  |  Branch (1084:27): [True: 31.0M, False: 176k]
  ------------------
 1085|  31.0M|		     j++, data += node_size) {
 1086|  31.0M|		    s = (SEXP) data;
 1087|  31.0M|		    if (NODE_IS_MARKED(s)) {
  ------------------
  |  |  268|  31.0M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  ------------------
  |  |  |  |  232|  31.0M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  ------------------
  |  |  |  Branch (268:27): [True: 444k, False: 30.6M]
  |  |  ------------------
  ------------------
 1088|   444k|			in_use = 1;
 1089|   444k|			break;
 1090|   444k|		    }
 1091|  31.0M|		}
 1092|   620k|		if (! in_use) {
  ------------------
  |  Branch (1092:7): [True: 176k, False: 444k]
  ------------------
 1093|   176k|		    ReleasePage(page, i);
 1094|   176k|		    if (last == NULL)
  ------------------
  |  Branch (1094:11): [True: 115k, False: 60.3k]
  ------------------
 1095|   115k|			R_GenHeap[i].pages = next;
 1096|  60.3k|		    else
 1097|  60.3k|			last->next = next;
 1098|   176k|		    rel_pages++;
 1099|   176k|		}
 1100|   444k|		else last = page;
 1101|   620k|		page = next;
 1102|   620k|	    }
 1103|    960|	    DEBUG_RELEASE_PRINT(rel_pages, maxrel_pages, i);
 1104|    960|	    R_GenHeap[i].Free = NEXT_NODE(R_GenHeap[i].New);
  ------------------
  |  |  639|    960|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1105|    960|	}
 1106|    160|    }
 1107|    158|    else release_count--;
 1108|    318|}
memory.c:ReleasePage:
 1039|   176k|{
 1040|   176k|    SEXP s;
 1041|   176k|    char *data;
 1042|   176k|    int node_size, page_count, i;
 1043|       |
 1044|   176k|    node_size = NODE_SIZE(node_class);
  ------------------
  |  |  592|   176k|  ((c) == 0 ? sizeof(SEXPREC) : \
  |  |  ------------------
  |  |  |  Branch (592:4): [True: 155k, False: 20.1k]
  |  |  ------------------
  |  |  593|   176k|   sizeof(SEXPREC_ALIGN) + NodeClassSize[c] * sizeof(VECREC))
  ------------------
 1045|   176k|    page_count = (R_PAGE_SIZE - sizeof(PAGE_HEADER)) / node_size;
  ------------------
  |  |  588|   176k|  (((BASE_PAGE_SIZE - sizeof(PAGE_HEADER)) / sizeof(SEXPREC)) \
  |  |  ------------------
  |  |  |  |  583|   176k|# define BASE_PAGE_SIZE 8000
  |  |  ------------------
  |  |  589|   176k|   * sizeof(SEXPREC) \
  |  |  590|   176k|   + sizeof(PAGE_HEADER))
  ------------------
 1046|   176k|    data = PAGE_DATA(page);
  ------------------
  |  |  595|   176k|#define PAGE_DATA(p) ((void *) (p + 1))
  ------------------
 1047|       |
 1048|  24.3M|    for (i = 0; i < page_count; i++, data += node_size) {
  ------------------
  |  Branch (1048:17): [True: 24.1M, False: 176k]
  ------------------
 1049|  24.1M|	s = (SEXP) data;
 1050|  24.1M|	UNSNAP_NODE(s);
  ------------------
  |  |  648|  24.1M|#define UNSNAP_NODE(s) do { \
  |  |  649|  24.1M|  SEXP un__n__ = (s); \
  |  |  650|  24.1M|  SEXP next = NEXT_NODE(un__n__); \
  |  |  ------------------
  |  |  |  |  639|  24.1M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  |  |  651|  24.1M|  SEXP prev = PREV_NODE(un__n__); \
  |  |  ------------------
  |  |  |  |  640|  24.1M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  |  |  652|  24.1M|  SET_NEXT_NODE(prev, next); \
  |  |  ------------------
  |  |  |  |  641|  24.1M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  24.1M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  653|  24.1M|  SET_PREV_NODE(next, prev); \
  |  |  ------------------
  |  |  |  |  642|  24.1M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  24.1M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  654|  24.1M|} while(0)
  |  |  ------------------
  |  |  |  Branch (654:9): [Folded, False: 24.1M]
  |  |  ------------------
  ------------------
 1051|  24.1M|	R_GenHeap[node_class].AllocCount--;
 1052|  24.1M|    }
 1053|   176k|    R_GenHeap[node_class].PageCount--;
 1054|   176k|    free(page);
 1055|   176k|}
memory.c:SortNodes:
 1365|    318|{
 1366|    318|    SEXP s;
 1367|    318|    int i;
 1368|       |
 1369|  2.22k|    for (i = 0; i < NUM_SMALL_NODE_CLASSES; i++) {
  ------------------
  |  |  540|  2.22k|#define NUM_SMALL_NODE_CLASSES (NUM_NODE_CLASSES - 2)
  |  |  ------------------
  |  |  |  |  531|  2.22k|#define NUM_NODE_CLASSES 8
  |  |  ------------------
  ------------------
  |  Branch (1369:17): [True: 1.90k, False: 318]
  ------------------
 1370|  1.90k|	PAGE_HEADER *page;
 1371|  1.90k|	int node_size = NODE_SIZE(i);
  ------------------
  |  |  592|  1.90k|  ((c) == 0 ? sizeof(SEXPREC) : \
  |  |  ------------------
  |  |  |  Branch (592:4): [True: 318, False: 1.59k]
  |  |  ------------------
  |  |  593|  1.90k|   sizeof(SEXPREC_ALIGN) + NodeClassSize[c] * sizeof(VECREC))
  ------------------
 1372|  1.90k|	int page_count = (R_PAGE_SIZE - sizeof(PAGE_HEADER)) / node_size;
  ------------------
  |  |  588|  1.90k|  (((BASE_PAGE_SIZE - sizeof(PAGE_HEADER)) / sizeof(SEXPREC)) \
  |  |  ------------------
  |  |  |  |  583|  1.90k|# define BASE_PAGE_SIZE 8000
  |  |  ------------------
  |  |  589|  1.90k|   * sizeof(SEXPREC) \
  |  |  590|  1.90k|   + sizeof(PAGE_HEADER))
  ------------------
 1373|       |
 1374|  1.90k|	SET_NEXT_NODE(R_GenHeap[i].New, R_GenHeap[i].New);
  ------------------
  |  |  641|  1.90k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  ------------------
  |  |  |  |  639|  1.90k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  ------------------
 1375|  1.90k|	SET_PREV_NODE(R_GenHeap[i].New, R_GenHeap[i].New);
  ------------------
  |  |  642|  1.90k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  ------------------
  |  |  |  |  640|  1.90k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  ------------------
 1376|  1.49M|	for (page = R_GenHeap[i].pages; page != NULL; page = page->next) {
  ------------------
  |  Branch (1376:34): [True: 1.48M, False: 1.90k]
  ------------------
 1377|  1.48M|	    int j;
 1378|  1.48M|	    char *data = PAGE_DATA(page);
  ------------------
  |  |  595|  1.48M|#define PAGE_DATA(p) ((void *) (p + 1))
  ------------------
 1379|       |
 1380|   202M|	    for (j = 0; j < page_count; j++, data += node_size) {
  ------------------
  |  Branch (1380:18): [True: 200M, False: 1.48M]
  ------------------
 1381|   200M|		s = (SEXP) data;
 1382|   200M|		if (! NODE_IS_MARKED(s))
  ------------------
  |  |  268|   200M|#define NODE_IS_MARKED(s) (MARK(s)==1)
  |  |  ------------------
  |  |  |  |  232|   200M|#define MARK(x)		((x)->sxpinfo.mark)
  |  |  ------------------
  ------------------
  |  Branch (1382:7): [True: 85.3M, False: 115M]
  ------------------
 1383|  85.3M|		    SNAP_NODE(s, R_GenHeap[i].New);
  ------------------
  |  |  657|  85.3M|#define SNAP_NODE(s,t) do { \
  |  |  658|  85.3M|  SEXP sn__n__ = (s); \
  |  |  659|  85.3M|  SEXP next = (t); \
  |  |  660|  85.3M|  SEXP prev = PREV_NODE(next); \
  |  |  ------------------
  |  |  |  |  640|  85.3M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  |  |  661|  85.3M|  SET_NEXT_NODE(sn__n__, next); \
  |  |  ------------------
  |  |  |  |  641|  85.3M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  85.3M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  662|  85.3M|  SET_PREV_NODE(next, sn__n__); \
  |  |  ------------------
  |  |  |  |  642|  85.3M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  85.3M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  663|  85.3M|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  ------------------
  |  |  |  |  641|  85.3M|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  85.3M|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  664|  85.3M|  SET_PREV_NODE(sn__n__, prev); \
  |  |  ------------------
  |  |  |  |  642|  85.3M|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  85.3M|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  665|  85.3M|} while (0)
  |  |  ------------------
  |  |  |  Branch (665:10): [Folded, False: 85.3M]
  |  |  ------------------
  ------------------
 1384|   200M|	    }
 1385|  1.48M|	}
 1386|  1.90k|	R_GenHeap[i].Free = NEXT_NODE(R_GenHeap[i].New);
  ------------------
  |  |  639|  1.90k|#define NEXT_NODE(s) (s)->gengc_next_node
  ------------------
 1387|  1.90k|    }
 1388|    318|}
memory.c:gc_end_timing:
 3183|    318|{
 3184|    318|    if (gctime_enabled) {
  ------------------
  |  Branch (3184:9): [True: 0, False: 318]
  ------------------
 3185|      0|	double times[5], delta;
 3186|      0|	R_getProcTime(times);
 3187|       |
 3188|       |	/* add delta to compensate for timer resolution */
 3189|       |#if 0
 3190|       |	/* this seems to over-compensate too */
 3191|       |	delta = R_getClockIncrement();
 3192|       |#else
 3193|      0|	delta = 0;
 3194|      0|#endif
 3195|       |
 3196|      0|	gctimes[0] += times[0] - gcstarttimes[0] + delta;
 3197|      0|	gctimes[1] += times[1] - gcstarttimes[1] + delta;
 3198|      0|	gctimes[2] += times[2] - gcstarttimes[2];
 3199|      0|	gctimes[3] += times[3] - gcstarttimes[3];
 3200|      0|	gctimes[4] += times[4] - gcstarttimes[4];
 3201|      0|    }
 3202|    318|}
memory.c:DeleteFromList:
 3637|      2|{
 3638|      2|    if (CAR(list) == object)
  ------------------
  |  Branch (3638:9): [True: 2, False: 0]
  ------------------
 3639|      2|	return CDR(list);
  ------------------
  |  |  445|      2|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
 3640|      0|    else {
 3641|      0|	SEXP last = list;
 3642|      0|	for (SEXP head = CDR(list); head != R_NilValue; head = CDR(head)) {
  ------------------
  |  |  445|      0|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
              	for (SEXP head = CDR(list); head != R_NilValue; head = CDR(head)) {
  ------------------
  |  |  445|      0|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
  |  Branch (3642:30): [True: 0, False: 0]
  ------------------
 3643|      0|	    if (CAR(head) == object) {
  ------------------
  |  Branch (3643:10): [True: 0, False: 0]
  ------------------
 3644|      0|		SETCDR(last, CDR(head));
  ------------------
  |  |  445|      0|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
 3645|      0|		return list;
 3646|      0|	    }
 3647|      0|	    else last = head;
 3648|      0|	}
 3649|      0|	return list;
 3650|      0|    }
 3651|      2|}
memory.c:checkMSet:
 3759|  10.0k|{
 3760|  10.0k|    SEXP store = CAR(mset);
 3761|  10.0k|    SEXP npreserved = CDR(mset);
  ------------------
  |  |  445|  10.0k|#define CDR(e)		((e)->u.listsxp.cdrval)
  ------------------
 3762|  10.0k|    SEXP isize = TAG(mset);
  ------------------
  |  |  440|  10.0k|#define TAG(e)		((e)->u.listsxp.tagval)
  ------------------
 3763|  10.0k|    if (/*MAYBE_REFERENCED(mset) ||*/
 3764|  10.0k|	((store != R_NilValue) &&
  ------------------
  |  Branch (3764:3): [True: 9.97k, False: 44]
  ------------------
 3765|  9.97k|	 (TYPEOF(store) != VECSXP /*|| MAYBE_REFERENCED(store)*/)) ||
  ------------------
  |  |  233|  9.97k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
              	 (TYPEOF(store) != VECSXP /*|| MAYBE_REFERENCED(store)*/)) ||
  ------------------
  |  |  131|  9.97k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (3765:3): [True: 0, False: 9.97k]
  ------------------
 3766|  10.0k|	(TYPEOF(npreserved) != INTSXP || XLENGTH(npreserved) != 1 /*||
  ------------------
  |  |  233|  10.0k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
              	(TYPEOF(npreserved) != INTSXP || XLENGTH(npreserved) != 1 /*||
  ------------------
  |  |  123|  20.0k|#define INTSXP	    13	  /* integer vectors */
  ------------------
              	(TYPEOF(npreserved) != INTSXP || XLENGTH(npreserved) != 1 /*||
  ------------------
  |  |  407|  10.0k|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
  |  Branch (3766:3): [True: 0, False: 10.0k]
  |  Branch (3766:35): [True: 0, False: 10.0k]
  ------------------
 3767|  10.0k|	 MAYBE_REFERENCED(npreserved)*/) ||
 3768|  10.0k|	(TYPEOF(isize) != INTSXP || XLENGTH(isize) != 1))
  ------------------
  |  |  233|  10.0k|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
              	(TYPEOF(isize) != INTSXP || XLENGTH(isize) != 1))
  ------------------
  |  |  123|  20.0k|#define INTSXP	    13	  /* integer vectors */
  ------------------
              	(TYPEOF(isize) != INTSXP || XLENGTH(isize) != 1))
  ------------------
  |  |  407|  10.0k|#define XLENGTH(x) XLENGTH_EX(x)
  ------------------
  |  Branch (3768:3): [True: 0, False: 10.0k]
  |  Branch (3768:30): [True: 0, False: 10.0k]
  ------------------
 3769|       |
 3770|      0|	error("Invalid mset");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 3771|  10.0k|}
memory.c:old_to_new:
 1309|  35.3k|{
 1310|       |#ifdef EXPEL_OLD_TO_NEW
 1311|       |    AgeNodeAndChildren(y, NODE_GENERATION(x));
 1312|       |#else
 1313|  35.3k|    UNSNAP_NODE(x);
  ------------------
  |  |  648|  35.3k|#define UNSNAP_NODE(s) do { \
  |  |  649|  35.3k|  SEXP un__n__ = (s); \
  |  |  650|  35.3k|  SEXP next = NEXT_NODE(un__n__); \
  |  |  ------------------
  |  |  |  |  639|  35.3k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  ------------------
  |  |  651|  35.3k|  SEXP prev = PREV_NODE(un__n__); \
  |  |  ------------------
  |  |  |  |  640|  35.3k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  |  |  652|  35.3k|  SET_NEXT_NODE(prev, next); \
  |  |  ------------------
  |  |  |  |  641|  35.3k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  35.3k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  653|  35.3k|  SET_PREV_NODE(next, prev); \
  |  |  ------------------
  |  |  |  |  642|  35.3k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  35.3k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  654|  35.3k|} while(0)
  |  |  ------------------
  |  |  |  Branch (654:9): [Folded, False: 35.3k]
  |  |  ------------------
  ------------------
 1314|  35.3k|    SNAP_NODE(x, R_GenHeap[NODE_CLASS(x)].OldToNew[NODE_GENERATION(x)]);
  ------------------
  |  |  657|  35.3k|#define SNAP_NODE(s,t) do { \
  |  |  658|  35.3k|  SEXP sn__n__ = (s); \
  |  |  659|  35.3k|  SEXP next = (t); \
  |  |  660|  35.3k|  SEXP prev = PREV_NODE(next); \
  |  |  ------------------
  |  |  |  |  640|  35.3k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  ------------------
  |  |  661|  35.3k|  SET_NEXT_NODE(sn__n__, next); \
  |  |  ------------------
  |  |  |  |  641|  35.3k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  35.3k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  662|  35.3k|  SET_PREV_NODE(next, sn__n__); \
  |  |  ------------------
  |  |  |  |  642|  35.3k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  35.3k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  663|  35.3k|  SET_NEXT_NODE(prev, sn__n__); \
  |  |  ------------------
  |  |  |  |  641|  35.3k|#define SET_NEXT_NODE(s,t) (NEXT_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  639|  35.3k|#define NEXT_NODE(s) (s)->gengc_next_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  664|  35.3k|  SET_PREV_NODE(sn__n__, prev); \
  |  |  ------------------
  |  |  |  |  642|  35.3k|#define SET_PREV_NODE(s,t) (PREV_NODE(s) = (t))
  |  |  |  |  ------------------
  |  |  |  |  |  |  640|  35.3k|#define PREV_NODE(s) (s)->gengc_prev_node
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  665|  35.3k|} while (0)
  |  |  ------------------
  |  |  |  Branch (665:10): [Folded, False: 35.3k]
  |  |  ------------------
  ------------------
 1315|  35.3k|#endif
 1316|  35.3k|}
memory.c:check_SET_TYPEOF:
 4028|  6.58M|{
 4029|  6.58M|    if (ALTREP(x))
  ------------------
  |  |  242|  6.58M|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  ------------------
  |  |  |  Branch (242:25): [True: 0, False: 6.58M]
  |  |  ------------------
  ------------------
 4030|      0|	error(_("can't change the type of an ALTREP object from %s to %s"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("can't change the type of an ALTREP object from %s to %s"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4031|      0|	      sexptype2char(TYPEOF(x)), sexptype2char(v));
  ------------------
  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  ------------------
              	      sexptype2char(TYPEOF(x)), sexptype2char(v));
  ------------------
  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
              	      sexptype2char(TYPEOF(x)), sexptype2char(v));
  ------------------
  |  | 1984|      0|# define sexptype2char		Rf_sexptype2char
  ------------------
 4032|  6.58M|    switch (TYPEOF(x)) {
  ------------------
  |  |  233|  6.58M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
 4033|  6.58M|    case LISTSXP:
  ------------------
  |  |  113|  6.58M|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (4033:5): [True: 6.58M, False: 0]
  ------------------
 4034|  6.58M|    case LANGSXP:
  ------------------
  |  |  117|  6.58M|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (4034:5): [True: 0, False: 6.58M]
  ------------------
 4035|  6.58M|    case DOTSXP:
  ------------------
  |  |  127|  6.58M|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (4035:5): [True: 0, False: 6.58M]
  ------------------
 4036|  6.58M|	if (BNDCELL_TAG(x))
  ------------------
  |  |  463|  6.58M|#define BNDCELL_TAG(e)	((e)->sxpinfo.extra)
  |  |  ------------------
  |  |  |  Branch (463:24): [True: 0, False: 6.58M]
  |  |  ------------------
  ------------------
 4037|      0|	    error(_("can't change the type of a binding cell"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("can't change the type of a binding cell"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 4038|  6.58M|	switch (v) {
 4039|      0|	case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (4039:2): [True: 0, False: 6.58M]
  ------------------
 4040|  5.04M|	case LANGSXP:
  ------------------
  |  |  117|  5.04M|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (4040:2): [True: 5.04M, False: 1.54M]
  ------------------
 4041|  6.58M|	case DOTSXP:
  ------------------
  |  |  127|  6.58M|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (4041:2): [True: 1.54M, False: 5.04M]
  ------------------
 4042|  6.58M|	case BCODESXP: return;
  ------------------
  |  |  133|  6.58M|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (4042:2): [True: 11, False: 6.58M]
  ------------------
 4043|      0|	default: bad_SET_TYPEOF(TYPEOF(x), v);
  ------------------
  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
  |  Branch (4043:2): [True: 0, False: 6.58M]
  ------------------
 4044|  6.58M|	}
 4045|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (4045:5): [True: 0, False: 6.58M]
  ------------------
 4046|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (4046:5): [True: 0, False: 6.58M]
  ------------------
 4047|      0|	switch (v) {
 4048|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (4048:2): [True: 0, False: 0]
  ------------------
 4049|      0|	case LGLSXP: return;
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (4049:2): [True: 0, False: 0]
  ------------------
 4050|      0|	default: bad_SET_TYPEOF(TYPEOF(x), v);
  ------------------
  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
  |  Branch (4050:2): [True: 0, False: 0]
  ------------------
 4051|      0|	}
 4052|      0|    case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (4052:5): [True: 0, False: 6.58M]
  ------------------
 4053|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (4053:5): [True: 0, False: 6.58M]
  ------------------
 4054|      0|	switch (v) {
 4055|      0|	case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (4055:2): [True: 0, False: 0]
  ------------------
 4056|      0|	case EXPRSXP: return;
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (4056:2): [True: 0, False: 0]
  ------------------
 4057|      0|	default: bad_SET_TYPEOF(TYPEOF(x), v);
  ------------------
  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
  |  Branch (4057:2): [True: 0, False: 0]
  ------------------
 4058|      0|	}
 4059|      0|    default: bad_SET_TYPEOF(TYPEOF(x), v);
  ------------------
  |  |  233|      0|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
  |  Branch (4059:5): [True: 0, False: 6.58M]
  ------------------
 4060|  6.58M|    }
 4061|  6.58M|}
memory.c:CHK2:
 4117|   141M|{
 4118|   141M|    x = CHK(x);
 4119|   141M|    if(nvec[TYPEOF(x)])
  ------------------
  |  |  233|   141M|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
  |  Branch (4119:8): [True: 0, False: 141M]
  ------------------
 4120|      0|	error("LENGTH or similar applied to %s object", R_typeToChar(x));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4121|   141M|    return x;
 4122|   141M|}
memory.c:CHKCONS:
 4378|  1.35G|{
 4379|  1.35G|    if (ALTREP(e))
  ------------------
  |  |  242|  1.35G|#define ALTREP(x)       ((x)->sxpinfo.alt)
  |  |  ------------------
  |  |  |  Branch (242:25): [True: 17.1k, False: 1.35G]
  |  |  ------------------
  ------------------
 4380|  17.1k|	return CHK(e);
 4381|  1.35G|    switch (TYPEOF(e)) {
  ------------------
  |  |  233|  1.35G|#define TYPEOF(x)	((x)->sxpinfo.type)
  ------------------
 4382|  1.23G|    case LISTSXP:
  ------------------
  |  |  113|  1.23G|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (4382:5): [True: 1.23G, False: 122M]
  ------------------
 4383|  1.26G|    case LANGSXP:
  ------------------
  |  |  117|  1.26G|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (4383:5): [True: 33.3M, False: 1.32G]
  ------------------
 4384|  1.28G|    case NILSXP:
  ------------------
  |  |  111|  1.28G|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (4384:5): [True: 17.6M, False: 1.33G]
  ------------------
 4385|  1.29G|    case DOTSXP:
  ------------------
  |  |  127|  1.29G|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (4385:5): [True: 11.9M, False: 1.34G]
  ------------------
 4386|  1.29G|    case CLOSXP:    /**** use separate accessors? */
  ------------------
  |  |  114|  1.29G|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (4386:5): [True: 20.4k, False: 1.35G]
  ------------------
 4387|  1.35G|    case BCODESXP:  /**** use separate accessors? */
  ------------------
  |  |  133|  1.35G|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (4387:5): [True: 59.5M, False: 1.29G]
  ------------------
 4388|  1.35G|    case ENVSXP:    /**** use separate accessors? */
  ------------------
  |  |  115|  1.35G|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (4388:5): [True: 0, False: 1.35G]
  ------------------
 4389|  1.35G|    case PROMSXP:   /**** use separate accessors? */
  ------------------
  |  |  116|  1.35G|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (4389:5): [True: 270, False: 1.35G]
  ------------------
 4390|  1.35G|    case EXTPTRSXP: /**** use separate accessors? */
  ------------------
  |  |  134|  1.35G|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (4390:5): [True: 0, False: 1.35G]
  ------------------
 4391|  1.35G|	return CHK(e);
 4392|      0|    default:
  ------------------
  |  Branch (4392:5): [True: 0, False: 1.35G]
  ------------------
 4393|      0|	error("CAR/CDR/TAG or similar applied to %s object",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 4394|      0|	      R_typeToChar(e));
 4395|  1.35G|    }
 4396|  1.35G|}

Rf_StrToInternal:
 1093|    816|{
 1094|    816|    int i;
 1095|   122k|    for (i = 0; R_FunTab[i].name; i++)
  ------------------
  |  Branch (1095:17): [True: 122k, False: 0]
  ------------------
 1096|   122k|	if (strcmp(s, R_FunTab[i].name) == 0) return i;
  ------------------
  |  Branch (1096:6): [True: 816, False: 121k]
  ------------------
 1097|      0|    return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
 1098|    816|}
Rf_InitNames:
 1221|      2|{
 1222|       |    /* allocate the symbol table */
 1223|      2|    if (!(R_SymbolTable = (SEXP *) calloc(HSIZE, sizeof(SEXP))))
  ------------------
  |  | 1174|      2|#define HSIZE	  49157	/* The size of the hash table for symbols */
  ------------------
  |  Branch (1223:9): [True: 0, False: 2]
  ------------------
 1224|      0|	R_Suicide("couldn't allocate memory for symbol table");
 1225|       |
 1226|       |    /* Create marker values */
 1227|      2|    R_UnboundValue = mkSymMarker(R_NilValue);
 1228|      2|    R_MissingArg = mkSymMarker(mkChar(""));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 1229|      2|    R_InBCInterpreter = mkSymMarker(mkChar("<in-bc-interp>"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 1230|      2|    R_RestartToken = mkSymMarker(mkChar(""));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 1231|      2|    R_CurrentExpression = mkSymMarker(mkChar("<current-expression>"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 1232|       |
 1233|       |    /* String constants (CHARSXP values) */
 1234|       |    /* Note: we don't want NA_STRING to be in the CHARSXP cache, so that
 1235|       |       mkChar("NA") is distinct from NA_STRING */
 1236|       |    /* NA_STRING */
 1237|      2|    NA_STRING = allocCharsxp(strlen("NA"));
  ------------------
  |  |  433|      2|#define NA_STRING	R_NaString
  ------------------
                  NA_STRING = allocCharsxp(strlen("NA"));
  ------------------
  |  | 1859|      2|# define allocCharsxp		Rf_allocCharsxp
  ------------------
 1238|      2|    strcpy(CHAR_RW(NA_STRING), "NA");
  ------------------
  |  |  930|      2|#define CHAR_RW(x)	((char *) CHAR(x))
  |  |  ------------------
  |  |  |  |  203|      2|#define CHAR(x) R_CHAR(x)
  |  |  ------------------
  ------------------
 1239|      2|    SET_CACHED(NA_STRING);  /* Mark it */
  ------------------
  |  |  433|      2|#define NA_STRING	R_NaString
  ------------------
 1240|      2|    R_print.na_string = NA_STRING;
  ------------------
  |  |  433|      2|#define NA_STRING	R_NaString
  ------------------
 1241|       |    /* R_BlankString */
 1242|      2|    R_BlankString = mkChar("");
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 1243|      2|    R_BlankScalarString = ScalarString(R_BlankString);
  ------------------
  |  | 1025|      2|#define ScalarString		Rf_ScalarString
  ------------------
 1244|      2|    MARK_NOT_MUTABLE(R_BlankScalarString);
 1245|       |
 1246|       |    /* Initialize the symbol Table */
 1247|  98.3k|    for (int i = 0; i < HSIZE; i++) R_SymbolTable[i] = R_NilValue;
  ------------------
  |  | 1174|  98.3k|#define HSIZE	  49157	/* The size of the hash table for symbols */
  ------------------
  |  Branch (1247:21): [True: 98.3k, False: 2]
  ------------------
 1248|       |
 1249|       |    /* Set up a set of globals so that a symbol table search can be
 1250|       |       avoided when matching something like dim or dimnames. */
 1251|      2|    SymbolShortcuts();
 1252|       |
 1253|       |    /*  Builtin Functions */
 1254|  1.54k|    for (int i = 0; R_FunTab[i].name; i++) installFunTab(i);
  ------------------
  |  Branch (1254:21): [True: 1.54k, False: 2]
  ------------------
 1255|       |
 1256|       |    /* Special base functions */
 1257|     94|    for (int i = 0; Spec_name[i]; i++)
  ------------------
  |  Branch (1257:21): [True: 92, False: 2]
  ------------------
 1258|     92|	SET_SPECIAL_SYMBOL(install(Spec_name[i]));
  ------------------
  |  |  934|     92|#define install			Rf_install
  ------------------
 1259|       |
 1260|      2|    R_initEvalSymbols();
 1261|      2|    initializeDDVALSymbols();
 1262|      2|    R_initialize_bcode();
 1263|      2|    R_init_altrep();
 1264|      2|}
Rf_install:
 1272|  3.52M|{
 1273|  3.52M|    SEXP sym;
 1274|  3.52M|    int i, hashcode;
 1275|       |
 1276|  3.52M|    hashcode = R_Newhashpjw(name);
 1277|  3.52M|    i = hashcode % HSIZE;
  ------------------
  |  | 1174|  3.52M|#define HSIZE	  49157	/* The size of the hash table for symbols */
  ------------------
 1278|       |    /* Check to see if the symbol is already present;  if it is, return it. */
 1279|  3.90M|    for (sym = R_SymbolTable[i]; sym != R_NilValue; sym = CDR(sym))
  ------------------
  |  Branch (1279:34): [True: 3.90M, False: 2.26k]
  ------------------
 1280|  3.90M|	if (strcmp(name, CHAR(PRINTNAME(CAR(sym)))) == 0) return (CAR(sym));
  ------------------
  |  |  203|  3.90M|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1280:6): [True: 3.51M, False: 385k]
  ------------------
 1281|       |    /* Create a new symbol node and link it into the table. */
 1282|  2.26k|    if (*name == '\0')
  ------------------
  |  Branch (1282:9): [True: 0, False: 2.26k]
  ------------------
 1283|      0|	error(_("attempt to use zero-length variable name"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt to use zero-length variable name"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1284|  2.26k|    if (strlen(name) > MAXIDSIZE)
  ------------------
  |  | 1175|  2.26k|#define MAXIDSIZE 10000	/* Largest symbol size,
  ------------------
  |  Branch (1284:9): [True: 0, False: 2.26k]
  ------------------
 1285|      0|	error(_("variable names are limited to %d bytes"), MAXIDSIZE);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("variable names are limited to %d bytes"), MAXIDSIZE);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              	error(_("variable names are limited to %d bytes"), MAXIDSIZE);
  ------------------
  |  | 1175|      0|#define MAXIDSIZE 10000	/* Largest symbol size,
  ------------------
 1286|  2.26k|    sym = mkSYMSXP(mkChar(name), R_UnboundValue);
  ------------------
  |  | 1959|  2.26k|# define mkSYMSXP		Rf_mkSYMSXP
  ------------------
                  sym = mkSYMSXP(mkChar(name), R_UnboundValue);
  ------------------
  |  |  998|  2.26k|#define mkChar			Rf_mkChar
  ------------------
 1287|  2.26k|    SET_HASHVALUE(PRINTNAME(sym), hashcode);
 1288|  2.26k|    SET_HASHASH(PRINTNAME(sym), 1);
 1289|       |
 1290|  2.26k|    R_SymbolTable[i] = CONS(sym, R_SymbolTable[i]);
  ------------------
  |  |  309|  2.26k|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 1291|  2.26k|    return (sym);
 1292|  3.52M|}
Rf_installNoTrChar:
 1299|  1.60M|{
 1300|  1.60M|    SEXP sym;
 1301|  1.60M|    int i, hashcode;
 1302|       |
 1303|  1.60M|    if( !HASHASH(charSXP) ) {
  ------------------
  |  Branch (1303:9): [True: 11.8k, False: 1.58M]
  ------------------
 1304|  11.8k|	hashcode = R_Newhashpjw(CHAR(charSXP));
  ------------------
  |  |  203|  11.8k|#define CHAR(x) R_CHAR(x)
  ------------------
 1305|  11.8k|	SET_HASHVALUE(charSXP, hashcode);
 1306|  11.8k|	SET_HASHASH(charSXP, 1);
 1307|  1.58M|    } else {
 1308|  1.58M|	hashcode = HASHVALUE(charSXP);
 1309|  1.58M|    }
 1310|  1.60M|    i = hashcode % HSIZE;
  ------------------
  |  | 1174|  1.60M|#define HSIZE	  49157	/* The size of the hash table for symbols */
  ------------------
 1311|       |    /* Check to see if the symbol is already present;  if it is, return it. */
 1312|  2.37M|    for (sym = R_SymbolTable[i]; sym != R_NilValue; sym = CDR(sym))
  ------------------
  |  Branch (1312:34): [True: 2.36M, False: 11.8k]
  ------------------
 1313|  2.36M|	if (strcmp(CHAR(charSXP), CHAR(PRINTNAME(CAR(sym)))) == 0) return (CAR(sym));
  ------------------
  |  |  203|  2.36M|#define CHAR(x) R_CHAR(x)
  ------------------
              	if (strcmp(CHAR(charSXP), CHAR(PRINTNAME(CAR(sym)))) == 0) return (CAR(sym));
  ------------------
  |  |  203|  2.36M|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (1313:6): [True: 1.58M, False: 774k]
  ------------------
 1314|       |    /* Create a new symbol node and link it into the table. */
 1315|  11.8k|    int len = LENGTH(charSXP);
 1316|  11.8k|    if (len == 0)
  ------------------
  |  Branch (1316:9): [True: 0, False: 11.8k]
  ------------------
 1317|      0|	error(_("attempt to use zero-length variable name"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt to use zero-length variable name"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1318|  11.8k|    if (len > MAXIDSIZE)
  ------------------
  |  | 1175|  11.8k|#define MAXIDSIZE 10000	/* Largest symbol size,
  ------------------
  |  Branch (1318:9): [True: 0, False: 11.8k]
  ------------------
 1319|      0|	error(_("variable names are limited to %d bytes"), MAXIDSIZE);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("variable names are limited to %d bytes"), MAXIDSIZE);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              	error(_("variable names are limited to %d bytes"), MAXIDSIZE);
  ------------------
  |  | 1175|      0|#define MAXIDSIZE 10000	/* Largest symbol size,
  ------------------
 1320|  11.8k|    if (IS_ASCII(charSXP) || (IS_UTF8(charSXP) && utf8locale) ||
  ------------------
  |  Branch (1320:9): [True: 11.8k, False: 0]
  |  Branch (1320:31): [True: 0, False: 0]
  |  Branch (1320:51): [True: 0, False: 0]
  ------------------
 1321|      0|					(IS_LATIN1(charSXP) && latin1locale) )
  ------------------
  |  Branch (1321:7): [True: 0, False: 0]
  |  Branch (1321:29): [True: 0, False: 0]
  ------------------
 1322|  11.8k|	sym = mkSYMSXP(charSXP, R_UnboundValue);
  ------------------
  |  | 1959|  11.8k|# define mkSYMSXP		Rf_mkSYMSXP
  ------------------
 1323|      0|    else {
 1324|       |	/* This branch is to match behaviour of install (which is older):
 1325|       |	   symbol C-string names are always interpreted as if
 1326|       |	   in the native locale, even when they are not in the native locale */
 1327|      0|	PROTECT(charSXP);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1328|      0|	sym = mkSYMSXP(mkChar(CHAR(charSXP)), R_UnboundValue);
  ------------------
  |  | 1959|      0|# define mkSYMSXP		Rf_mkSYMSXP
  ------------------
              	sym = mkSYMSXP(mkChar(CHAR(charSXP)), R_UnboundValue);
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
              	sym = mkSYMSXP(mkChar(CHAR(charSXP)), R_UnboundValue);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1329|      0|	SET_HASHVALUE(PRINTNAME(sym), hashcode);
 1330|      0|	SET_HASHASH(PRINTNAME(sym), 1);
 1331|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1332|      0|    }
 1333|       |
 1334|  11.8k|    R_SymbolTable[i] = CONS(sym, R_SymbolTable[i]);
  ------------------
  |  |  309|  11.8k|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 1335|  11.8k|    return (sym);
 1336|  1.60M|}
Rf_installS3Signature:
 1340|  1.55M|SEXP installS3Signature(const char *className, const char *methodName) {
 1341|       |
 1342|  1.55M|    const char *src;
 1343|  1.55M|    char signature[maxLength];
 1344|       |
 1345|  1.55M|    int i = 0;
 1346|  6.20M|    for(src = className; *src; src++) {
  ------------------
  |  Branch (1346:26): [True: 4.65M, False: 1.55M]
  ------------------
 1347|  4.65M|	if (i == maxLength)
  ------------------
  |  | 1338|  4.65M|#define maxLength 512
  ------------------
  |  Branch (1347:6): [True: 0, False: 4.65M]
  ------------------
 1348|      0|	    error(_("class name too long in '%s'"), className);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("class name too long in '%s'"), className);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1349|  4.65M|	signature[i++] = *src;
 1350|  4.65M|    }
 1351|       |
 1352|  1.55M|    if (i == maxLength)
  ------------------
  |  | 1338|  1.55M|#define maxLength 512
  ------------------
  |  Branch (1352:9): [True: 0, False: 1.55M]
  ------------------
 1353|      0|	error(_("class name too long in '%s'"), className);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("class name too long in '%s'"), className);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1354|  1.55M|    signature[i++] = '.';
 1355|       |
 1356|  12.4M|    for(src = methodName; *src; src++) {
  ------------------
  |  Branch (1356:27): [True: 10.9M, False: 1.55M]
  ------------------
 1357|  10.9M|	if (i == maxLength)
  ------------------
  |  | 1338|  10.9M|#define maxLength 512
  ------------------
  |  Branch (1357:6): [True: 0, False: 10.9M]
  ------------------
 1358|      0|	    error(_("class name too long in '%s'"), className);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("class name too long in '%s'"), className);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1359|  10.9M|	signature[i++] = *src;
 1360|  10.9M|    }
 1361|       |
 1362|  1.55M|    if (i == maxLength)
  ------------------
  |  | 1338|  1.55M|#define maxLength 512
  ------------------
  |  Branch (1362:9): [True: 0, False: 1.55M]
  ------------------
 1363|      0|	error(_("class name too long in '%s'"), className);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("class name too long in '%s'"), className);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1364|  1.55M|    signature[i] = 0;
 1365|       |
 1366|  1.55M|    return install(signature);
  ------------------
  |  |  934|  1.55M|#define install			Rf_install
  ------------------
 1367|  1.55M|}
do_internal:
 1373|  1.63k|{
 1374|  1.63k|    SEXP s, fun, ans;
 1375|  1.63k|    int save = R_PPStackTop;
 1376|  1.63k|    int flag;
 1377|  1.63k|    const void *vmax = vmaxget();
 1378|       |
 1379|  1.63k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.63k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1380|  1.63k|    s = CAR(args);
 1381|  1.63k|    if (!isPairList(s))
  ------------------
  |  |  961|  1.63k|#define isPairList		Rf_isPairList
  ------------------
  |  Branch (1381:9): [True: 0, False: 1.63k]
  ------------------
 1382|      0|	errorcall(call, _("invalid .Internal() argument"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid .Internal() argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1383|  1.63k|    fun = CAR(s);
 1384|  1.63k|    if (!isSymbol(fun))
  ------------------
  |  |  953|  1.63k|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1384:9): [True: 0, False: 1.63k]
  ------------------
 1385|      0|	errorcall(call, _("invalid .Internal() argument"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid .Internal() argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1386|  1.63k|    if (INTERNAL(fun) == R_NilValue)
  ------------------
  |  Branch (1386:9): [True: 0, False: 1.63k]
  ------------------
 1387|      0|	errorcall(call, _("there is no .Internal function '%s'"),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("there is no .Internal function '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1388|      0|		  CHAR(PRINTNAME(fun)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1389|       |
 1390|       |#ifdef CHECK_INTERNALS
 1391|       |    if(R_Is_Running > 1 && getenv("_R_CHECK_INTERNALS2_")) {
 1392|       |	// find out if we were called from a namespace.
 1393|       |	// inlining by the compiler can defeat this.
 1394|       |	const char *ns = "";
 1395|       |	SEXP e = env;
 1396|       |	for (int i = 0; i < 10; i++) {
 1397|       |	    if(R_IsNamespaceEnv(e)) {
 1398|       |		ns = CHAR(STRING_ELT(R_NamespaceEnvSpec(e), 0));
 1399|       |		break;
 1400|       |	    }
 1401|       |	    e = ENCLOS(e);
 1402|       |	    if (isNull(e)) break;
 1403|       |	}
 1404|       |	const char *fn = CHAR(PRINTNAME(fun));
 1405|       |	// nspackloader.R contained a .Internal call, so need this
 1406|       |	// until all packages have been re-installed.
 1407|       |	if (!strlen(ns) && strcmp(fn, "getRegisteredNamespace"))
 1408|       |	    errorcall(call,
 1409|       |		      ".Internal(%s()) not called from a base namespace\n", fn);
 1410|       |	if (strlen(ns)
 1411|       |	    && strcmp(ns, "base") && strcmp(ns, "tools")
 1412|       |	    && strcmp(ns, "utils") && strcmp(ns, "compiler"))
 1413|       |	    errorcall(call,
 1414|       |		      ".Internal(%s()) called from namespace '%s'\n", fn, ns);
 1415|       |    }
 1416|       |#endif
 1417|       |
 1418|       |
 1419|  1.63k|    args = CDR(s);
 1420|  1.63k|    if (TYPEOF(INTERNAL(fun)) == BUILTINSXP)
  ------------------
  |  |  119|  1.63k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (1420:9): [True: 244, False: 1.39k]
  ------------------
 1421|    244|	args = evalList(args, env, call, 0);
  ------------------
  |  | 1898|    244|# define evalList		Rf_evalList
  ------------------
 1422|  1.63k|    PROTECT(args);
  ------------------
  |  |  357|  1.63k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1423|  1.63k|    flag = PRIMPRINT(INTERNAL(fun));
  ------------------
  |  | 1350|  1.63k|#define PRIMPRINT(x)	(((R_FunTab[PRIMOFFSET(x)].eval)/100)%10)
  |  |  ------------------
  |  |  |  |  913|  1.63k|#define eval			Rf_eval
  |  |  ------------------
  ------------------
 1424|  1.63k|    R_Visible = flag != 1;
 1425|  1.63k|    ans = PRIMFUN(INTERNAL(fun)) (s, INTERNAL(fun), args, env);
  ------------------
  |  | 1345|  1.63k|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
 1426|       |    /* This resetting of R_Visible = FALSE was to fix PR#7397,
 1427|       |       now fixed in GEText */
 1428|  1.63k|    if (flag < 2) R_Visible = flag != 1;
  ------------------
  |  Branch (1428:9): [True: 1.54k, False: 96]
  ------------------
 1429|       |#ifdef CHECK_VISIBILITY
 1430|       |    if(flag < 2 && flag == R_Visible) {
 1431|       |	char *nm = CHAR(PRINTNAME(fun));
 1432|       |	if(strcmp(nm, "eval") && strcmp(nm, "options") && strcmp(nm, "Recall")
 1433|       |	   && strcmp(nm, "do.call") && strcmp(nm, "switch")
 1434|       |	   && strcmp(nm, "recordGraphics") && strcmp(nm, "writeBin")
 1435|       |	   && strcmp(nm, "NextMethod"))
 1436|       |	    printf("vis: internal %s\n", nm);
 1437|       |    }
 1438|       |#endif
 1439|  1.63k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.63k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1440|  1.63k|    check_stack_balance(INTERNAL(fun), save);
  ------------------
  |  | 1866|  1.63k|# define check_stack_balance	Rf_check_stack_balance
  ------------------
 1441|  1.63k|    vmaxset(vmax);
 1442|  1.63k|    return (ans);
 1443|  1.63k|}
names.c:createDDVALSymbol:
 1188|    130|static SEXP createDDVALSymbol(int n) {
 1189|    130|    char buf[15];
 1190|    130|    snprintf(buf, 15, "..%d", n);
 1191|    130|    return install(buf);
  ------------------
  |  |  934|    130|#define install			Rf_install
  ------------------
 1192|    130|}
names.c:mkSymMarker:
 1209|     10|{
 1210|     10|    PROTECT(pname);
  ------------------
  |  |  357|     10|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1211|     10|    SEXP ans = allocSExp(SYMSXP);
  ------------------
  |  |  874|     10|#define allocSExp		Rf_allocSExp
  ------------------
                  SEXP ans = allocSExp(SYMSXP);
  ------------------
  |  |  112|     10|#define SYMSXP	     1	  /* symbols */
  ------------------
 1212|     10|    SET_SYMVALUE(ans, ans);
 1213|     10|    SET_ATTRIB(ans, R_NilValue);
 1214|     10|    SET_PRINTNAME(ans, pname);
 1215|     10|    UNPROTECT(1);
  ------------------
  |  |  358|     10|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1216|     10|    return ans;
 1217|     10|}
names.c:SymbolShortcuts:
 1112|      2|{  /* ../include/Rinternals.h : */
 1113|      2|    R_Bracket2Symbol = install("[[");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1114|      2|    R_BracketSymbol = install("[");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1115|      2|    R_BraceSymbol = install("{");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1116|      2|    R_ClassSymbol = install("class");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1117|      2|    R_DeviceSymbol = install(".Device");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1118|      2|    R_DimNamesSymbol = install("dimnames");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1119|      2|    R_DimSymbol = install("dim");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1120|      2|    R_DollarSymbol = install("$");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1121|      2|    R_AtsignSymbol = install("@");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1122|      2|    R_DotsSymbol = install("...");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1123|      2|    R_DropSymbol = install("drop");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1124|      2|    R_EvalSymbol = install("eval");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1125|       |
 1126|       |    /* The last value symbol is used by the interpreter for recording
 1127|       |       the value of the most recently evaluated top level
 1128|       |       expression. To avoid creating an additional reference that
 1129|       |       would requires duplicating on modification this symbol does not
 1130|       |       increment reference counts on its symbol value.  This is safe
 1131|       |       since the symbol value corresponds to the base environment
 1132|       |       where complex assignments are not allowed.  */
 1133|      2|    R_LastvalueSymbol = install(".Last.value");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1134|      2|    DISABLE_REFCNT(R_LastvalueSymbol);
 1135|       |
 1136|      2|    R_LevelsSymbol = install("levels");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1137|      2|    R_ModeSymbol = install("mode");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1138|      2|    R_NameSymbol  = install("name");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1139|      2|    R_NamesSymbol = install("names");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1140|      2|    R_NaRmSymbol = install("na.rm");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1141|      2|    R_PackageSymbol = install("package");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1142|      2|    R_PreviousSymbol = install("previous");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1143|      2|    R_QuoteSymbol = install("quote");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1144|      2|    R_RowNamesSymbol = install("row.names");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1145|      2|    R_SeedsSymbol = install(".Random.seed");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1146|      2|    R_SortListSymbol = install("sort.list");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1147|      2|    R_SourceSymbol = install("source");   /* Not used by R or core packages */
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1148|      2|    R_TspSymbol = install("tsp");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1149|       |    /* ../include/Defn.h , i.e. non-public : */
 1150|      2|    R_CommentSymbol = install("comment");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1151|      2|    R_DotEnvSymbol = install(".Environment");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1152|      2|    R_ExactSymbol = install("exact");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1153|      2|    R_RecursiveSymbol = install("recursive");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1154|      2|    R_SrcfileSymbol = install("srcfile");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1155|      2|    R_SrcrefSymbol = install("srcref");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1156|      2|    R_WholeSrcrefSymbol = install("wholeSrcref");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1157|      2|    R_TmpvalSymbol = install("*tmp*");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1158|      2|    R_UseNamesSymbol = install("use.names");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1159|      2|    R_ColonSymbol = install(":");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1160|      2|    R_DoubleColonSymbol = install("::");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1161|      2|    R_TripleColonSymbol = install(":::");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1162|      2|    R_ConnIdSymbol = install("conn_id");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1163|      2|    R_DevicesSymbol = install(".Devices");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1164|      2|    R_baseSymbol = // <- back compatible, "deprecated"
 1165|      2|    R_BaseSymbol = install("base");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1166|      2|    R_SpecSymbol = install("spec");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1167|      2|    R_NamespaceEnvSymbol = install(".__NAMESPACE__.");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1168|      2|    R_AsCharacterSymbol = install("as.character");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1169|      2|    R_FunctionSymbol = install("function");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1170|       |
 1171|      2|    R_dot_Generic = install(".Generic");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1172|      2|    R_dot_Method = install(".Method");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1173|      2|    R_dot_Methods = install(".Methods");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1174|      2|    R_dot_defined = install(".defined");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1175|      2|    R_dot_target = install(".target");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1176|      2|    R_dot_Group = install(".Group");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1177|      2|    R_dot_Class = install(".Class");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1178|      2|    R_dot_GenericCallEnv = install(".GenericCallEnv");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1179|      2|    R_dot_GenericDefEnv = install(".GenericDefEnv");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1180|      2|    R_dot_packageName = install(".packageName");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1181|      2|}
names.c:installFunTab:
 1101|  1.54k|{
 1102|  1.54k|    SEXP prim;
 1103|       |    /* mkPRIMSXP caches its results, thus prim does not need protection */
 1104|  1.54k|    prim = mkPRIMSXP(i, R_FunTab[i].eval % 10);
  ------------------
  |  |  913|  1.54k|#define eval			Rf_eval
  ------------------
 1105|  1.54k|    if ((R_FunTab[i].eval % 100 )/10)
  ------------------
  |  |  913|  1.54k|#define eval			Rf_eval
  ------------------
  |  Branch (1105:9): [True: 1.11k, False: 422]
  ------------------
 1106|  1.11k|	SET_INTERNAL(install(R_FunTab[i].name), prim);
  ------------------
  |  |  934|  1.11k|#define install			Rf_install
  ------------------
 1107|    422|    else
 1108|    422|	SET_SYMVALUE(install(R_FunTab[i].name), prim);
  ------------------
  |  |  934|    422|#define install			Rf_install
  ------------------
 1109|  1.54k|}
names.c:initializeDDVALSymbols:
 1194|      2|static void initializeDDVALSymbols(void) {
 1195|    132|    for(int i = 0; i < N_DDVAL_SYMBOLS; i++) {
  ------------------
  |  | 1184|    132|#define N_DDVAL_SYMBOLS 65
  ------------------
  |  Branch (1195:20): [True: 130, False: 2]
  ------------------
 1196|    130|	DDVALSymbols[i] = createDDVALSymbol(i);
 1197|    130|    }
 1198|      2|}

R_LookupMethod:
  235|  1.55M|{
  236|  1.55M|    SEXP val, top = R_NilValue;	/* -Wall */
  237|  1.55M|    static SEXP s_S3MethodsTable = NULL;
  238|  1.55M|    PROTECT_INDEX validx;
  239|       |
  240|  1.55M|    if (TYPEOF(callrho) != ENVSXP) {
  ------------------
  |  |  115|  1.55M|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (240:9): [True: 0, False: 1.55M]
  ------------------
  241|      0|	if (TYPEOF(callrho) == NILSXP)
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (241:6): [True: 0, False: 0]
  ------------------
  242|      0|	    error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  243|      0|	else
  244|      0|	    error(_("bad generic call environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("bad generic call environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  245|      0|    }
  246|  1.55M|    if (defrho == R_BaseEnv)
  ------------------
  |  Branch (246:9): [True: 1.55M, False: 688]
  ------------------
  247|  1.55M|	defrho = R_BaseNamespace;
  248|    688|    else if (TYPEOF(defrho) != ENVSXP) {
  ------------------
  |  |  115|    688|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (248:14): [True: 0, False: 688]
  ------------------
  249|      0|	if (TYPEOF(defrho) == NILSXP)
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (249:6): [True: 0, False: 0]
  ------------------
  250|      0|	    error(_("use of NULL environment is defunct"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("use of NULL environment is defunct"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  251|      0|	else
  252|      0|	    error(_("bad generic definition environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("bad generic definition environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  253|      0|    }
  254|       |
  255|       |    /* This evaluates promises */
  256|  1.55M|    PROTECT(top = topenv(R_NilValue, callrho));
  ------------------
  |  |  357|  1.55M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  257|  1.55M|    val = findFunInEnvRange(method, callrho, top);
  258|  1.55M|    if(val != R_UnboundValue) {
  ------------------
  |  Branch (258:8): [True: 396, False: 1.55M]
  ------------------
  259|    396|	UNPROTECT(1); /* top */
  ------------------
  |  |  358|    396|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  260|    396|	return val;
  261|    396|    }
  262|       |
  263|  1.55M|    PROTECT_WITH_INDEX(val, &validx);
  ------------------
  |  |  366|  1.55M|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
  264|       |    /* We assume here that no one registered a non-function */
  265|  1.55M|    if (!s_S3MethodsTable)
  ------------------
  |  Branch (265:9): [True: 2, False: 1.55M]
  ------------------
  266|      2|	s_S3MethodsTable = install(".__S3MethodsTable__.");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  267|  1.55M|    SEXP table = R_findVarInFrame(defrho, s_S3MethodsTable);
  268|  1.55M|    if (TYPEOF(table) == PROMSXP) {
  ------------------
  |  |  116|  1.55M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (268:9): [True: 1.55M, False: 0]
  ------------------
  269|  1.55M|	PROTECT(table);
  ------------------
  |  |  357|  1.55M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  270|  1.55M|	table = eval(table, R_BaseEnv);
  ------------------
  |  |  913|  1.55M|#define eval			Rf_eval
  ------------------
  271|  1.55M|	UNPROTECT(1); /* table */
  ------------------
  |  |  358|  1.55M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  272|  1.55M|    }
  273|  1.55M|    if (TYPEOF(table) == ENVSXP) {
  ------------------
  |  |  115|  1.55M|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (273:9): [True: 1.55M, False: 0]
  ------------------
  274|  1.55M|	PROTECT(table);
  ------------------
  |  |  357|  1.55M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  275|  1.55M|	REPROTECT(val = R_findVarInFrame(table, method), validx);
  ------------------
  |  |  367|  1.55M|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  276|  1.55M|	UNPROTECT(1); /* table */
  ------------------
  |  |  358|  1.55M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  277|  1.55M|	if (TYPEOF(val) == PROMSXP)
  ------------------
  |  |  116|  1.55M|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (277:6): [True: 49, False: 1.55M]
  ------------------
  278|     49|	    REPROTECT(val = eval(val, rho), validx);
  ------------------
  |  |  367|     49|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  279|  1.55M|	if(val != R_UnboundValue) {
  ------------------
  |  Branch (279:5): [True: 49, False: 1.55M]
  ------------------
  280|     49|	    UNPROTECT(2); /* top, val */
  ------------------
  |  |  358|     49|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  281|     49|	    return val;
  282|     49|	}
  283|  1.55M|    }
  284|       |
  285|  1.55M|    if (top == R_GlobalEnv)
  ------------------
  |  Branch (285:9): [True: 0, False: 1.55M]
  ------------------
  286|      0|	top = R_BaseEnv;
  287|  1.55M|    else
  288|  1.55M|	top = ENCLOS(top);
  289|  1.55M|    REPROTECT(val = findFunWithBaseEnvAfterGlobalEnv(method, top),
  ------------------
  |  |  367|  1.55M|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  290|  1.55M|	      validx);
  291|       |
  292|  1.55M|    UNPROTECT(2); /* top, val */
  ------------------
  |  |  358|  1.55M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  293|  1.55M|    return val;
  294|  1.55M|}
Rf_createS3Vars:
  341|    449|		  SEXP dotGenericCallEnv, SEXP dotGenericDefEnv) {
  342|       |
  343|    449|    SEXP v = R_NilValue;
  344|    449|    v = addS3Var(v, R_dot_GenericDefEnv, dotGenericDefEnv);
  345|    449|    v = addS3Var(v, R_dot_GenericCallEnv, dotGenericCallEnv);
  346|    449|    v = addS3Var(v, R_dot_Group, dotGroup);
  347|    449|    v = addS3Var(v, R_dot_Method, dotMethod);
  348|    449|    v = addS3Var(v, R_dot_Class, dotClass);
  349|    449|    v = addS3Var(v, R_dot_Generic, dotGeneric);
  350|       |
  351|    449|    return v;
  352|    449|}
Rf_usemethod:
  483|   776k|{
  484|   776k|    SEXP klass, method, sxp;
  485|   776k|    SEXP op;
  486|   776k|    int i, nclass;
  487|   776k|    RCNTXT *cptr;
  488|       |
  489|       |    /* Get the context which UseMethod was called from. */
  490|       |
  491|   776k|    cptr = R_GlobalContext;
  492|   776k|    op = cptr->callfun;
  493|   776k|    PROTECT(klass = R_data_class2(obj));
  ------------------
  |  |  357|   776k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  494|       |
  495|   776k|    nclass = length(klass);
  ------------------
  |  |  987|   776k|#define length(x)		Rf_length(x)
  ------------------
  496|  1.55M|    for (i = 0; i < nclass; i++) {
  ------------------
  |  Branch (496:17): [True: 778k, False: 776k]
  ------------------
  497|   778k|	const void *vmax = vmaxget();
  498|   778k|	const char *ss = translateChar(STRING_ELT(klass, i));
  ------------------
  |  | 1037|   778k|#define translateChar		Rf_translateChar
  ------------------
  499|   778k|	method = installS3Signature(generic, ss);
  ------------------
  |  |  939|   778k|#define installS3Signature	Rf_installS3Signature
  ------------------
  500|   778k|	vmaxset(vmax);
  501|   778k|	sxp = R_LookupMethod(method, rho, callrho, defrho);
  502|   778k|	if (isFunction(sxp)) {
  ------------------
  |  |  948|   778k|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (502:6): [True: 114, False: 778k]
  ------------------
  503|    114|	    if(method == R_SortListSymbol && CLOENV(sxp) == R_BaseNamespace)
  ------------------
  |  Branch (503:9): [True: 0, False: 114]
  |  Branch (503:39): [True: 0, False: 0]
  ------------------
  504|      0|		continue; /* kludge because sort.list is not a method */
  505|    114|	    PROTECT(sxp);
  ------------------
  |  |  357|    114|#define PROTECT(s)	Rf_protect(s)
  ------------------
  506|    114|	    if (i > 0) {
  ------------------
  |  Branch (506:10): [True: 70, False: 44]
  ------------------
  507|     70|		SEXP dotClass = PROTECT(stringSuffix(klass, i));
  ------------------
  |  |  357|     70|#define PROTECT(s)	Rf_protect(s)
  ------------------
  508|     70|		setAttrib(dotClass, R_PreviousSymbol, klass);
  ------------------
  |  | 1027|     70|#define setAttrib		Rf_setAttrib
  ------------------
  509|     70|		*ans = dispatchMethod(op, sxp, dotClass, cptr, method, generic,
  510|     70|				      rho, callrho, defrho);
  511|     70|		UNPROTECT(1); /* dotClass */
  ------------------
  |  |  358|     70|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  512|     70|	    } else {
  513|     44|		*ans = dispatchMethod(op, sxp, klass, cptr, method, generic,
  514|     44|				      rho, callrho, defrho);
  515|     44|	    }
  516|    114|	    UNPROTECT(2); /* klass, sxp */
  ------------------
  |  |  358|    114|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  517|    114|	    return 1;
  518|    114|	}
  519|   778k|    }
  520|   776k|    method = installS3Signature(generic, "default");
  ------------------
  |  |  939|   776k|#define installS3Signature	Rf_installS3Signature
  ------------------
  521|   776k|    PROTECT(sxp = R_LookupMethod(method, rho, callrho, defrho));
  ------------------
  |  |  357|   776k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  522|   776k|    if (isFunction(sxp)) {
  ------------------
  |  |  948|   776k|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (522:9): [True: 281, False: 776k]
  ------------------
  523|    281|	*ans = dispatchMethod(op, sxp, R_NilValue, cptr, method, generic,
  524|    281|			      rho, callrho, defrho);
  525|    281|	UNPROTECT(2); /* klass, sxp */
  ------------------
  |  |  358|    281|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  526|    281|	return 1;
  527|    281|    }
  528|   776k|    UNPROTECT(2); /* klass, sxp */
  ------------------
  |  |  358|   776k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  529|   776k|    cptr->callflag = CTXT_RETURN;
  530|   776k|    return 0;
  531|   776k|}
do_usemethod:
  541|    343|{
  542|    343|    static SEXP do_usemethod_formals = NULL;
  543|    343|    if (do_usemethod_formals == NULL)
  ------------------
  |  Branch (543:9): [True: 2, False: 341]
  ------------------
  544|      2|	do_usemethod_formals = allocFormalsList2(install("generic"),
  ------------------
  |  |  865|      2|#define allocFormalsList2	Rf_allocFormalsList2
  ------------------
              	do_usemethod_formals = allocFormalsList2(install("generic"),
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  545|      2|						 install("object"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  546|       |
  547|    343|    SEXP argList = PROTECT(matchArgs_NR(do_usemethod_formals, args, call));
  ------------------
  |  |  357|    343|#define PROTECT(s)	Rf_protect(s)
  ------------------
  548|    343|    if (CAR(argList) == R_MissingArg)
  ------------------
  |  Branch (548:9): [True: 0, False: 343]
  ------------------
  549|      0|	errorcall(call, _("there must be a 'generic' argument"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("there must be a 'generic' argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  550|       |    // else
  551|    343|    SEXP generic = PROTECT(eval(CAR(argList), env));
  ------------------
  |  |  357|    343|#define PROTECT(s)	Rf_protect(s)
  ------------------
  552|    343|    if(!isString(generic) || LENGTH(generic) != 1)
  ------------------
  |  |  966|    343|#define isString		Rf_isString
  ------------------
  |  Branch (552:8): [True: 0, False: 343]
  |  Branch (552:30): [True: 0, False: 343]
  ------------------
  553|      0|	errorcall(call, _("'generic' argument must be a character string"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("'generic' argument must be a character string"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  554|       |
  555|       |    /* get environments needed for dispatching.
  556|       |       callenv = environment from which the generic was called
  557|       |       defenv = environment where the generic was defined */
  558|    343|    RCNTXT *cptr = R_GlobalContext;
  559|    343|    if ( !(cptr->callflag & CTXT_FUNCTION) || cptr->cloenv != env)
  ------------------
  |  Branch (559:10): [True: 0, False: 343]
  |  Branch (559:47): [True: 0, False: 343]
  ------------------
  560|      0|	errorcall(call, _("'UseMethod' used in an inappropriate fashion"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("'UseMethod' used in an inappropriate fashion"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  561|    343|    SEXP callenv = cptr->sysparent;
  562|       |    /* We need to find the generic to find out where it is defined.
  563|       |       This is set up to avoid getting caught by things like
  564|       |
  565|       |	mycoef <- function(x)
  566|       |       {
  567|       |	   mycoef <- function(x) stop("not this one")
  568|       |	   UseMethod("mycoef")
  569|       |       }
  570|       |
  571|       |	The generic need not be a closure (Henrik Bengtsson writes
  572|       |	UseMethod("$"), although only functions are documented.)
  573|       |    */
  574|    343|    SEXP defenv = topenv(R_NilValue, env);
  ------------------
  |  | 1036|    343|#define topenv		        Rf_topenv
  ------------------
  575|    343|    SEXP obj = PROTECT((CADR(argList) != R_MissingArg)
  ------------------
  |  |  357|    686|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  |  Branch (357:31): [True: 0, False: 343]
  |  |  ------------------
  ------------------
  576|    343|		       ? eval(CADR(argList), env)
  577|    343|		       : GetObject(cptr));
  578|    343|    SEXP ans;
  579|    343|    if (usemethod(translateChar(STRING_ELT(generic, 0)), obj, call, CDR(args),
  ------------------
  |  | 2005|    343|# define usemethod		Rf_usemethod
  ------------------
                  if (usemethod(translateChar(STRING_ELT(generic, 0)), obj, call, CDR(args),
  ------------------
  |  | 1037|    343|#define translateChar		Rf_translateChar
  ------------------
  |  Branch (579:9): [True: 343, False: 0]
  ------------------
  580|    343|		  env, callenv, defenv, &ans) == 1) {
  581|    343|	UNPROTECT(3); /* obj, generic, argList */
  ------------------
  |  |  358|    343|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  582|    343|	findcontext(CTXT_RETURN, env, ans); /* does not return */
  ------------------
  |  | 1901|    343|# define findcontext		Rf_findcontext
  ------------------
  583|    343|    }
  584|      0|    else { // no method found
  585|      0|#define CLLEN 1024
  586|      0|	char cl[CLLEN] = {0};
  587|      0|	SEXP klass = PROTECT(R_data_class2(obj));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  588|      0|	int nclass = length(klass);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  589|      0|	if(!nclass)
  ------------------
  |  Branch (589:5): [True: 0, False: 0]
  ------------------
  590|      0|	    errorcall(call, _("illegal class of length 0 when using method for '%s'"),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("illegal class of length 0 when using method for '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  591|      0|		      translateChar(STRING_ELT(generic, 0)));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  592|      0|	const char *c_name = translateChar(STRING_ELT(klass, 0));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  593|      0|	if (nclass == 1) {
  ------------------
  |  Branch (593:6): [True: 0, False: 0]
  ------------------
  594|      0|	    strncpy(cl, c_name, CLLEN-1); cl[CLLEN-1] = '\0';
  ------------------
  |  |  585|      0|#define CLLEN 1024
  ------------------
              	    strncpy(cl, c_name, CLLEN-1); cl[CLLEN-1] = '\0';
  ------------------
  |  |  585|      0|#define CLLEN 1024
  ------------------
  595|      0|	} else { // nclass >= 2
  596|      0|	    size_t cl_count = 3; // 3 : "c(" + \0
  597|      0|	    strcpy(cl, "c('");
  598|      0|	    for (int i = 0; i < nclass; i++) {
  ------------------
  |  Branch (598:22): [True: 0, False: 0]
  ------------------
  599|      0|		if(i > 0) {
  ------------------
  |  Branch (599:6): [True: 0, False: 0]
  ------------------
  600|      0|		    c_name = translateChar(STRING_ELT(klass, i));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  601|      0|		    cl_count += 4; // "', '"
  602|      0|		    if (cl_count < CLLEN) strcat(cl, "', '");
  ------------------
  |  |  585|      0|#define CLLEN 1024
  ------------------
  |  Branch (602:11): [True: 0, False: 0]
  ------------------
  603|      0|		}
  604|      0|		size_t len_nm = strlen(c_name);
  605|      0|		if (cl_count + len_nm >= CLLEN) {
  ------------------
  |  |  585|      0|#define CLLEN 1024
  ------------------
  |  Branch (605:7): [True: 0, False: 0]
  ------------------
  606|      0|		    cl_count += 2;
  607|      0|		    if(cl_count < CLLEN) strcat(cl, "..");
  ------------------
  |  |  585|      0|#define CLLEN 1024
  ------------------
  |  Branch (607:10): [True: 0, False: 0]
  ------------------
  608|      0|		    break;
  609|      0|		}
  610|       |		// else
  611|      0|		cl_count += len_nm;
  612|      0|		strcat(cl, c_name);
  613|      0|	    }
  614|      0|	    if (++cl_count < CLLEN) strcat(cl, "'");
  ------------------
  |  |  585|      0|#define CLLEN 1024
  ------------------
  |  Branch (614:10): [True: 0, False: 0]
  ------------------
  615|      0|	    if (++cl_count < CLLEN) strcat(cl, ")");
  ------------------
  |  |  585|      0|#define CLLEN 1024
  ------------------
  |  Branch (615:10): [True: 0, False: 0]
  ------------------
  616|      0|	}
  617|      0|	errorcall(call, _("no applicable method for '%s' applied to an object of class \"%s\""),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("no applicable method for '%s' applied to an object of class \"%s\""),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  618|      0|		  translateChar(STRING_ELT(generic, 0)), cl);
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  619|      0|    }
  620|    343|}
do_nextmethod:
  706|     16|{
  707|     16|    const char *sb, *sg, *sk;
  708|     16|    SEXP ans, s, t, klass, method, matchedarg, generic;
  709|     16|    SEXP nextfun, nextfunSignature;
  710|     16|    SEXP sysp, formals, newcall;
  711|     16|    SEXP group, basename;
  712|     16|    SEXP callenv, defenv;
  713|     16|    RCNTXT *cptr;
  714|     16|    int i, j;
  715|       |
  716|     16|    cptr = R_GlobalContext;
  717|     16|    cptr->callflag = CTXT_GENERIC;
  718|       |
  719|       |    /* get the env NextMethod was called from */
  720|     16|    sysp = R_GlobalContext->sysparent;
  721|     48|    while (cptr != NULL) {
  ------------------
  |  Branch (721:12): [True: 48, False: 0]
  ------------------
  722|     48|	if (cptr->callflag & CTXT_FUNCTION && cptr->cloenv == sysp) break;
  ------------------
  |  Branch (722:6): [True: 48, False: 0]
  |  Branch (722:40): [True: 16, False: 32]
  ------------------
  723|     32|	cptr = cptr->nextcontext;
  724|     32|    }
  725|     16|    if (cptr == NULL)
  ------------------
  |  Branch (725:9): [True: 0, False: 16]
  ------------------
  726|      0|	error(_("'NextMethod' called from outside a function"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'NextMethod' called from outside a function"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  727|       |
  728|     16|    PROTECT(newcall = shallow_duplicate(cptr->call));
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
  729|       |
  730|       |    /* eg get("print.ts")(1) or do.call() */
  731|     16|    if (TYPEOF(CAR(cptr->call)) != SYMSXP)
  ------------------
  |  |  112|     16|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (731:9): [True: 0, False: 16]
  ------------------
  732|      0|       error(_("'NextMethod' called from an anonymous function"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                     error(_("'NextMethod' called from an anonymous function"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  733|       |
  734|     16|    readS3VarsFromFrame(sysp, &generic, &group, &klass, &method,
  ------------------
  |  | 1016|     16|#define readS3VarsFromFrame	Rf_readS3VarsFromFrame
  ------------------
  735|     16|			&callenv, &defenv);
  736|       |
  737|       |    /* Find dispatching environments. Promises shouldn't occur, but
  738|       |       check to be on the safe side.  If the variables are not in the
  739|       |       environment (the method was called outside a method dispatch)
  740|       |       then chose reasonable defaults. */
  741|     16|    if (TYPEOF(callenv) == PROMSXP)
  ------------------
  |  |  116|     16|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (741:9): [True: 0, False: 16]
  ------------------
  742|      0|	callenv = eval(callenv, R_BaseEnv);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
  743|     16|    else if (callenv == R_UnboundValue)
  ------------------
  |  Branch (743:14): [True: 0, False: 16]
  ------------------
  744|      0|	callenv = env;
  745|     16|    if (TYPEOF(defenv) == PROMSXP) defenv = eval(defenv, R_BaseEnv);
  ------------------
  |  |  116|     16|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
                  if (TYPEOF(defenv) == PROMSXP) defenv = eval(defenv, R_BaseEnv);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
  |  Branch (745:9): [True: 0, False: 16]
  ------------------
  746|     16|    else if (defenv == R_UnboundValue) defenv = R_GlobalEnv;
  ------------------
  |  Branch (746:14): [True: 0, False: 16]
  ------------------
  747|       |
  748|       |    /* set up the arglist */
  749|     16|    s = cptr->callfun;
  750|       |
  751|     16|    if (TYPEOF(s) != CLOSXP){ /* R_LookupMethod looked for a function */
  ------------------
  |  |  114|     16|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (751:9): [True: 0, False: 16]
  ------------------
  752|      0|	if (s == R_UnboundValue)
  ------------------
  |  Branch (752:6): [True: 0, False: 0]
  ------------------
  753|      0|	    error(_("no calling generic was found: was a method called directly?"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("no calling generic was found: was a method called directly?"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  754|      0|	else
  755|      0|	    errorcall(R_NilValue,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  756|      0|		  _("'function' is not a function, but of type %d"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  757|      0|		  TYPEOF(s));
  758|      0|    }
  759|       |    /* get formals and actuals; attach the names of the formals to
  760|       |       the actuals, expanding any ... that occurs */
  761|     16|    formals = FORMALS(s);
  762|     16|    PROTECT(matchedarg = patchArgsByActuals(formals, cptr->promargs, cptr->cloenv));
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
  763|       |
  764|       |    /*
  765|       |      Now see if there were any other arguments passed in
  766|       |      Currently we seem to only allow named args to change
  767|       |      or to be added, this is at variance with p. 470 of the
  768|       |      White Book
  769|       |    */
  770|       |
  771|     16|    s = CADDR(args); /* this is ... and we need to see if it's bound */
  772|     16|    if (s == R_DotsSymbol) {
  ------------------
  |  Branch (772:9): [True: 16, False: 0]
  ------------------
  773|     16|	t = R_findVarInFrame(env, s);
  774|     16|	if (t != R_NilValue && t != R_MissingArg) {
  ------------------
  |  Branch (774:6): [True: 16, False: 0]
  |  Branch (774:25): [True: 0, False: 16]
  ------------------
  775|      0|	    SET_TYPEOF(t, LISTSXP); /* a safe mutation */
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  776|      0|	    s = matchmethargs(matchedarg, t);
  777|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  778|      0|	    PROTECT(matchedarg = s);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  779|      0|	    newcall = fixcall(newcall, matchedarg);
  780|      0|	}
  781|     16|    }
  782|      0|    else
  783|      0|	error(_("wrong argument ..."));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("wrong argument ..."));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  784|       |
  785|       |    /*
  786|       |      .Class is used to determine the next method; if it doesn't
  787|       |      exist the first argument to the current method is used
  788|       |      the second argument to NextMethod is another option but
  789|       |      isn't currently used).
  790|       |    */
  791|     16|    if (klass == R_UnboundValue) {
  ------------------
  |  Branch (791:9): [True: 0, False: 16]
  ------------------
  792|       |	/* we can get the object from actuals directly, but this
  793|       |	   branch seems to be very cold if not dead */
  794|      0|	s = GetObject(cptr);
  795|      0|	if (!isObject(s)) error(_("object not specified"));
  ------------------
  |  |  959|      0|#define isObject		Rf_isObject
  ------------------
              	if (!isObject(s)) error(_("object not specified"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if (!isObject(s)) error(_("object not specified"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (795:6): [True: 0, False: 0]
  ------------------
  796|      0|	klass = getAttrib(s, R_ClassSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  797|      0|    }
  798|       |
  799|       |    /* the generic comes from either the sysparent or it's named */
  800|     16|    if (generic == R_UnboundValue)
  ------------------
  |  Branch (800:9): [True: 0, False: 16]
  ------------------
  801|      0|	generic = eval(CAR(args), env);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
  802|     16|    if (generic == R_NilValue)
  ------------------
  |  Branch (802:9): [True: 0, False: 16]
  ------------------
  803|      0|	error(_("generic function not specified"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("generic function not specified"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  804|     16|    PROTECT(generic);
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
  805|       |
  806|     16|    if (!isString(generic) || LENGTH(generic) != 1)
  ------------------
  |  |  966|     16|#define isString		Rf_isString
  ------------------
  |  Branch (806:9): [True: 0, False: 16]
  |  Branch (806:31): [True: 0, False: 16]
  ------------------
  807|      0|	error(_("invalid generic argument to 'NextMethod'"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid generic argument to 'NextMethod'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  808|       |
  809|     16|    if (CHAR(STRING_ELT(generic, 0))[0] == '\0')
  ------------------
  |  |  203|     16|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (809:9): [True: 0, False: 16]
  ------------------
  810|      0|	error(_("generic function not specified"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("generic function not specified"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  811|       |
  812|       |    /* determine whether we are in a Group dispatch */
  813|       |    /* determine the root: either the group or the generic will be it */
  814|     16|    if (group == R_UnboundValue) {
  ------------------
  |  Branch (814:9): [True: 0, False: 16]
  ------------------
  815|      0|	group = R_BlankScalarString;
  816|      0|	basename = generic;
  817|     16|    } else {
  818|     16|	if (!isString(group) || LENGTH(group) != 1)
  ------------------
  |  |  966|     16|#define isString		Rf_isString
  ------------------
  |  Branch (818:6): [True: 0, False: 16]
  |  Branch (818:26): [True: 0, False: 16]
  ------------------
  819|      0|	    error(_("invalid 'group' argument found in 'NextMethod'"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid 'group' argument found in 'NextMethod'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  820|     16|	if (CHAR(STRING_ELT(group, 0))[0] == '\0') basename = generic;
  ------------------
  |  |  203|     16|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (820:6): [True: 16, False: 0]
  ------------------
  821|      0|	else basename = group;
  822|     16|    }
  823|     16|    PROTECT(group);
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
  824|       |
  825|     16|    nextfun = R_NilValue;
  826|     16|    nextfunSignature = R_NilValue;
  827|       |
  828|       |    /*
  829|       |       Find the method currently being invoked and jump over the current call
  830|       |       If t is R_UnboundValue then we called the current method directly
  831|       |    */
  832|     16|    const void *vmax = vmaxget(); /* needed for translateChar */
  833|     16|    const char *b = NULL;
  834|     16|    if (method != R_UnboundValue) {
  ------------------
  |  Branch (834:9): [True: 16, False: 0]
  ------------------
  835|     16|	if (!isString(method))
  ------------------
  |  |  966|     16|#define isString		Rf_isString
  ------------------
  |  Branch (835:6): [True: 0, False: 16]
  ------------------
  836|      0|	    error(_("wrong value for .Method"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("wrong value for .Method"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  837|     16|	for(i = 0; i < LENGTH(method); i++) {
  ------------------
  |  Branch (837:13): [True: 16, False: 0]
  ------------------
  838|     16|	    b = translateChar(STRING_ELT(method, i));
  ------------------
  |  | 1037|     16|#define translateChar		Rf_translateChar
  ------------------
  839|     16|	    if (strlen(b)) break;
  ------------------
  |  Branch (839:10): [True: 16, False: 0]
  ------------------
  840|     16|	}
  841|       |	/* for binary operators check that the second argument's method
  842|       |	   is the same or absent */
  843|     32|	for(j = i; j < LENGTH(method); j++) {
  ------------------
  |  Branch (843:13): [True: 16, False: 16]
  ------------------
  844|     16|	    const char *bb = translateChar(STRING_ELT(method, j));
  ------------------
  |  | 1037|     16|#define translateChar		Rf_translateChar
  ------------------
  845|     16|	    if (strlen(bb) && strcmp(b,bb))
  ------------------
  |  Branch (845:10): [True: 16, False: 0]
  |  Branch (845:24): [True: 0, False: 16]
  ------------------
  846|      0|		warning(_("Incompatible methods ignored"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		warning(_("Incompatible methods ignored"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  847|     16|	}
  848|     16|    }
  849|      0|    else {
  850|      0|	b = CHAR(PRINTNAME(CAR(cptr->call)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  851|      0|    }
  852|       |
  853|     16|    sb = translateChar(STRING_ELT(basename, 0));
  ------------------
  |  | 1037|     16|#define translateChar		Rf_translateChar
  ------------------
  854|     16|    Rboolean foundSignature = FALSE;
  855|     16|    for (j = 0; j < LENGTH(klass); j++) {
  ------------------
  |  Branch (855:17): [True: 16, False: 0]
  ------------------
  856|     16|	sk = translateChar(STRING_ELT(klass, j));
  ------------------
  |  | 1037|     16|#define translateChar		Rf_translateChar
  ------------------
  857|     16|	if (equalS3Signature(b, sb, sk)) { /* b == sb.sk */
  ------------------
  |  Branch (857:6): [True: 16, False: 0]
  ------------------
  858|     16|	    foundSignature = TRUE;
  859|     16|	    break;
  860|     16|	}
  861|     16|    }
  862|       |
  863|     16|    if (foundSignature) /* we found a match and start from there */
  ------------------
  |  Branch (863:9): [True: 16, False: 0]
  ------------------
  864|     16|      j++;
  865|      0|    else
  866|      0|      j = 0;  /* no match so start with the first element of .Class */
  867|       |
  868|       |    /* we need the value of i on exit from the for loop to figure out
  869|       |	   how many classes to drop. */
  870|       |
  871|     16|    sg = translateChar(STRING_ELT(generic, 0));
  ------------------
  |  | 1037|     16|#define translateChar		Rf_translateChar
  ------------------
  872|     16|    for (i = j ; i < LENGTH(klass); i++) {
  ------------------
  |  Branch (872:18): [True: 0, False: 16]
  ------------------
  873|      0|	sk = translateChar(STRING_ELT(klass, i));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  874|      0|	nextfunSignature = installS3Signature(sg, sk);
  ------------------
  |  |  939|      0|#define installS3Signature	Rf_installS3Signature
  ------------------
  875|      0|	nextfun = R_LookupMethod(nextfunSignature, env, callenv, defenv);
  876|      0|	if (isFunction(nextfun)) break;
  ------------------
  |  |  948|      0|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (876:6): [True: 0, False: 0]
  ------------------
  877|      0|	if (group != R_UnboundValue) {
  ------------------
  |  Branch (877:6): [True: 0, False: 0]
  ------------------
  878|       |	    /* if not Generic.foo, look for Group.foo */
  879|      0|	    nextfunSignature = installS3Signature(sb, sk);
  ------------------
  |  |  939|      0|#define installS3Signature	Rf_installS3Signature
  ------------------
  880|      0|	    nextfun = R_LookupMethod(nextfunSignature, env, callenv, defenv);
  881|      0|	    if(isFunction(nextfun))
  ------------------
  |  |  948|      0|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (881:9): [True: 0, False: 0]
  ------------------
  882|      0|		break;
  883|      0|	}
  884|      0|	if (isFunction(nextfun))
  ------------------
  |  |  948|      0|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (884:6): [True: 0, False: 0]
  ------------------
  885|      0|	    break;
  886|      0|    }
  887|     16|    if (!isFunction(nextfun)) {
  ------------------
  |  |  948|     16|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (887:9): [True: 16, False: 0]
  ------------------
  888|     16|	nextfunSignature = installS3Signature(sg, "default");
  ------------------
  |  |  939|     16|#define installS3Signature	Rf_installS3Signature
  ------------------
  889|     16|	nextfun = R_LookupMethod(nextfunSignature, env, callenv, defenv);
  890|       |	/* If there is no default method, try the generic itself,
  891|       |	   provided it is primitive or a wrapper for a .Internal
  892|       |	   function of the same name.
  893|       |	 */
  894|     16|	if (!isFunction(nextfun)) {
  ------------------
  |  |  948|     16|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (894:6): [True: 16, False: 0]
  ------------------
  895|     16|	    t = install(sg);
  ------------------
  |  |  934|     16|#define install			Rf_install
  ------------------
  896|     16|	    nextfun = R_findVar(t, env);
  897|     16|	    if (TYPEOF(nextfun) == PROMSXP) {
  ------------------
  |  |  116|     16|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (897:10): [True: 0, False: 16]
  ------------------
  898|      0|		PROTECT(nextfun);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  899|      0|		nextfun = eval(nextfun, env);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
  900|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  901|      0|	    }
  902|     16|	    if (!isFunction(nextfun))
  ------------------
  |  |  948|     16|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (902:10): [True: 0, False: 16]
  ------------------
  903|      0|		error(_("no method to invoke"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("no method to invoke"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  904|     16|	    if (TYPEOF(nextfun) == CLOSXP) {
  ------------------
  |  |  114|     16|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (904:10): [True: 0, False: 16]
  ------------------
  905|      0|		if (INTERNAL(t) != R_NilValue)
  ------------------
  |  Branch (905:7): [True: 0, False: 0]
  ------------------
  906|      0|		    nextfun = INTERNAL(t);
  907|      0|		else {
  908|      0|		    nextfun = getPrimitive(t);
  909|      0|		    if (nextfun == R_NilValue)
  ------------------
  |  Branch (909:11): [True: 0, False: 0]
  ------------------
  910|      0|		        error(_("no method to invoke"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		        error(_("no method to invoke"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  911|      0|		}
  912|      0|	    }
  913|     16|	}
  914|     16|    }
  915|     16|    PROTECT(nextfun);
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
  916|     16|    PROTECT(s = stringSuffix(klass, i));
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
  917|     16|    setAttrib(s, R_PreviousSymbol, klass);
  ------------------
  |  | 1027|     16|#define setAttrib		Rf_setAttrib
  ------------------
  918|       |    /* It is possible that if a method was called directly that
  919|       |	'method' is unset */
  920|     16|    if (method != R_UnboundValue) {
  ------------------
  |  Branch (920:9): [True: 16, False: 0]
  ------------------
  921|       |	/* for Ops we need `method' to be a vector */
  922|     16|	PROTECT(method = duplicate(method));
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
  923|     32|	for(j = 0; j < LENGTH(method); j++) {
  ------------------
  |  Branch (923:13): [True: 16, False: 16]
  ------------------
  924|     16|	    if (strlen(CHAR(STRING_ELT(method,j))))
  ------------------
  |  |  203|     16|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (924:10): [True: 16, False: 0]
  ------------------
  925|     16|		SET_STRING_ELT(method, j,  PRINTNAME(nextfunSignature));
  926|     16|	}
  927|     16|    } else
  928|      0|	PROTECT(method = PRINTNAME(nextfunSignature));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  929|       |
  930|     16|    SEXP newvars = PROTECT(createS3Vars(
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
  931|     16|	generic,
  932|     16|	group,
  933|     16|	s,
  934|     16|	method,
  935|     16|	callenv,
  936|     16|	defenv
  937|     16|    ));
  938|       |
  939|     16|    SETCAR(newcall, nextfunSignature);
  940|       |
  941|       |    /* applyMethod expects that the parent of the caller is the caller
  942|       |       of the generic, so fixup by brute force. This should fix
  943|       |       PR#15267 --pd */
  944|     16|    R_GlobalContext->sysparent = callenv;
  945|       |
  946|     16|    ans = applyMethod(newcall, nextfun, matchedarg, env, newvars);
  947|     16|    vmaxset(vmax);
  948|     16|    UNPROTECT(8);
  ------------------
  |  |  358|     16|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  949|     16|    return(ans);
  950|     16|}
do_unclass:
  954|      2|{
  955|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  956|      2|    check1arg(args, call, "x");
  ------------------
  |  | 1867|      2|# define check1arg		Rf_check1arg
  ------------------
  957|       |
  958|      2|    if (isObject(CAR(args))) {
  ------------------
  |  |  959|      2|#define isObject		Rf_isObject
  ------------------
  |  Branch (958:9): [True: 2, False: 0]
  ------------------
  959|      2|	switch(TYPEOF(CAR(args))) {
  960|      0|	case ENVSXP:
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (960:2): [True: 0, False: 2]
  ------------------
  961|      0|	    errorcall(call, _("cannot unclass an environment"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("cannot unclass an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  962|      0|	    break;
  963|      0|	case EXTPTRSXP:
  ------------------
  |  |  134|      0|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (963:2): [True: 0, False: 2]
  ------------------
  964|      0|	    errorcall(call, _("cannot unclass an external pointer"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("cannot unclass an external pointer"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  965|      0|	    break;
  966|      2|	default:
  ------------------
  |  Branch (966:2): [True: 2, False: 0]
  ------------------
  967|      2|	    break;
  968|      2|	}
  969|      2|	if (MAYBE_REFERENCED(CAR(args)))
  ------------------
  |  |  251|      2|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  970|      2|	    SETCAR(args, R_shallow_duplicate_attr(CAR(args)));
  971|      2|	setAttrib(CAR(args), R_ClassSymbol, R_NilValue);
  ------------------
  |  | 1027|      2|#define setAttrib		Rf_setAttrib
  ------------------
  972|      2|    }
  973|      2|    return CAR(args);
  974|      2|}
do_inherits:
 1077|  2.73k|{
 1078|  2.73k|    checkArity(op, args);
  ------------------
  |  | 1788|  2.73k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1079|       |
 1080|  2.73k|    SEXP x = CAR(args);
 1081|  2.73k|    SEXP what = CADR(args);
 1082|  2.73k|    SEXP which = CADDR(args);
 1083|       |
 1084|  2.73k|    if (OBJECT(what) && TYPEOF(what) != STRSXP) {
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1084:9): [True: 0, False: 2.73k]
  |  Branch (1084:25): [True: 0, False: 0]
  ------------------
 1085|      0|	SEXP name = nameOfClass(what, env);
 1086|      0|	if (name != R_NilValue) {
  ------------------
  |  Branch (1086:6): [True: 0, False: 0]
  ------------------
 1087|      0|	    PROTECT(name);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1088|      0|	    SEXP val = inherits3(x, name, which);
 1089|      0|	    UNPROTECT(1); /* name */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1090|      0|	    return val;
 1091|      0|	}
 1092|       |	/* fall through */
 1093|      0|    }
 1094|       |
 1095|  2.73k|    return inherits3(x, what, which);
 1096|  2.73k|}
R_set_standardGeneric_ptr:
 1217|      2|{
 1218|      2|    R_stdGen_ptr_t old = R_standardGeneric_ptr;
 1219|      2|    R_standardGeneric_ptr = val;
 1220|      2|    if(envir && !isNull(envir))
  ------------------
  |  |  956|      2|#define isNull			Rf_isNull
  ------------------
  |  Branch (1220:8): [True: 2, False: 0]
  |  Branch (1220:17): [True: 2, False: 0]
  ------------------
 1221|      2|	R_MethodsNamespace = envir;
 1222|       |    /* just in case ... */
 1223|      2|    if(!R_MethodsNamespace)
  ------------------
  |  Branch (1223:8): [True: 0, False: 2]
  ------------------
 1224|      0|	R_MethodsNamespace = R_GlobalEnv;
 1225|      2|    return old;
 1226|      2|}
isMethodsDispatchOn:
 1255|  2.11k|{
 1256|  2.11k|    return !NOT_METHODS_DISPATCH_PTR(R_standardGeneric_ptr);
  ------------------
  |  | 1206|  2.11k|#define NOT_METHODS_DISPATCH_PTR(ptr) (ptr == 0 || ptr == dispatchNonGeneric)
  |  |  ------------------
  |  |  |  Branch (1206:40): [True: 2, False: 2.11k]
  |  |  |  Branch (1206:52): [True: 0, False: 2.11k]
  |  |  ------------------
  ------------------
 1257|  2.11k|}
do_S4on:
 1269|    208|{
 1270|    208|    if(length(args) == 0) return ScalarLogical(isMethodsDispatchOn());
  ------------------
  |  |  987|    208|#define length(x)		Rf_length(x)
  ------------------
                  if(length(args) == 0) return ScalarLogical(isMethodsDispatchOn());
  ------------------
  |  | 1023|    208|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  |  Branch (1270:8): [True: 208, False: 0]
  ------------------
 1271|      0|    return R_isMethodsDispatchOn(CAR(args));
 1272|    208|}
R_set_prim_method:
 1366|      2|{
 1367|      2|    const char *code_string;
 1368|      2|    const void *vmax = vmaxget();
 1369|      2|    if(!isValidString(code_vec))
  ------------------
  |  |  972|      2|#define isValidString		Rf_isValidString
  ------------------
  |  Branch (1369:8): [True: 0, False: 2]
  ------------------
 1370|      0|	error(_("argument '%s' must be a character string"), "code");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("argument '%s' must be a character string"), "code");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1371|      2|    code_string = translateChar(asChar(code_vec));
  ------------------
  |  | 1037|      2|#define translateChar		Rf_translateChar
  ------------------
                  code_string = translateChar(asChar(code_vec));
  ------------------
  |  |  882|      2|#define asChar			Rf_asChar
  ------------------
 1372|       |    /* with a NULL op, turns all primitive matching off or on (used to avoid possible infinite
 1373|       |     recursion in methods computations*/
 1374|      2|    if(op == R_NilValue) {
  ------------------
  |  Branch (1374:8): [True: 0, False: 2]
  ------------------
 1375|      0|	SEXP value = allowPrimitiveMethods ? mkTrue() : mkFalse();
  ------------------
  |  | 1960|      0|# define mkTrue			Rf_mkTrue
  ------------------
              	SEXP value = allowPrimitiveMethods ? mkTrue() : mkFalse();
  ------------------
  |  | 1956|      0|# define mkFalse		Rf_mkFalse
  ------------------
  |  Branch (1375:15): [True: 0, False: 0]
  ------------------
 1376|      0|	switch(code_string[0]) {
 1377|      0|	case 'c': case 'C':/* clear */
  ------------------
  |  Branch (1377:2): [True: 0, False: 0]
  |  Branch (1377:12): [True: 0, False: 0]
  ------------------
 1378|      0|	    allowPrimitiveMethods = FALSE; break;
 1379|      0|	case 's': case 'S': /* set */
  ------------------
  |  Branch (1379:2): [True: 0, False: 0]
  |  Branch (1379:12): [True: 0, False: 0]
  ------------------
 1380|      0|	    allowPrimitiveMethods = TRUE; break;
 1381|      0|	default: /* just report the current state */
  ------------------
  |  Branch (1381:2): [True: 0, False: 0]
  ------------------
 1382|      0|	    break;
 1383|      0|	}
 1384|      0|	return value;
 1385|      0|    }
 1386|      2|    if (!isPrimitive(op)) {
  ------------------
  |  |  962|      2|#define isPrimitive		Rf_isPrimitive
  ------------------
  |  Branch (1386:9): [True: 0, False: 2]
  ------------------
 1387|      0|        SEXP internal = R_do_slot(op, install("internal"));
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 1388|      0|        op = INTERNAL(installTrChar(asChar(internal)));
  ------------------
  |  |  937|      0|#define installTrChar		Rf_installTrChar
  ------------------
                      op = INTERNAL(installTrChar(asChar(internal)));
  ------------------
  |  |  882|      0|#define asChar			Rf_asChar
  ------------------
 1389|      0|        if (op == R_NilValue) {
  ------------------
  |  Branch (1389:13): [True: 0, False: 0]
  ------------------
 1390|      0|          error("'internal' slot does not name an internal function: %s",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 1391|      0|                CHAR(asChar(internal)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1392|      0|        }
 1393|      0|    }
 1394|      2|    do_set_prim_method(op, code_string, fundef, mlist);
 1395|      2|    vmaxset(vmax);
 1396|      2|    return fname;
 1397|      2|}
do_set_prim_method:
 1424|      2|{
 1425|      2|    int offset = 0;
 1426|      2|    prim_methods_t code = NO_METHODS; /* -Wall */
 1427|      2|    SEXP value;
 1428|      2|    Rboolean errorcase = FALSE;
 1429|      2|    switch(code_string[0]) {
 1430|      0|    case 'c': /* clear */
  ------------------
  |  Branch (1430:5): [True: 0, False: 2]
  ------------------
 1431|      0|	code = NO_METHODS; break;
 1432|      2|    case 'r': /* reset */
  ------------------
  |  Branch (1432:5): [True: 2, False: 0]
  ------------------
 1433|      2|	code = NEEDS_RESET; break;
 1434|      0|    case 's': /* set or suppress */
  ------------------
  |  Branch (1434:5): [True: 0, False: 2]
  ------------------
 1435|      0|	switch(code_string[1]) {
 1436|      0|	case 'e': code = HAS_METHODS; break;
  ------------------
  |  Branch (1436:2): [True: 0, False: 0]
  ------------------
 1437|      0|	case 'u': code = SUPPRESSED; break;
  ------------------
  |  Branch (1437:2): [True: 0, False: 0]
  ------------------
 1438|      0|	default: errorcase = TRUE;
  ------------------
  |  Branch (1438:2): [True: 0, False: 0]
  ------------------
 1439|      0|	}
 1440|      0|	break;
 1441|      0|    default:
  ------------------
  |  Branch (1441:5): [True: 0, False: 2]
  ------------------
 1442|      0|	errorcase = TRUE;
 1443|      2|    }
 1444|      2|    if(errorcase) {
  ------------------
  |  Branch (1444:8): [True: 0, False: 2]
  ------------------
 1445|      0|	error(_("invalid primitive methods code (\"%s\"): should be \"clear\", \"reset\", \"set\", or \"suppress\""), code_string);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid primitive methods code (\"%s\"): should be \"clear\", \"reset\", \"set\", or \"suppress\""), code_string);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1446|      0|	return R_NilValue;
 1447|      0|    }
 1448|      2|    switch(TYPEOF(op)) {
 1449|      2|    case BUILTINSXP: case SPECIALSXP:
  ------------------
  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
                  case BUILTINSXP: case SPECIALSXP:
  ------------------
  |  |  118|      2|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (1449:5): [True: 0, False: 2]
  |  Branch (1449:22): [True: 2, False: 0]
  ------------------
 1450|      2|	offset = PRIMOFFSET(op);
 1451|      2|	break;
 1452|      0|    default:
  ------------------
  |  Branch (1452:5): [True: 0, False: 2]
  ------------------
 1453|      0|	error(_("invalid object: must be a primitive function"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid object: must be a primitive function"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1454|      2|    }
 1455|      2|    if(offset >= maxMethodsOffset) {
  ------------------
  |  Branch (1455:8): [True: 2, False: 0]
  ------------------
 1456|      2|	int n;
 1457|      2|	n = offset + 1;
 1458|      2|	if(n < DEFAULT_N_PRIM_METHODS)
  ------------------
  |  | 1361|      2|#define DEFAULT_N_PRIM_METHODS 100
  ------------------
  |  Branch (1458:5): [True: 2, False: 0]
  ------------------
 1459|      2|	    n = DEFAULT_N_PRIM_METHODS;
  ------------------
  |  | 1361|      2|#define DEFAULT_N_PRIM_METHODS 100
  ------------------
 1460|      2|	if(n < 2*maxMethodsOffset)
  ------------------
  |  Branch (1460:5): [True: 0, False: 2]
  ------------------
 1461|      0|	    n = 2 * maxMethodsOffset;
 1462|      2|	if(prim_methods) {
  ------------------
  |  Branch (1462:5): [True: 0, False: 2]
  ------------------
 1463|      0|	    int i;
 1464|       |
 1465|      0|	    prim_methods  = R_Realloc(prim_methods,  n, prim_methods_t);
  ------------------
  |  |   56|      0|#define R_Realloc(p,n,t) (t *) R_chk_realloc( (void *)(p), (R_SIZE_T)((n) * sizeof(t)) )
  ------------------
 1466|      0|	    prim_generics = R_Realloc(prim_generics, n, SEXP);
  ------------------
  |  |   56|      0|#define R_Realloc(p,n,t) (t *) R_chk_realloc( (void *)(p), (R_SIZE_T)((n) * sizeof(t)) )
  ------------------
 1467|      0|	    prim_mlist	  = R_Realloc(prim_mlist,	   n, SEXP);
  ------------------
  |  |   56|      0|#define R_Realloc(p,n,t) (t *) R_chk_realloc( (void *)(p), (R_SIZE_T)((n) * sizeof(t)) )
  ------------------
 1468|       |
 1469|       |	    /* R_Realloc does not clear the added memory, hence: */
 1470|      0|	    for (i = maxMethodsOffset ; i < n ; i++) {
  ------------------
  |  Branch (1470:34): [True: 0, False: 0]
  ------------------
 1471|      0|		prim_methods[i]	 = NO_METHODS;
 1472|      0|		prim_generics[i] = NULL;
 1473|      0|		prim_mlist[i]	 = NULL;
 1474|      0|	    }
 1475|      0|	}
 1476|      2|	else {
 1477|      2|	    prim_methods  = R_Calloc(n, prim_methods_t);
  ------------------
  |  |   55|      2|#define R_Calloc(n, t)   (t *) R_chk_calloc( (R_SIZE_T) (n), sizeof(t) )
  ------------------
 1478|      2|	    prim_generics = R_Calloc(n, SEXP);
  ------------------
  |  |   55|      2|#define R_Calloc(n, t)   (t *) R_chk_calloc( (R_SIZE_T) (n), sizeof(t) )
  ------------------
 1479|      2|	    prim_mlist	  = R_Calloc(n, SEXP);
  ------------------
  |  |   55|      2|#define R_Calloc(n, t)   (t *) R_chk_calloc( (R_SIZE_T) (n), sizeof(t) )
  ------------------
 1480|      2|	}
 1481|      2|	maxMethodsOffset = n;
 1482|      2|    }
 1483|      2|    if(offset > curMaxOffset)
  ------------------
  |  Branch (1483:8): [True: 2, False: 0]
  ------------------
 1484|      2|	curMaxOffset = offset;
 1485|      2|    prim_methods[offset] = code;
 1486|       |    /* store a preserved pointer to the generic function if there is not
 1487|       |       one there currently.  Unpreserve it if no more methods, but don't
 1488|       |       replace it otherwise:  the generic definition is not allowed to
 1489|       |       change while it's still defined! (the stored methods list can,
 1490|       |       however) */
 1491|      2|    value = prim_generics[offset];
 1492|      2|    if(code == SUPPRESSED) {} /* leave the structure alone */
  ------------------
  |  Branch (1492:8): [True: 0, False: 2]
  ------------------
 1493|      2|    else if(code == NO_METHODS && prim_generics[offset]) {
  ------------------
  |  Branch (1493:13): [True: 0, False: 2]
  |  Branch (1493:35): [True: 0, False: 0]
  ------------------
 1494|      0|	R_ReleaseObject(prim_generics[offset]);
 1495|      0|	prim_generics[offset] = 0;
 1496|      0|	prim_mlist[offset] = 0;
 1497|      0|    }
 1498|      2|    else if(fundef && !isNull(fundef) && !prim_generics[offset]) {
  ------------------
  |  |  956|      2|#define isNull			Rf_isNull
  ------------------
  |  Branch (1498:13): [True: 2, False: 0]
  |  Branch (1498:23): [True: 2, False: 0]
  |  Branch (1498:42): [True: 2, False: 0]
  ------------------
 1499|      2|	if(TYPEOF(fundef) != CLOSXP)
  ------------------
  |  |  114|      2|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1499:5): [True: 0, False: 2]
  ------------------
 1500|      0|	    error(_("the formal definition of a primitive generic must be a function object (got type '%s')"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("the formal definition of a primitive generic must be a function object (got type '%s')"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1501|      0|		  R_typeToChar(fundef));
 1502|      2|	R_PreserveObject(fundef);
 1503|      2|	prim_generics[offset] = fundef;
 1504|      2|    }
 1505|      2|    if(code == HAS_METHODS) {
  ------------------
  |  Branch (1505:8): [True: 0, False: 2]
  ------------------
 1506|      0|	if(!mlist  || isNull(mlist)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (1506:5): [True: 0, False: 0]
  |  Branch (1506:16): [True: 0, False: 0]
  ------------------
 1507|       |	    /* turning methods back on after a SUPPRESSED */
 1508|      0|	} else {
 1509|      0|	    if(prim_mlist[offset])
  ------------------
  |  Branch (1509:9): [True: 0, False: 0]
  ------------------
 1510|      0|		R_ReleaseObject(prim_mlist[offset]);
 1511|      0|	    R_PreserveObject(mlist);
 1512|      0|	    prim_mlist[offset] = mlist;
 1513|      0|	}
 1514|      0|    }
 1515|      2|    return value;
 1516|      2|}
R_has_methods:
 1569|   773k|{
 1570|   773k|    R_stdGen_ptr_t ptr = R_get_standardGeneric_ptr(); int offset;
 1571|   773k|    if(NOT_METHODS_DISPATCH_PTR(ptr))
  ------------------
  |  | 1206|   773k|#define NOT_METHODS_DISPATCH_PTR(ptr) (ptr == 0 || ptr == dispatchNonGeneric)
  |  |  ------------------
  |  |  |  Branch (1206:40): [True: 186, False: 772k]
  |  |  |  Branch (1206:52): [True: 0, False: 772k]
  |  |  ------------------
  ------------------
 1572|    186|	return(FALSE);
 1573|   772k|    if(!op || TYPEOF(op) == CLOSXP) /* except for primitives, just test for the package */
  ------------------
  |  |  114|   772k|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1573:8): [True: 0, False: 772k]
  |  Branch (1573:15): [True: 0, False: 772k]
  ------------------
 1574|      0|	return(TRUE);
 1575|   772k|    if(!allowPrimitiveMethods) /* all primitives turned off by a call to R_set_prim */
  ------------------
  |  Branch (1575:8): [True: 0, False: 772k]
  ------------------
 1576|      0|	return FALSE;
 1577|   772k|    offset = PRIMOFFSET(op);
 1578|   772k|    if(offset > curMaxOffset || prim_methods[offset] == NO_METHODS
  ------------------
  |  Branch (1578:8): [True: 772k, False: 0]
  |  Branch (1578:33): [True: 0, False: 0]
  ------------------
 1579|      0|       || prim_methods[offset] == SUPPRESSED)
  ------------------
  |  Branch (1579:11): [True: 0, False: 0]
  ------------------
 1580|   772k|	return(FALSE);
 1581|      0|    return(TRUE);
 1582|   772k|}
R_set_quick_method_check:
 1596|      2|{
 1597|      2|    quick_method_check_ptr = value;
 1598|      2|}
Rf_isS4:
 1847|     40|{
 1848|     40|    return IS_S4_OBJECT(s);
 1849|     40|}
objects.c:findFunInEnvRange:
  171|  1.55M|{
  172|  1.55M|    SEXP vl;
  173|  5.43M|    while(rho != R_EmptyEnv) {
  ------------------
  |  Branch (173:11): [True: 5.43M, False: 0]
  ------------------
  174|  5.43M|	vl = R_findVarInFrame(rho, symbol);
  175|  5.43M|	if (vl != R_UnboundValue) {
  ------------------
  |  Branch (175:6): [True: 396, False: 5.43M]
  ------------------
  176|    396|	    if (TYPEOF(vl) == PROMSXP) {
  ------------------
  |  |  116|    396|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (176:10): [True: 396, False: 0]
  ------------------
  177|    396|		PROTECT(vl);
  ------------------
  |  |  357|    396|#define PROTECT(s)	Rf_protect(s)
  ------------------
  178|    396|		vl = eval(vl, rho);
  ------------------
  |  |  913|    396|#define eval			Rf_eval
  ------------------
  179|    396|		UNPROTECT(1);
  ------------------
  |  |  358|    396|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  180|    396|	    }
  181|    396|	    if ((TYPEOF(vl) == CLOSXP ||
  ------------------
  |  |  114|    792|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (181:11): [True: 396, False: 0]
  ------------------
  182|      0|		 TYPEOF(vl) == BUILTINSXP ||
  ------------------
  |  |  119|    396|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (182:4): [True: 0, False: 0]
  ------------------
  183|      0|		 TYPEOF(vl) == SPECIALSXP))
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (183:4): [True: 0, False: 0]
  ------------------
  184|    396|		return (vl);
  185|    396|	}
  186|  5.43M|	if(rho == target)
  ------------------
  |  Branch (186:5): [True: 1.55M, False: 3.88M]
  ------------------
  187|  1.55M|	    return (R_UnboundValue);
  188|  3.88M|	else
  189|  3.88M|	    rho = ENCLOS(rho);
  190|  5.43M|    }
  191|      0|    return (R_UnboundValue);
  192|  1.55M|}
objects.c:findFunWithBaseEnvAfterGlobalEnv:
  195|  1.55M|{
  196|  1.55M|    SEXP vl;
  197|  4.66M|    while(rho != R_EmptyEnv) {
  ------------------
  |  Branch (197:11): [True: 3.11M, False: 1.55M]
  ------------------
  198|  3.11M|	vl = R_findVarInFrame(rho, symbol);
  199|  3.11M|	if (vl != R_UnboundValue) {
  ------------------
  |  Branch (199:6): [True: 0, False: 3.11M]
  ------------------
  200|      0|	    if (TYPEOF(vl) == PROMSXP) {
  ------------------
  |  |  116|      0|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (200:10): [True: 0, False: 0]
  ------------------
  201|      0|		PROTECT(vl);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  202|      0|		vl = eval(vl, rho);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
  203|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  204|      0|	    }
  205|      0|	    if ((TYPEOF(vl) == CLOSXP ||
  ------------------
  |  |  114|      0|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (205:11): [True: 0, False: 0]
  ------------------
  206|      0|		 TYPEOF(vl) == BUILTINSXP ||
  ------------------
  |  |  119|      0|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (206:4): [True: 0, False: 0]
  ------------------
  207|      0|		 TYPEOF(vl) == SPECIALSXP))
  ------------------
  |  |  118|      0|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (207:4): [True: 0, False: 0]
  ------------------
  208|      0|		return (vl);
  209|      0|	}
  210|  3.11M|	if(rho == R_GlobalEnv)
  ------------------
  |  Branch (210:5): [True: 1.55M, False: 1.55M]
  ------------------
  211|  1.55M|	    rho = R_BaseEnv;
  212|  1.55M|	else
  213|  1.55M|	    rho = ENCLOS(rho);
  214|  3.11M|    }
  215|  1.55M|    return (R_UnboundValue);
  216|  1.55M|}
objects.c:addS3Var:
  332|  2.69k|SEXP addS3Var(SEXP vars, SEXP name, SEXP value) {
  333|       |
  334|  2.69k|    SEXP res = CONS(value, vars);
  ------------------
  |  |  309|  2.69k|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  335|  2.69k|    SET_TAG(res, name);
  336|  2.69k|    return res;
  337|  2.69k|}
objects.c:dispatchMethod:
  357|    395|		    const char *generic, SEXP rho, SEXP callrho, SEXP defrho) {
  358|       |
  359|    395|    SEXP newvars = PROTECT(createS3Vars(
  ------------------
  |  |  357|    395|#define PROTECT(s)	Rf_protect(s)
  ------------------
  360|    395|	PROTECT(mkString(generic)),
  361|    395|	R_BlankScalarString,
  362|    395|	dotClass,
  363|    395|	PROTECT(ScalarString(PRINTNAME(method))),
  364|    395|	callrho,
  365|    395|	defrho
  366|    395|    ));
  367|       |
  368|       |    /* Create a new environment without any */
  369|       |    /* of the formals to the generic in it. */
  370|       |
  371|    395|    if (TYPEOF(op) == CLOSXP) {
  ------------------
  |  |  114|    395|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (371:9): [True: 343, False: 52]
  ------------------
  372|    343|	SEXP formals = FORMALS(op);
  373|    343|	SEXP s, t;
  374|    343|	int matched;
  375|       |
  376|  1.13k|	for (s = FRAME(cptr->cloenv); s != R_NilValue; s = CDR(s)) {
  ------------------
  |  Branch (376:32): [True: 790, False: 343]
  ------------------
  377|    790|	    matched = 0;
  378|  1.34k|	    for (t = formals; t != R_NilValue; t = CDR(t))
  ------------------
  |  Branch (378:24): [True: 1.34k, False: 0]
  ------------------
  379|  1.34k|		if (TAG(t) == TAG(s)) {
  ------------------
  |  Branch (379:7): [True: 790, False: 553]
  ------------------
  380|    790|		    matched = 1;
  381|    790|		    break;
  382|    790|		}
  383|    790|	    if (!matched) {
  ------------------
  |  Branch (383:10): [True: 0, False: 790]
  ------------------
  384|       |#ifdef USEMETHOD_FORWARD_LOCALS
  385|       |		UNPROTECT(1); /* newvars */
  386|       |		newvars = PROTECT(CONS(CAR(s), newvars));
  387|       |		SET_TAG(newvars, TAG(s));
  388|       |#else
  389|      0|		static int option = -1;
  390|      0|		if (option == -1) {
  ------------------
  |  Branch (390:7): [True: 0, False: 0]
  ------------------
  391|      0|		    option = 2; // none: the default
  392|      0|		    const char *val = getenv("R_USEMETHOD_FORWARD_LOCALS");
  393|      0|		    if (val != NULL) {
  ------------------
  |  Branch (393:11): [True: 0, False: 0]
  ------------------
  394|      0|			if (strcmp(val, "all") == 0)
  ------------------
  |  Branch (394:8): [True: 0, False: 0]
  ------------------
  395|      0|			    option = 0;
  396|      0|			else if (strcmp(val, "S4") == 0)
  ------------------
  |  Branch (396:13): [True: 0, False: 0]
  ------------------
  397|      0|			    option = 1;
  398|      0|			else if (strcmp(val, "none") == 0)
  ------------------
  |  Branch (398:13): [True: 0, False: 0]
  ------------------
  399|      0|			    option = 2;
  400|      0|			else if (strcmp(val, "error") == 0)
  ------------------
  |  Branch (400:13): [True: 0, False: 0]
  ------------------
  401|      0|			    option = 3;
  402|      0|			else if (strcmp(val, "warning") == 0)
  ------------------
  |  Branch (402:13): [True: 0, False: 0]
  ------------------
  403|      0|			    option = 4;
  404|      0|			else
  405|      0|			    warning("bad value for R_USEMETHOD_FORWARD_LOCALS");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  406|      0|		    }
  407|      0|		}
  408|      0|		SEXP val;
  409|      0|		char buf[8192];
  410|      0|		switch(option) {
  411|      0|		case 0: // forward all, as in the past before R 4.4.0
  ------------------
  |  Branch (411:3): [True: 0, False: 0]
  ------------------
  412|      0|		    UNPROTECT(1); /* newvars */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  413|      0|		    newvars = PROTECT(CONS(CAR(s), newvars));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  414|      0|		    SET_TAG(newvars, TAG(s));
  415|      0|		    break;
  416|      0|		case 1: // forward only S4 variables
  ------------------
  |  Branch (416:3): [True: 0, False: 0]
  ------------------
  417|      0|		    if (TAG(s) == R_dot_defined ||
  ------------------
  |  Branch (417:11): [True: 0, False: 0]
  ------------------
  418|      0|			TAG(s) == R_dot_Method ||
  ------------------
  |  Branch (418:4): [True: 0, False: 0]
  ------------------
  419|      0|			TAG(s) == R_dot_target ||
  ------------------
  |  Branch (419:4): [True: 0, False: 0]
  ------------------
  420|      0|			TAG(s) == R_dot_Generic ||
  ------------------
  |  Branch (420:4): [True: 0, False: 0]
  ------------------
  421|      0|			TAG(s) == R_dot_Methods) {
  ------------------
  |  Branch (421:4): [True: 0, False: 0]
  ------------------
  422|      0|			UNPROTECT(1); /* newvars */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  423|      0|			newvars = PROTECT(CONS(CAR(s), newvars));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  424|      0|			SET_TAG(newvars, TAG(s));
  425|      0|		    }
  426|      0|		    break;
  427|      0|		case 2: // don't forward any variables
  ------------------
  |  Branch (427:3): [True: 0, False: 0]
  ------------------
  428|      0|		    break;
  429|      0|		case 3: // forward all, with an error when used
  ------------------
  |  Branch (429:3): [True: 0, False: 0]
  ------------------
  430|       |#ifdef WARN_ON_FORWARDING
  431|       |		    if (TAG(s) != R_dot_defined &&
  432|       |			TAG(s) != R_dot_Method &&
  433|       |			TAG(s) != R_dot_target &&
  434|       |			TAG(s) != R_dot_Generic &&
  435|       |			TAG(s) != R_dot_Methods)
  436|       |			warningcall_immediate(R_NilValue,
  437|       |					      "UseMethod forwarding '%s' "
  438|       |					      "in generic '%s'",
  439|       |				CHAR(PRINTNAME(TAG(s))),
  440|       |				generic);
  441|       |#endif
  442|      0|		    snprintf(buf, sizeof(buf),
  443|      0|			     "stop(\"getting UseMethod variable '%s' "
  444|      0|			     "from generic '%s'; "
  445|      0|			     "this is no longer supported\")",
  446|      0|			     CHAR(PRINTNAME(TAG(s))),
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  447|      0|			     generic);
  448|      0|		    val = mkPROMISE(R_ParseString(buf), R_GlobalEnv);
  ------------------
  |  | 1957|      0|# define mkPROMISE		Rf_mkPROMISE
  ------------------
  449|      0|		    UNPROTECT(1); /* newvars */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  450|      0|		    newvars = PROTECT(CONS(val, newvars));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  451|      0|		    SET_TAG(newvars, TAG(s));
  452|      0|		    break;
  453|      0|		default:
  ------------------
  |  Branch (453:3): [True: 0, False: 0]
  ------------------
  454|      0|		    option = 0;
  455|      0|		    warning("bad value for R_USEMETHOD_FORWARD_LOCALS");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  456|      0|		}
  457|      0|#endif
  458|      0|	    }
  459|    790|	}
  460|    343|    }
  461|       |
  462|       |    /* Debug a method when debugging the generic. When called via UseMethod or
  463|       |       NextMethod, RSTEP(op) will always be zero because the bit is cleared by
  464|       |       applyClosure. We thus approximate and enter the debugger also when
  465|       |       RDEBUG(rho) is set. */
  466|    395|    if ((RDEBUG(op) && R_current_debug_state()) || RSTEP(op) || RDEBUG(rho))
  ------------------
  |  Branch (466:10): [True: 0, False: 395]
  |  Branch (466:24): [True: 0, False: 0]
  |  Branch (466:52): [True: 0, False: 395]
  |  Branch (466:65): [True: 0, False: 395]
  ------------------
  467|      0|	SET_RSTEP(sxp, 1);
  468|       |
  469|    395|    SEXP newcall =  PROTECT(shallow_duplicate(cptr->call));
  ------------------
  |  |  357|    395|#define PROTECT(s)	Rf_protect(s)
  ------------------
  470|    395|    SETCAR(newcall, method);
  471|    395|    R_GlobalContext->callflag = CTXT_GENERIC;
  472|    395|    SEXP matchedarg = PROTECT(cptr->promargs); /* ? is this PROTECT needed ? */
  ------------------
  |  |  357|    395|#define PROTECT(s)	Rf_protect(s)
  ------------------
  473|    395|    SEXP ans = applyMethod(newcall, sxp, matchedarg, rho, newvars);
  474|    395|    R_GlobalContext->callflag = CTXT_RETURN;
  475|    395|    UNPROTECT(5); /* "generic,method", newvars, newcall, matchedarg */
  ------------------
  |  |  358|    395|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  476|       |
  477|    395|    return ans;
  478|    395|}
objects.c:GetObject:
   35|    343|{
   36|    343|    SEXP s, b, formals, tag;
   37|       |
   38|    343|    b = cptr->callfun;
   39|    343|    if (TYPEOF(b) != CLOSXP) error(_("generic 'function' is not a function"));
  ------------------
  |  |  114|    343|#define CLOSXP	     3	  /* closures */
  ------------------
                  if (TYPEOF(b) != CLOSXP) error(_("generic 'function' is not a function"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (TYPEOF(b) != CLOSXP) error(_("generic 'function' is not a function"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (39:9): [True: 0, False: 343]
  ------------------
   40|    343|    formals = FORMALS(b);
   41|       |
   42|    343|    tag = TAG(formals);
   43|    343|    if (tag != R_NilValue && tag != R_DotsSymbol) {
  ------------------
  |  Branch (43:9): [True: 343, False: 0]
  |  Branch (43:30): [True: 343, False: 0]
  ------------------
   44|    343|	s = NULL;
   45|       |	/** exact matches **/
   46|    688|	for (b = cptr->promargs ; b != R_NilValue ; b = CDR(b))
  ------------------
  |  Branch (46:28): [True: 345, False: 343]
  ------------------
   47|    345|	    if (TAG(b) != R_NilValue && pmatch(tag, TAG(b), 1)) {
  ------------------
  |  | 1011|      0|#define pmatch			Rf_pmatch
  ------------------
  |  Branch (47:10): [True: 0, False: 345]
  |  Branch (47:34): [True: 0, False: 0]
  ------------------
   48|      0|		if (s != NULL)
  ------------------
  |  Branch (48:7): [True: 0, False: 0]
  ------------------
   49|      0|		    error(_("formal argument \"%s\" matched by multiple actual arguments"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("formal argument \"%s\" matched by multiple actual arguments"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   50|      0|		          CHAR(PRINTNAME(tag)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
   51|      0|		else
   52|      0|		    s = CAR(b);
   53|      0|	    }
   54|       |
   55|    343|	if (s == NULL)
  ------------------
  |  Branch (55:6): [True: 343, False: 0]
  ------------------
   56|       |	    /** partial matches **/
   57|    688|	    for (b = cptr->promargs ; b != R_NilValue ; b = CDR(b))
  ------------------
  |  Branch (57:32): [True: 345, False: 343]
  ------------------
   58|    345|		if (TAG(b) != R_NilValue && pmatch(tag, TAG(b), 0)) {
  ------------------
  |  | 1011|      0|#define pmatch			Rf_pmatch
  ------------------
  |  Branch (58:7): [True: 0, False: 345]
  |  Branch (58:31): [True: 0, False: 0]
  ------------------
   59|      0|		    if ( s != NULL)
  ------------------
  |  Branch (59:12): [True: 0, False: 0]
  ------------------
   60|      0|			error(_("formal argument \"%s\" matched by multiple actual arguments"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              			error(_("formal argument \"%s\" matched by multiple actual arguments"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   61|      0|			      CHAR(PRINTNAME(tag)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
   62|      0|		    else
   63|      0|			s = CAR(b);
   64|      0|		}
   65|    343|	if (s == NULL)
  ------------------
  |  Branch (65:6): [True: 343, False: 0]
  ------------------
   66|       |	    /** first untagged argument **/
   67|    343|	    for (b = cptr->promargs ; b != R_NilValue ; b = CDR(b))
  ------------------
  |  Branch (67:32): [True: 343, False: 0]
  ------------------
   68|    343|		if (TAG(b) == R_NilValue )
  ------------------
  |  Branch (68:7): [True: 343, False: 0]
  ------------------
   69|    343|		{
   70|    343|		    s = CAR(b);
   71|    343|		    break;
   72|    343|		}
   73|    343|	if (s == NULL)
  ------------------
  |  Branch (73:6): [True: 0, False: 343]
  ------------------
   74|      0|	    s = CAR(cptr->promargs);
   75|       |/*
   76|       |	    error("failed to match argument for dispatch");
   77|       |*/
   78|    343|    }
   79|      0|    else
   80|      0|	s = CAR(cptr->promargs);
   81|       |
   82|    343|    if (TYPEOF(s) == PROMSXP) {
  ------------------
  |  |  116|    343|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (82:9): [True: 343, False: 0]
  ------------------
   83|    343|	if (! PROMISE_IS_EVALUATED(s))
  ------------------
  |  Branch (83:6): [True: 343, False: 0]
  ------------------
   84|    343|	    s = eval(s, R_BaseEnv);
  ------------------
  |  |  913|    343|#define eval			Rf_eval
  ------------------
   85|      0|	else
   86|      0|	    s = PRVALUE(s);
   87|    343|    }
   88|    343|    return(s);
   89|    343|}
objects.c:equalS3Signature:
  657|     16|			 const char *right) {
  658|       |
  659|     16|    const char *s = signature;
  660|     16|    const char *a;
  661|       |
  662|     32|    for(a = left; *a; s++, a++) {
  ------------------
  |  Branch (662:19): [True: 16, False: 16]
  ------------------
  663|     16|	if (*s != *a)
  ------------------
  |  Branch (663:6): [True: 0, False: 16]
  ------------------
  664|      0|	    return FALSE;
  665|     16|    }
  666|     16|    if (*s++ != '.')
  ------------------
  |  Branch (666:9): [True: 0, False: 16]
  ------------------
  667|      0|	return FALSE;
  668|    192|    for(a = right; *a; s++, a++) {
  ------------------
  |  Branch (668:20): [True: 176, False: 16]
  ------------------
  669|    176|	if (*s != *a)
  ------------------
  |  Branch (669:6): [True: 0, False: 176]
  ------------------
  670|      0|	    return FALSE;
  671|    176|    }
  672|     16|    return (*s == 0) ? TRUE : FALSE;
  ------------------
  |  Branch (672:12): [True: 16, False: 0]
  ------------------
  673|     16|}
objects.c:applyMethod:
   92|    411|{
   93|    411|    SEXP ans;
   94|    411|    if (TYPEOF(op) == SPECIALSXP) {
  ------------------
  |  |  118|    411|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (94:9): [True: 16, False: 395]
  ------------------
   95|     16|	int save = R_PPStackTop, flag = PRIMPRINT(op);
  ------------------
  |  | 1350|     16|#define PRIMPRINT(x)	(((R_FunTab[PRIMOFFSET(x)].eval)/100)%10)
  |  |  ------------------
  |  |  |  |  913|     16|#define eval			Rf_eval
  |  |  ------------------
  ------------------
   96|     16|	const void *vmax = vmaxget();
   97|     16|	R_Visible = flag != 1;
   98|     16|	ans = PRIMFUN(op) (call, op, args, rho);
  ------------------
  |  | 1345|     16|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
   99|     16|	if (flag < 2) R_Visible = flag != 1;
  ------------------
  |  Branch (99:6): [True: 16, False: 0]
  ------------------
  100|     16|	check_stack_balance(op, save);
  ------------------
  |  | 1866|     16|# define check_stack_balance	Rf_check_stack_balance
  ------------------
  101|     16|	vmaxset(vmax);
  102|     16|    }
  103|       |    /* In other places we add a context to builtins when profiling,
  104|       |       but we have not bothered here (as there seem to be no primitives
  105|       |       used as methods, and this would have to be a primitive to be
  106|       |       found).
  107|       |     */
  108|    395|    else if (TYPEOF(op) == BUILTINSXP) {
  ------------------
  |  |  119|    395|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (108:14): [True: 0, False: 395]
  ------------------
  109|      0|	int save = R_PPStackTop, flag = PRIMPRINT(op);
  ------------------
  |  | 1350|      0|#define PRIMPRINT(x)	(((R_FunTab[PRIMOFFSET(x)].eval)/100)%10)
  |  |  ------------------
  |  |  |  |  913|      0|#define eval			Rf_eval
  |  |  ------------------
  ------------------
  110|      0|	const void *vmax = vmaxget();
  111|      0|	PROTECT(args = evalList(args, rho, call, 0));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  112|      0|	R_Visible = flag != 1;
  113|      0|	ans = PRIMFUN(op) (call, op, args, rho);
  ------------------
  |  | 1345|      0|#define PRIMFUN(x)	(R_FunTab[PRIMOFFSET(x)].cfun)
  ------------------
  114|      0|	if (flag < 2) R_Visible = flag != 1;
  ------------------
  |  Branch (114:6): [True: 0, False: 0]
  ------------------
  115|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  116|      0|	check_stack_balance(op, save);
  ------------------
  |  | 1866|      0|# define check_stack_balance	Rf_check_stack_balance
  ------------------
  117|      0|	vmaxset(vmax);
  118|      0|    }
  119|    395|    else if (TYPEOF(op) == CLOSXP) {
  ------------------
  |  |  114|    395|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (119:14): [True: 395, False: 0]
  ------------------
  120|    395|	ans = applyClosure(call, op, args, rho, newvars, FALSE);
  ------------------
  |  |  879|    395|#define applyClosure		Rf_applyClosure
  ------------------
  121|    395|    }
  122|      0|    else
  123|      0|	ans = R_NilValue;  /* for -Wall */
  124|    411|    return ans;
  125|    411|}
objects.c:inherits3:
 1015|  2.73k|{
 1016|  2.73k|    const void *vmax = vmaxget();
 1017|  2.73k|    SEXP klass, rval = R_NilValue /* -Wall */;
 1018|       |
 1019|  2.73k|    if(IS_S4_OBJECT(x))
  ------------------
  |  Branch (1019:8): [True: 0, False: 2.73k]
  ------------------
 1020|      0|	PROTECT(klass = R_data_class2(x)); // -> := S4_extends( "class(x)" )
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1021|  2.73k|    else
 1022|  2.73k|	PROTECT(klass = R_data_class(x, FALSE));
  ------------------
  |  |  357|  2.73k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1023|       |
 1024|  2.73k|    if(!isString(what))
  ------------------
  |  |  966|  2.73k|#define isString		Rf_isString
  ------------------
  |  Branch (1024:8): [True: 0, False: 2.73k]
  ------------------
 1025|      0|	error(_("'what' must be a character vector "
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'what' must be a character vector "
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1026|      0|		"or an object with a nameOfClass() method"));
 1027|  2.73k|    int j, nwhat = LENGTH(what);
 1028|       |
 1029|  2.73k|    if( !isLogical(which) || (LENGTH(which) != 1) )
  ------------------
  |  |  952|  2.73k|#define isLogical		Rf_isLogical
  ------------------
  |  Branch (1029:9): [True: 0, False: 2.73k]
  |  Branch (1029:30): [True: 0, False: 2.73k]
  ------------------
 1030|      0|	error(_("'which' must be a length 1 logical vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'which' must be a length 1 logical vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1031|  2.73k|    bool isvec = asRbool(which, R_NilValue);
  ------------------
  |  | 1861|  2.73k|# define asRbool		Rf_asRbool
  ------------------
 1032|       |
 1033|  2.73k|    if(isvec)
  ------------------
  |  Branch (1033:8): [True: 0, False: 2.73k]
  ------------------
 1034|      0|	PROTECT(rval = allocVector(INTSXP, nwhat));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1035|       |
 1036|  4.22k|    for(j = 0; j < nwhat; j++) {
  ------------------
  |  Branch (1036:16): [True: 2.73k, False: 1.48k]
  ------------------
 1037|  2.73k|	const char *ss = translateChar(STRING_ELT(what, j));
  ------------------
  |  | 1037|  2.73k|#define translateChar		Rf_translateChar
  ------------------
 1038|  2.73k|	int i = stringPositionTr(klass, ss);
  ------------------
  |  | 1033|  2.73k|#define stringPositionTr	Rf_stringPositionTr
  ------------------
 1039|  2.73k|	if (isvec)
  ------------------
  |  Branch (1039:6): [True: 0, False: 2.73k]
  ------------------
 1040|      0|	    INTEGER(rval)[j] = i+1; /* 0 when ss is not in klass */
 1041|  2.73k|	else if (i >= 0) {
  ------------------
  |  Branch (1041:11): [True: 1.24k, False: 1.48k]
  ------------------
 1042|  1.24k|	    vmaxset(vmax);
 1043|  1.24k|	    UNPROTECT(1);
  ------------------
  |  |  358|  1.24k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1044|  1.24k|	    return mkTrue();
  ------------------
  |  | 1960|  1.24k|# define mkTrue			Rf_mkTrue
  ------------------
 1045|  1.24k|	}
 1046|  2.73k|    }
 1047|  1.48k|    vmaxset(vmax);
 1048|  1.48k|    if(!isvec) {
  ------------------
  |  Branch (1048:8): [True: 1.48k, False: 0]
  ------------------
 1049|  1.48k|	UNPROTECT(1);
  ------------------
  |  |  358|  1.48k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1050|  1.48k|	return mkFalse();
  ------------------
  |  | 1956|  1.48k|# define mkFalse		Rf_mkFalse
  ------------------
 1051|  1.48k|    }
 1052|      0|    UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1053|      0|    return rval;
 1054|  1.48k|}
objects.c:R_get_standardGeneric_ptr:
 1210|   773k|{
 1211|   773k|    return R_standardGeneric_ptr;
 1212|   773k|}

Rf_GetOption1:
  129|   787k|{
  130|   787k|    SEXP opt = SYMVALUE(Options());
  131|   787k|    if (!isList(opt)) error(_("corrupted options list"));
  ------------------
  |  |  951|   787k|#define isList			Rf_isList
  ------------------
                  if (!isList(opt)) error(_("corrupted options list"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (!isList(opt)) error(_("corrupted options list"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (131:9): [True: 0, False: 787k]
  ------------------
  132|   787k|    opt = FindTaggedItem(opt, tag);
  133|   787k|    return CAR(opt);
  134|   787k|}
Rf_FixupWidth:
  137|  2.95k|{
  138|  2.95k|    int w = asInteger(width);
  ------------------
  |  |  885|  2.95k|#define asInteger		Rf_asInteger
  ------------------
  139|  2.95k|    if (w == NA_INTEGER || w < R_MIN_WIDTH_OPT || w > R_MAX_WIDTH_OPT) {
  ------------------
  |  |   56|  5.91k|#define NA_INTEGER	R_NaInt
  ------------------
                  if (w == NA_INTEGER || w < R_MIN_WIDTH_OPT || w > R_MAX_WIDTH_OPT) {
  ------------------
  |  |   78|  5.91k|#define R_MIN_WIDTH_OPT		10
  ------------------
                  if (w == NA_INTEGER || w < R_MIN_WIDTH_OPT || w > R_MAX_WIDTH_OPT) {
  ------------------
  |  |   79|  2.95k|#define R_MAX_WIDTH_OPT		10000
  ------------------
  |  Branch (139:9): [True: 0, False: 2.95k]
  |  Branch (139:28): [True: 0, False: 2.95k]
  |  Branch (139:51): [True: 0, False: 2.95k]
  ------------------
  140|      0|	switch(warn) {
  ------------------
  |  Branch (140:9): [True: 0, False: 0]
  ------------------
  141|      0|	case iWARN: warning(_("invalid printing width %d, used 80"), w);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	case iWARN: warning(_("invalid printing width %d, used 80"), w);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (141:2): [True: 0, False: 0]
  ------------------
  142|      0|	case iSILENT:
  ------------------
  |  Branch (142:2): [True: 0, False: 0]
  ------------------
  143|      0|	    return 80; // for SILENT and WARN
  144|      0|	case iERROR: error(_("invalid printing width"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	case iERROR: error(_("invalid printing width"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (144:2): [True: 0, False: 0]
  ------------------
  145|      0|	}
  146|      0|    }
  147|  2.95k|    return w;
  148|  2.95k|}
Rf_GetOptionWidth:
  150|  2.95k|{
  151|  2.95k|    return FixupWidth(GetOption1(install("width")), iWARN);
  ------------------
  |  |  922|  2.95k|#define FixupWidth		Rf_FixupWidth
  ------------------
                  return FixupWidth(GetOption1(install("width")), iWARN);
  ------------------
  |  |  928|  2.95k|#define GetOption1		Rf_GetOption1
  ------------------
                  return FixupWidth(GetOption1(install("width")), iWARN);
  ------------------
  |  |  934|  2.95k|#define install			Rf_install
  ------------------
  152|  2.95k|}
Rf_FixupDigits:
  155|  2.95k|{
  156|  2.95k|    int d = asInteger(digits);
  ------------------
  |  |  885|  2.95k|#define asInteger		Rf_asInteger
  ------------------
  157|  2.95k|    if (d == NA_INTEGER || d < R_MIN_DIGITS_OPT || d > R_MAX_DIGITS_OPT) {
  ------------------
  |  |   56|  5.91k|#define NA_INTEGER	R_NaInt
  ------------------
                  if (d == NA_INTEGER || d < R_MIN_DIGITS_OPT || d > R_MAX_DIGITS_OPT) {
  ------------------
  |  |   80|  5.91k|#define R_MIN_DIGITS_OPT	1
  ------------------
                  if (d == NA_INTEGER || d < R_MIN_DIGITS_OPT || d > R_MAX_DIGITS_OPT) {
  ------------------
  |  |   81|  2.95k|#define R_MAX_DIGITS_OPT	22
  ------------------
  |  Branch (157:9): [True: 0, False: 2.95k]
  |  Branch (157:28): [True: 0, False: 2.95k]
  |  Branch (157:52): [True: 0, False: 2.95k]
  ------------------
  158|      0|	switch(warn) {
  ------------------
  |  Branch (158:9): [True: 0, False: 0]
  ------------------
  159|      0|	case iWARN: warning(_("invalid printing digits %d, used 7"), d);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	case iWARN: warning(_("invalid printing digits %d, used 7"), d);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (159:2): [True: 0, False: 0]
  ------------------
  160|      0|	case iSILENT:
  ------------------
  |  Branch (160:2): [True: 0, False: 0]
  ------------------
  161|      0|	    return 7; // for SILENT and WARN
  162|      0|	case iERROR: error(_("invalid printing digits %d"), d);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	case iERROR: error(_("invalid printing digits %d"), d);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (162:2): [True: 0, False: 0]
  ------------------
  163|      0|	}
  164|      0|    }
  165|  2.95k|    return d;
  166|  2.95k|}
Rf_GetOptionDigits:
  169|  2.95k|{
  170|  2.95k|    return FixupDigits(GetOption1(install("digits")), iWARN);
  ------------------
  |  |  921|  2.95k|#define FixupDigits		Rf_FixupDigits
  ------------------
                  return FixupDigits(GetOption1(install("digits")), iWARN);
  ------------------
  |  |  928|  2.95k|#define GetOption1		Rf_GetOption1
  ------------------
                  return FixupDigits(GetOption1(install("digits")), iWARN);
  ------------------
  |  |  934|  2.95k|#define install			Rf_install
  ------------------
  171|  2.95k|}
Rf_GetOptionCutoff:
  203|  2.95k|{
  204|  2.95k|    int w;
  205|  2.95k|    w = asInteger(GetOption1(install("deparse.cutoff")));
  ------------------
  |  |  885|  2.95k|#define asInteger		Rf_asInteger
  ------------------
                  w = asInteger(GetOption1(install("deparse.cutoff")));
  ------------------
  |  |  928|  2.95k|#define GetOption1		Rf_GetOption1
  ------------------
                  w = asInteger(GetOption1(install("deparse.cutoff")));
  ------------------
  |  |  934|  2.95k|#define install			Rf_install
  ------------------
  206|  2.95k|    if (w == NA_INTEGER || w <= 0) {
  ------------------
  |  |   56|  5.91k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (206:9): [True: 0, False: 2.95k]
  |  Branch (206:28): [True: 0, False: 2.95k]
  ------------------
  207|      0|	warning(_("invalid 'deparse.cutoff', used 60"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("invalid 'deparse.cutoff', used 60"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  208|      0|	w = 60;
  209|      0|    }
  210|  2.95k|    return w;
  211|  2.95k|}
Rf_InitOptions:
  300|      2|{
  301|      2|    SEXP val, v;
  302|      2|    char *p;
  303|       |
  304|       |    /* options set here should be included into mandatory[] in do_options */
  305|      2|#ifdef HAVE_RL_COMPLETION_MATCHES
  306|      2|    PROTECT(v = val = allocList(31));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
  307|       |#else
  308|       |    PROTECT(v = val = allocList(30));
  309|       |#endif
  310|       |
  311|      2|    SET_TAG(v, install("prompt"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  312|      2|    SETCAR(v, mkString("> "));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
  313|      2|    v = CDR(v);
  314|       |
  315|      2|    SET_TAG(v, install("continue"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  316|      2|    SETCAR(v, mkString("+ "));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
  317|      2|    v = CDR(v);
  318|       |
  319|      2|    SET_TAG(v, install("expressions"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  320|      2|    SETCAR(v, ScalarInteger(R_Expressions));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  321|      2|    v = CDR(v);
  322|       |
  323|      2|    SET_TAG(v, install("width"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  324|      2|    SETCAR(v, ScalarInteger(80));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  325|      2|    v = CDR(v);
  326|       |
  327|      2|    SET_TAG(v, install("deparse.cutoff"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  328|      2|    SETCAR(v, ScalarInteger(60));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  329|      2|    v = CDR(v);
  330|       |
  331|      2|    SET_TAG(v, install("digits"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  332|      2|    SETCAR(v, ScalarInteger(7));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  333|      2|    v = CDR(v);
  334|       |
  335|      2|    SET_TAG(v, install("echo"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  336|      2|    SETCAR(v, ScalarLogical(!R_NoEcho));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  337|      2|    v = CDR(v);
  338|       |
  339|      2|    SET_TAG(v, install("quiet"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  340|      2|    SETCAR(v, ScalarLogical(R_Quiet));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  341|      2|    v = CDR(v);
  342|       |
  343|      2|    SET_TAG(v, install("verbose"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  344|      2|    SETCAR(v, ScalarLogical(R_Verbose));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  345|      2|    v = CDR(v);
  346|       |
  347|      2|    SET_TAG(v, install("check.bounds"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  348|      2|    SETCAR(v, ScalarLogical(0));	/* no checking */
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  349|      2|    v = CDR(v);
  350|       |
  351|      2|    p = getenv("R_KEEP_PKG_SOURCE");
  352|      2|    R_KeepSource = (p && (strcmp(p, "yes") == 0)) ? 1 : 0;
  ------------------
  |  Branch (352:21): [True: 0, False: 2]
  |  Branch (352:26): [True: 0, False: 0]
  ------------------
  353|       |
  354|      2|    SET_TAG(v, install("keep.source")); /* overridden in Common.R */
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  355|      2|    SETCAR(v, ScalarLogical(R_KeepSource));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  356|      2|    v = CDR(v);
  357|       |
  358|      2|    SET_TAG(v, install("keep.source.pkgs"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  359|      2|    SETCAR(v, ScalarLogical(R_KeepSource));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  360|      2|    v = CDR(v);
  361|       |
  362|      2|    SET_TAG(v, install("keep.parse.data"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  363|      2|    SETCAR(v, ScalarLogical(TRUE));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  364|      2|    v = CDR(v);
  365|       |
  366|      2|    p = getenv("R_KEEP_PKG_PARSE_DATA");
  367|      2|    SET_TAG(v, install("keep.parse.data.pkgs"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  368|      2|    SETCAR(v, ScalarLogical((p && (strcmp(p, "yes") == 0)) ? TRUE : FALSE));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  |  Branch (368:30): [True: 0, False: 2]
  |  Branch (368:35): [True: 0, False: 0]
  ------------------
  369|      2|    v = CDR(v);
  370|       |
  371|      2|    SET_TAG(v, install("warning.length"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  372|      2|    SETCAR(v, ScalarInteger(R_WarnLength));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  373|      2|    v = CDR(v);
  374|       |
  375|      2|    SET_TAG(v, install("nwarnings"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  376|      2|    SETCAR(v, ScalarInteger(R_nwarnings));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  377|      2|    v = CDR(v);
  378|       |
  379|      2|    SET_TAG(v, install("OutDec"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  380|      2|    SETCAR(v, mkString(OutDec));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
  381|      2|    v = CDR(v);
  382|       |
  383|      2|    p = getenv("R_C_BOUNDS_CHECK");
  384|      2|    R_CBoundsCheck = (p && (strcmp(p, "yes") == 0)) ? TRUE : FALSE;
  ------------------
  |  Branch (384:23): [True: 0, False: 2]
  |  Branch (384:28): [True: 0, False: 0]
  ------------------
  385|       |
  386|      2|    SET_TAG(v, install("CBoundsCheck"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  387|      2|    SETCAR(v, ScalarLogical(R_CBoundsCheck));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  388|      2|    v = CDR(v);
  389|       |
  390|      2|    SET_TAG(v, install("matprod"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  391|      2|    switch(R_Matprod) {
  ------------------
  |  Branch (391:12): [True: 2, False: 0]
  ------------------
  392|      2|	case MATPROD_DEFAULT: p = "default"; break;
  ------------------
  |  Branch (392:2): [True: 2, False: 0]
  ------------------
  393|      0|	case MATPROD_INTERNAL: p = "internal"; break;
  ------------------
  |  Branch (393:2): [True: 0, False: 2]
  ------------------
  394|      0|	case MATPROD_BLAS: p = "blas"; break;
  ------------------
  |  Branch (394:2): [True: 0, False: 2]
  ------------------
  395|      0|	case MATPROD_DEFAULT_SIMD: p = "default.simd"; break;
  ------------------
  |  Branch (395:2): [True: 0, False: 2]
  ------------------
  396|      2|    }
  397|      2|    SETCAR(v, mkString(p));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
  398|      2|    v = CDR(v);
  399|       |
  400|      2|    SET_TAG(v, install("PCRE_study"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  401|      2|    if (R_PCRE_study == -1)
  ------------------
  |  Branch (401:9): [True: 0, False: 2]
  ------------------
  402|      0|	SETCAR(v, ScalarLogical(TRUE));
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  403|      2|    else if (R_PCRE_study == -2)
  ------------------
  |  Branch (403:14): [True: 2, False: 0]
  ------------------
  404|      2|	SETCAR(v, ScalarLogical(FALSE));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  405|      0|    else
  406|      0|	SETCAR(v, ScalarInteger(R_PCRE_study));
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  407|      2|    v = CDR(v);
  408|       |
  409|      2|    SET_TAG(v, install("PCRE_use_JIT"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  410|      2|    SETCAR(v, ScalarLogical(R_PCRE_use_JIT));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  411|      2|    v = CDR(v);
  412|       |
  413|      2|    SET_TAG(v, install("PCRE_limit_recursion"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  414|      2|    R_PCRE_limit_recursion = NA_LOGICAL;
  ------------------
  |  |   55|      2|#define NA_LOGICAL	R_NaInt
  ------------------
  415|      2|    SETCAR(v, ScalarLogical(R_PCRE_limit_recursion));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  416|      2|    v = CDR(v);
  417|       |
  418|      2|    SET_TAG(v, install("max.contour.segments"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  419|      2|    SETCAR(v, ScalarInteger(max_contour_segments));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  420|      2|    v = CDR(v);
  421|       |
  422|      2|    SET_TAG(v, install("warnPartialMatchDollar"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  423|      2|    SETCAR(v, ScalarLogical(R_warn_partial_match_dollar));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  424|      2|    v = CDR(v);
  425|       |
  426|      2|    SET_TAG(v, install("warnPartialMatchArgs"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  427|      2|    SETCAR(v, ScalarLogical(R_warn_partial_match_args));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  428|      2|    v = CDR(v);
  429|       |
  430|      2|    SET_TAG(v, install("warnPartialMatchAttr"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  431|      2|    SETCAR(v, ScalarLogical(R_warn_partial_match_attr));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  432|      2|    v = CDR(v);
  433|       |
  434|      2|    SET_TAG(v, install("showWarnCalls"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  435|      2|    SETCAR(v, ScalarLogical(R_ShowWarnCalls));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  436|      2|    v = CDR(v);
  437|       |
  438|      2|    SET_TAG(v, install("showErrorCalls"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  439|      2|    SETCAR(v, ScalarLogical(R_ShowErrorCalls));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  440|      2|    v = CDR(v);
  441|       |
  442|      2|    SET_TAG(v, install("showNCalls"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  443|      2|    SETCAR(v, ScalarInteger(R_NShowCalls));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  444|      2|    v = CDR(v);
  445|       |
  446|      2|    SET_TAG(v, install("browserNLdisabled"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  447|      2|    SETCAR(v, ScalarLogical(R_DisableNLinBrowser));
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  448|      2|    v = CDR(v);
  449|       |
  450|       |    /* options set here should be included into mandatory[] in do_options */
  451|       |
  452|      2|#ifdef HAVE_RL_COMPLETION_MATCHES
  453|       |    /* value from Rf_initialize_R */
  454|      2|    SET_TAG(v, install("rl_word_breaks"));
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  455|      2|    SETCAR(v, mkString(" \t\n\"\\'`><=;,|&{()}")); // no longer '%' for `%/%`, `%in%` ..
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
  456|      2|    set_rl_word_breaks(" \t\n\"\\'`><=;,|&{()}");
  457|      2|#endif
  458|       |
  459|      2|    SET_SYMVALUE(install(".Options"), val);
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  460|      2|    UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  461|      2|}
do_getOption:
  465|    157|{
  466|    157|    checkArity(op, args);
  ------------------
  |  | 1788|    157|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  467|    157|    SEXP x = CAR(args);
  468|    157|    if (!isString(x) || LENGTH(x) != 1)
  ------------------
  |  |  966|    157|#define isString		Rf_isString
  ------------------
  |  Branch (468:9): [True: 0, False: 157]
  |  Branch (468:25): [True: 0, False: 157]
  ------------------
  469|      0|	error(_("'%s' must be a character string"), "x");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'%s' must be a character string"), "x");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  470|    157|    return duplicate(GetOption1(installTrChar(STRING_ELT(x, 0))));
  ------------------
  |  |  909|    157|#define duplicate		Rf_duplicate
  ------------------
                  return duplicate(GetOption1(installTrChar(STRING_ELT(x, 0))));
  ------------------
  |  |  928|    157|#define GetOption1		Rf_GetOption1
  ------------------
                  return duplicate(GetOption1(installTrChar(STRING_ELT(x, 0))));
  ------------------
  |  |  937|    157|#define installTrChar		Rf_installTrChar
  ------------------
  471|    157|}
do_options:
  483|     78|{
  484|     78|    SEXP names, value, options;
  485|       |
  486|       |    /* Locate the options values in the symbol table.
  487|       |       This will need to change if options are to live in the session
  488|       |       frame.
  489|       |       */
  490|       |
  491|     78|    options = SYMVALUE(Options());
  492|       |
  493|       |    /* This code is not re-entrant and people have used it in
  494|       |       finalizers.
  495|       |
  496|       |       If a re-entrancy lock needs to be added, note that it
  497|       |       would apply to R_SetOption* too.
  498|       |    */
  499|       |
  500|     78|    checkArity(op, args);
  ------------------
  |  | 1788|     78|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  501|     78|    if (args == R_NilValue) {
  ------------------
  |  Branch (501:9): [True: 0, False: 78]
  ------------------
  502|       |	/* This is the zero argument case.
  503|       |	   We alloc up a vector list and write the system values into it.
  504|       |	*/
  505|      0|	int n = length(options);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  506|      0|	PROTECT(value = allocVector(VECSXP, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  507|      0|	PROTECT(names = allocVector(STRSXP, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  508|      0|	for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (508:18): [True: 0, False: 0]
  ------------------
  509|      0|	    SET_STRING_ELT(names, i, PRINTNAME(TAG(options)));
  510|      0|	    SET_VECTOR_ELT(value, i, duplicate(CAR(options)));
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
  511|      0|	    options = CDR(options);
  512|      0|	}
  513|      0|	SEXP sind = PROTECT(allocVector(INTSXP, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  514|      0|	int *indx = INTEGER(sind);
  515|      0|	for (int i = 0; i < n; i++) indx[i] = i;
  ------------------
  |  Branch (515:18): [True: 0, False: 0]
  ------------------
  516|      0|	orderVector1(indx, n, names, true, false, R_NilValue);
  517|      0|	SEXP value2 = PROTECT(allocVector(VECSXP, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  518|      0|	SEXP names2 = PROTECT(allocVector(STRSXP, n));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  519|      0|	for(int i = 0; i < n; i++) {
  ------------------
  |  Branch (519:17): [True: 0, False: 0]
  ------------------
  520|      0|	    SET_STRING_ELT(names2, i, STRING_ELT(names, indx[i]));
  521|      0|	    SET_VECTOR_ELT(value2, i, VECTOR_ELT(value, indx[i]));
  522|      0|	}
  523|      0|	setAttrib(value2, R_NamesSymbol, names2);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  524|      0|	UNPROTECT(5);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  525|      0|	R_Visible = TRUE;
  526|      0|	return value2;
  527|      0|    }
  528|       |
  529|       |    /* The arguments to "options" can either be a sequence of
  530|       |       name = value form, or can be a single list.
  531|       |       This means that we must code so that both forms will work.
  532|       |       [ Vomits quietly onto shoes ... ]
  533|       |       */
  534|       |
  535|     78|    int n = length(args);
  ------------------
  |  |  987|     78|#define length(x)		Rf_length(x)
  ------------------
  536|     78|    if (n == 1 && (isPairList(CAR(args)) || isVectorList(CAR(args)))
  ------------------
  |  |  961|     64|#define isPairList		Rf_isPairList
  ------------------
                  if (n == 1 && (isPairList(CAR(args)) || isVectorList(CAR(args)))
  ------------------
  |  |  977|     64|#define isVectorList		Rf_isVectorList
  ------------------
  |  Branch (536:9): [True: 64, False: 14]
  |  Branch (536:20): [True: 0, False: 64]
  |  Branch (536:45): [True: 30, False: 34]
  ------------------
  537|     30|	&& TAG(args) == R_NilValue ) {
  ------------------
  |  Branch (537:5): [True: 30, False: 0]
  ------------------
  538|     30|	args = CAR(args);
  539|     30|	n = length(args);
  ------------------
  |  |  987|     30|#define length(x)		Rf_length(x)
  ------------------
  540|     30|    }
  541|     78|    PROTECT(value = allocVector(VECSXP, n));
  ------------------
  |  |  357|     78|#define PROTECT(s)	Rf_protect(s)
  ------------------
  542|     78|    PROTECT(names = allocVector(STRSXP, n));
  ------------------
  |  |  357|     78|#define PROTECT(s)	Rf_protect(s)
  ------------------
  543|       |
  544|     78|    SEXP argnames = R_NilValue;
  545|     78|    switch (TYPEOF(args)) {
  546|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (546:5): [True: 0, False: 78]
  ------------------
  547|     48|    case LISTSXP:
  ------------------
  |  |  113|     48|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (547:5): [True: 48, False: 30]
  ------------------
  548|     48|	break;
  549|     30|    case VECSXP:
  ------------------
  |  |  131|     30|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (549:5): [True: 30, False: 48]
  ------------------
  550|     30|	if(n > 0) {
  ------------------
  |  Branch (550:5): [True: 30, False: 0]
  ------------------
  551|     30|	    argnames = getAttrib(args, R_NamesSymbol);
  ------------------
  |  |  924|     30|#define getAttrib		Rf_getAttrib
  ------------------
  552|     30|	    if(LENGTH(argnames) != n)
  ------------------
  |  Branch (552:9): [True: 0, False: 30]
  ------------------
  553|      0|		error(_("list argument has no valid names"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("list argument has no valid names"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  554|     30|	}
  555|     30|	break;
  556|      0|    default:
  ------------------
  |  Branch (556:5): [True: 0, False: 78]
  ------------------
  557|      0|	UNIMPLEMENTED_TYPE("options", args);
  558|     78|    }
  559|     78|    PROTECT(argnames);
  ------------------
  |  |  357|     78|#define PROTECT(s)	Rf_protect(s)
  ------------------
  560|       |
  561|     78|    Rboolean visible = FALSE;
  562|    262|    for (int i = 0 ; i < n ; i++) { /* i-th argument */
  ------------------
  |  Branch (562:22): [True: 184, False: 78]
  ------------------
  563|    184|	SEXP argi = R_NilValue, namei = R_NilValue;
  564|    184|	switch (TYPEOF(args)) {
  565|     86|	case LISTSXP:
  ------------------
  |  |  113|     86|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (565:2): [True: 86, False: 98]
  ------------------
  566|     86|	    argi = CAR(args);
  567|     86|	    namei = EnsureString(TAG(args)); /* gives "" for no tag */
  ------------------
  |  | 1894|     86|# define EnsureString 		Rf_EnsureString
  ------------------
  568|     86|	    args = CDR(args);
  569|     86|	    break;
  570|     98|	case VECSXP:
  ------------------
  |  |  131|     98|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (570:2): [True: 98, False: 86]
  ------------------
  571|     98|	    argi = VECTOR_ELT(args, i);
  572|     98|	    namei = STRING_ELT(argnames, i);
  573|     98|	    break;
  574|      0|	default: /* already checked, but be safe here */
  ------------------
  |  Branch (574:2): [True: 0, False: 184]
  ------------------
  575|      0|	    UNIMPLEMENTED_TYPE("options", args);
  576|    184|	}
  577|       |
  578|    184|	if (*CHAR(namei)) { /* name = value  ---> assignment */
  ------------------
  |  |  203|    184|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (578:6): [True: 184, False: 0]
  ------------------
  579|    184|	    SEXP tag = installTrChar(namei);
  ------------------
  |  |  937|    184|#define installTrChar		Rf_installTrChar
  ------------------
  580|    184|	    SET_STRING_ELT(names, i, namei);
  581|       |
  582|    184|	    if (argi == R_NilValue) {
  ------------------
  |  Branch (582:10): [True: 12, False: 172]
  ------------------
  583|       |		/* Handle option removal separately to simplify value checking
  584|       |		   for known options below; mandatory means not allowed to be
  585|       |		   removed once set. It makes sense to also set these options
  586|       |		   at startup, because otherwise one could not reliably restore
  587|       |		   previously saved options (see also PR#18372).*/
  588|     12|		const char *mandatory[] = {"prompt", "continue", "expressions",
  589|     12|		  "width", "deparse.cutoff", "digits", "echo", "quiet", "verbose",
  590|     12|		  "check.bounds", "keep.source", "keep.source.pkgs",
  591|     12|		  "keep.parse.data", "keep.parse.data.pkgs", "warning.length",
  592|     12|		  "nwarnings", "OutDec", "CBoundsCheck",
  593|     12|		  "matprod", "PCRE_study", "PCRE_use_JIT",
  594|     12|		  "PCRE_limit_recursion", "rl_word_breaks",
  595|     12|		  "max.contour.segments", "warnPartialMatchDollar",
  596|     12|		  "warnPartialMatchArgs", "warnPartialMatchAttr",
  597|     12|		  "showWarnCalls", "showErrorCalls", "showNCalls",
  598|     12|		  "browserNLdisabled",
  599|       |		  /* ^^^ from InitOptions ^^^ */
  600|     12|		  "warn", "max.print", "show.error.messages", "scipen",
  601|       |		  /* ^^^ from Common.R ^^^ */
  602|     12|		  NULL};
  603|    432|		for(int j = 0; mandatory[j] != NULL; j++)
  ------------------
  |  Branch (603:18): [True: 420, False: 12]
  ------------------
  604|    420|		    if (streql(CHAR(namei), mandatory[j]))
  ------------------
  |  | 1498|    420|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 420]
  |  |  ------------------
  ------------------
  605|      0|			error(_("option '%s' cannot be deleted"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              			error(_("option '%s' cannot be deleted"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              			error(_("option '%s' cannot be deleted"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  606|       |		// "else" :
  607|     12|		SET_VECTOR_ELT(value, i, SetOption(tag, R_NilValue));
  608|    172|	    } else if (streql(CHAR(namei), "width")) {
  ------------------
  |  | 1498|    172|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 172]
  |  |  ------------------
  ------------------
  609|      0|		int k = asInteger(argi);
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
  610|      0|		if (k < R_MIN_WIDTH_OPT || k > R_MAX_WIDTH_OPT)
  ------------------
  |  |   78|      0|#define R_MIN_WIDTH_OPT		10
  ------------------
              		if (k < R_MIN_WIDTH_OPT || k > R_MAX_WIDTH_OPT)
  ------------------
  |  |   79|      0|#define R_MAX_WIDTH_OPT		10000
  ------------------
  |  Branch (610:7): [True: 0, False: 0]
  |  Branch (610:30): [True: 0, False: 0]
  ------------------
  611|      0|		    error(_("invalid '%s' parameter, allowed %d...%d"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid '%s' parameter, allowed %d...%d"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  612|      0|			  CHAR(namei), R_MIN_WIDTH_OPT, R_MAX_WIDTH_OPT);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
              			  CHAR(namei), R_MIN_WIDTH_OPT, R_MAX_WIDTH_OPT);
  ------------------
  |  |   78|      0|#define R_MIN_WIDTH_OPT		10
  ------------------
              			  CHAR(namei), R_MIN_WIDTH_OPT, R_MAX_WIDTH_OPT);
  ------------------
  |  |   79|      0|#define R_MAX_WIDTH_OPT		10000
  ------------------
  613|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarInteger(k)));
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  614|      0|	    }
  615|    172|	    else if (streql(CHAR(namei), "deparse.cutoff")) {
  ------------------
  |  | 1498|    172|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 172]
  |  |  ------------------
  ------------------
  616|      0|		int k = asInteger(argi);
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
  617|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarInteger(k)));
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  618|      0|	    }
  619|    172|	    else if (streql(CHAR(namei), "digits")) {
  ------------------
  |  | 1498|    172|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 172]
  |  |  ------------------
  ------------------
  620|      0|		int k = asInteger(argi);
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
  621|      0|		if (k < R_MIN_DIGITS_OPT || k > R_MAX_DIGITS_OPT)
  ------------------
  |  |   80|      0|#define R_MIN_DIGITS_OPT	1
  ------------------
              		if (k < R_MIN_DIGITS_OPT || k > R_MAX_DIGITS_OPT)
  ------------------
  |  |   81|      0|#define R_MAX_DIGITS_OPT	22
  ------------------
  |  Branch (621:7): [True: 0, False: 0]
  |  Branch (621:31): [True: 0, False: 0]
  ------------------
  622|      0|		    error(_("invalid '%s' parameter, allowed %d...%d"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid '%s' parameter, allowed %d...%d"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  623|      0|			  CHAR(namei), R_MIN_DIGITS_OPT, R_MAX_DIGITS_OPT);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
              			  CHAR(namei), R_MIN_DIGITS_OPT, R_MAX_DIGITS_OPT);
  ------------------
  |  |   80|      0|#define R_MIN_DIGITS_OPT	1
  ------------------
              			  CHAR(namei), R_MIN_DIGITS_OPT, R_MAX_DIGITS_OPT);
  ------------------
  |  |   81|      0|#define R_MAX_DIGITS_OPT	22
  ------------------
  624|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarInteger(k)));
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  625|      0|	    }
  626|    172|	    else if (streql(CHAR(namei), "expressions")) {
  ------------------
  |  | 1498|    172|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 172]
  |  |  ------------------
  ------------------
  627|      0|		int k = asInteger(argi);
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
  628|      0|		if (k < R_MIN_EXPRESSIONS_OPT || k > R_MAX_EXPRESSIONS_OPT)
  ------------------
  |  |   31|      0|#define R_MIN_EXPRESSIONS_OPT	25
  ------------------
              		if (k < R_MIN_EXPRESSIONS_OPT || k > R_MAX_EXPRESSIONS_OPT)
  ------------------
  |  |   32|      0|#define R_MAX_EXPRESSIONS_OPT	500000
  ------------------
  |  Branch (628:7): [True: 0, False: 0]
  |  Branch (628:36): [True: 0, False: 0]
  ------------------
  629|      0|		    error(_("invalid '%s' parameter, allowed %d...%d"), CHAR(namei),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid '%s' parameter, allowed %d...%d"), CHAR(namei),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid '%s' parameter, allowed %d...%d"), CHAR(namei),
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  630|      0|			  R_MIN_EXPRESSIONS_OPT, R_MAX_EXPRESSIONS_OPT);
  ------------------
  |  |   31|      0|#define R_MIN_EXPRESSIONS_OPT	25
  ------------------
              			  R_MIN_EXPRESSIONS_OPT, R_MAX_EXPRESSIONS_OPT);
  ------------------
  |  |   32|      0|#define R_MAX_EXPRESSIONS_OPT	500000
  ------------------
  631|      0|		R_Expressions = R_Expressions_keep = k;
  632|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarInteger(k)));
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  633|      0|	    }
  634|    172|	    else if (streql(CHAR(namei), "keep.source")) {
  ------------------
  |  | 1498|    172|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 26, False: 146]
  |  |  ------------------
  ------------------
  635|     26|		if (TYPEOF(argi) != LGLSXP || LENGTH(argi) != 1)
  ------------------
  |  |  121|     52|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (635:7): [True: 0, False: 26]
  |  Branch (635:33): [True: 0, False: 26]
  ------------------
  636|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  637|     26|		Rboolean k = asRbool(argi, call);
  ------------------
  |  | 1861|     26|# define asRbool		Rf_asRbool
  ------------------
  638|     26|		R_KeepSource = k;
  639|     26|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarLogical(k)));
  ------------------
  |  | 1023|     26|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  640|     26|	    }
  641|    146|	    else if (streql(CHAR(namei), "editor") && isString(argi)) {
  ------------------
  |  | 1498|    292|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 2, False: 144]
  |  |  ------------------
  ------------------
              	    else if (streql(CHAR(namei), "editor") && isString(argi)) {
  ------------------
  |  |  966|      2|#define isString		Rf_isString
  ------------------
  |  Branch (641:48): [True: 2, False: 0]
  ------------------
  642|      2|		SEXP s =  asChar(argi);
  ------------------
  |  |  882|      2|#define asChar			Rf_asChar
  ------------------
  643|      2|		if (s == NA_STRING || LENGTH(s) == 0)
  ------------------
  |  |  433|      4|#define NA_STRING	R_NaString
  ------------------
  |  Branch (643:7): [True: 0, False: 2]
  |  Branch (643:25): [True: 0, False: 2]
  ------------------
  644|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  645|      2|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarString(s)));
  ------------------
  |  | 1025|      2|#define ScalarString		Rf_ScalarString
  ------------------
  646|      2|	    }
  647|    144|	    else if (streql(CHAR(namei), "continue")) {
  ------------------
  |  | 1498|    144|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 144]
  |  |  ------------------
  ------------------
  648|      0|		SEXP s =  asChar(argi);
  ------------------
  |  |  882|      0|#define asChar			Rf_asChar
  ------------------
  649|      0|		if (s == NA_STRING || LENGTH(s) == 0)
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (649:7): [True: 0, False: 0]
  |  Branch (649:25): [True: 0, False: 0]
  ------------------
  650|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  651|       |		/* We want to make sure these are in the native encoding */
  652|      0|		SET_VECTOR_ELT(value, i,
  653|      0|			       SetOption(tag, mkString(translateChar(s))));
  ------------------
  |  | 1003|      0|#define mkString		Rf_mkString
  ------------------
              			       SetOption(tag, mkString(translateChar(s))));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  654|      0|	    }
  655|    144|	    else if (streql(CHAR(namei), "prompt")) {
  ------------------
  |  | 1498|    144|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 144]
  |  |  ------------------
  ------------------
  656|      0|		SEXP s =  asChar(argi);
  ------------------
  |  |  882|      0|#define asChar			Rf_asChar
  ------------------
  657|      0|		if (s == NA_STRING || LENGTH(s) == 0)
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (657:7): [True: 0, False: 0]
  |  Branch (657:25): [True: 0, False: 0]
  ------------------
  658|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  659|       |		/* We want to make sure these are in the native encoding */
  660|      0|		SET_VECTOR_ELT(value, i,
  661|      0|			       SetOption(tag, mkString(translateChar(s))));
  ------------------
  |  | 1003|      0|#define mkString		Rf_mkString
  ------------------
              			       SetOption(tag, mkString(translateChar(s))));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  662|      0|	    }
  663|    144|	    else if (streql(CHAR(namei), "contrasts")) {
  ------------------
  |  | 1498|    144|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 2, False: 142]
  |  |  ------------------
  ------------------
  664|      2|		if (TYPEOF(argi) != STRSXP || LENGTH(argi) != 2)
  ------------------
  |  |  126|      4|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (664:7): [True: 0, False: 2]
  |  Branch (664:33): [True: 0, False: 2]
  ------------------
  665|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  666|      2|		SET_VECTOR_ELT(value, i, SetOption(tag, argi));
  667|      2|	    }
  668|    142|	    else if (streql(CHAR(namei), "check.bounds")) {
  ------------------
  |  | 1498|    142|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 142]
  |  |  ------------------
  ------------------
  669|      0|		if (TYPEOF(argi) != LGLSXP || LENGTH(argi) != 1)
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (669:7): [True: 0, False: 0]
  |  Branch (669:33): [True: 0, False: 0]
  ------------------
  670|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  671|      0|		int k = asLogical(argi);
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
  672|       |		/* R_CheckBounds = k; */
  673|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarLogical(k)));
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  674|      0|	    }
  675|    142|	    else if (streql(CHAR(namei), "warn")) {
  ------------------
  |  | 1498|    142|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 4, False: 138]
  |  |  ------------------
  ------------------
  676|      4|		if (!isNumeric(argi) || LENGTH(argi) != 1)
  ------------------
  |  |  957|      4|#define isNumeric		Rf_isNumeric
  ------------------
  |  Branch (676:7): [True: 0, False: 4]
  |  Branch (676:27): [True: 0, False: 4]
  ------------------
  677|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  678|      4|		int k;
  679|       |		// k = asInteger(argi) wld give both error + warning
  680|      4|		if(TYPEOF(argi) == REALSXP) {
  ------------------
  |  |  124|      4|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (680:6): [True: 2, False: 2]
  ------------------
  681|      2|		    int w;
  682|      2|		    k = IntegerFromReal(REAL_ELT(argi, 0), &w);
  ------------------
  |  | 1927|      2|# define IntegerFromReal	Rf_IntegerFromReal
  ------------------
  683|      2|		} else {
  684|      2|		    k = asInteger(argi);
  ------------------
  |  |  885|      2|#define asInteger		Rf_asInteger
  ------------------
  685|      2|		}
  686|      4|		if (k == NA_INTEGER)
  ------------------
  |  |   56|      4|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (686:7): [True: 0, False: 4]
  ------------------
  687|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  688|      4|#ifndef _ALLOW_WARN_OUT_OF_BOUNDS_OPT_
  689|      4|		char *p = getenv("R_WARN_BOUNDS_OPT");
  690|      4|		if ((p && (strcmp(p, "yes") == 0)) && (k < -1 || k > 2)) {
  ------------------
  |  Branch (690:8): [True: 0, False: 4]
  |  Branch (690:13): [True: 0, False: 0]
  |  Branch (690:42): [True: 0, False: 0]
  |  Branch (690:52): [True: 0, False: 0]
  ------------------
  691|      0|		    int k_n = (k < 0) ? -1 : 2;
  ------------------
  |  Branch (691:17): [True: 0, False: 0]
  ------------------
  692|      0|		    warning(_("value for '%s' outside of -1:2 is set to %d\n"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		    warning(_("value for '%s' outside of -1:2 is set to %d\n"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  693|      0|			     CHAR(namei), k_n);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  694|      0|		    k = k_n;
  695|      0|		}
  696|      4|#endif
  697|      4|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarInteger(k)));
  ------------------
  |  | 1022|      4|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  698|      4|	    }
  699|    138|	    else if (streql(CHAR(namei), "warning.length")) {
  ------------------
  |  | 1498|    138|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 138]
  |  |  ------------------
  ------------------
  700|      0|		int k = asInteger(argi);
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
  701|      0|		if (k < 100 || k > 8170)
  ------------------
  |  Branch (701:7): [True: 0, False: 0]
  |  Branch (701:18): [True: 0, False: 0]
  ------------------
  702|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  703|      0|		R_WarnLength = k;
  704|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, argi));
  705|      0|	    }
  706|    138|	    else if ( streql(CHAR(namei), "warning.expression") )  {
  ------------------
  |  | 1498|    138|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 138]
  |  |  ------------------
  ------------------
  707|      0|		if( !isLanguage(argi) &&  ! isExpression(argi) )
  ------------------
  |  |  950|      0|#define isLanguage		Rf_isLanguage
  ------------------
              		if( !isLanguage(argi) &&  ! isExpression(argi) )
  ------------------
  |  |  945|      0|#define isExpression		Rf_isExpression
  ------------------
  |  Branch (707:7): [True: 0, False: 0]
  |  Branch (707:29): [True: 0, False: 0]
  ------------------
  708|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  709|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, argi));
  710|      0|	    }
  711|    138|	    else if (streql(CHAR(namei), "max.print")) {
  ------------------
  |  | 1498|    138|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 2, False: 136]
  |  |  ------------------
  ------------------
  712|      2|		int k = asInteger(argi);
  ------------------
  |  |  885|      2|#define asInteger		Rf_asInteger
  ------------------
  713|      2|		if (k < 1) error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		if (k < 1) error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		if (k < 1) error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (713:7): [True: 0, False: 2]
  ------------------
  714|      2|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarInteger(k)));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  715|      2|	    }
  716|    136|	    else if (streql(CHAR(namei), "scipen")) {
  ------------------
  |  | 1498|    136|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 2, False: 134]
  |  |  ------------------
  ------------------
  717|      2|		int k = FixupScipen(argi, iWARN); /* to become iERROR in say 2027 */
  718|      2|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarInteger(k)));
  ------------------
  |  | 1022|      2|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  719|      2|	    }
  720|    134|	    else if (streql(CHAR(namei), "nwarnings")) {
  ------------------
  |  | 1498|    134|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 134]
  |  |  ------------------
  ------------------
  721|      0|		int k = asInteger(argi);
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
  722|      0|		if (k < 1) error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		if (k < 1) error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		if (k < 1) error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (722:7): [True: 0, False: 0]
  ------------------
  723|      0|		R_nwarnings = k;
  724|      0|		R_CollectWarnings = 0; /* force a reset */
  725|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarInteger(k)));
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  726|      0|	    }
  727|    134|	    else if ( streql(CHAR(namei), "error") ) {
  ------------------
  |  | 1498|    134|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 134]
  |  |  ------------------
  ------------------
  728|      0|		if(isFunction(argi))
  ------------------
  |  |  948|      0|#define isFunction		Rf_isFunction
  ------------------
  |  Branch (728:6): [True: 0, False: 0]
  ------------------
  729|      0|		  argi = makeErrorCall(argi);
  730|      0|		else if( !isLanguage(argi) &&  !isExpression(argi) )
  ------------------
  |  |  950|      0|#define isLanguage		Rf_isLanguage
  ------------------
              		else if( !isLanguage(argi) &&  !isExpression(argi) )
  ------------------
  |  |  945|      0|#define isExpression		Rf_isExpression
  ------------------
  |  Branch (730:12): [True: 0, False: 0]
  |  Branch (730:34): [True: 0, False: 0]
  ------------------
  731|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  732|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, argi));
  733|      0|	    }
  734|       |/* handle this here to avoid GetOption1 during error handling */
  735|    134|	    else if ( streql(CHAR(namei), "show.error.messages") ) {
  ------------------
  |  | 1498|    134|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 2, False: 132]
  |  |  ------------------
  ------------------
  736|      2|		check_TRUE_FALSE(argi, CHAR(namei));
  ------------------
  |  |  203|      2|#define CHAR(x) R_CHAR(x)
  ------------------
  737|      2|		R_ShowErrorMessages = LOGICAL(argi)[0];
  738|      2|		SET_VECTOR_ELT(value, i, SetOption(tag, argi));
  739|      2|	    }
  740|    132|	    else if ( streql(CHAR(namei), "catch.script.errors") ) {
  ------------------
  |  | 1498|    132|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 2, False: 130]
  |  |  ------------------
  ------------------
  741|      2|		check_TRUE_FALSE(argi, CHAR(namei));
  ------------------
  |  |  203|      2|#define CHAR(x) R_CHAR(x)
  ------------------
  742|      2|		SET_VECTOR_ELT(value, i, SetOption(tag, argi));
  743|      2|	    }
  744|    130|	    else if (streql(CHAR(namei), "echo")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  745|      0|		if (TYPEOF(argi) != LGLSXP || LENGTH(argi) != 1)
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (745:7): [True: 0, False: 0]
  |  Branch (745:33): [True: 0, False: 0]
  ------------------
  746|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  747|      0|		int k = asLogical(argi);
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
  748|       |		/* Should be quicker than checking options(echo)
  749|       |		   every time R prompts for input:
  750|       |		   */
  751|      0|		R_NoEcho = !k;
  752|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarLogical(k)));
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  753|      0|	    }
  754|    130|	    else if (streql(CHAR(namei), "OutDec")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  755|      0|		if (TYPEOF(argi) != STRSXP || LENGTH(argi) != 1)
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (755:7): [True: 0, False: 0]
  |  Branch (755:33): [True: 0, False: 0]
  ------------------
  756|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  757|      0|		static char sdec[11];
  758|      0|		if(R_nchar(STRING_ELT(argi, 0), Chars,
  ------------------
  |  Branch (758:6): [True: 0, False: 0]
  ------------------
  759|      0|			   /* allowNA = */ FALSE, /* keepNA = */ FALSE,
  760|      0|			   "OutDec") != 1) // will become an error
  761|      0|		    warning(_("'OutDec' must be a string of one character"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		    warning(_("'OutDec' must be a string of one character"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  762|      0|		strncpy(sdec, CHAR(STRING_ELT(argi, 0)), 10);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  763|      0|		sdec[10] = '\0';
  764|      0|		OutDec = sdec;
  765|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, duplicate(argi)));
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
  766|      0|	    }
  767|    130|	    else if (streql(CHAR(namei), "max.contour.segments")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  768|      0|		int k = asInteger(argi);
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
  769|      0|		if (k < 0) // also many times above: rely on  NA_INTEGER  <  <finite_int>
  ------------------
  |  Branch (769:7): [True: 0, False: 0]
  ------------------
  770|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  771|      0|		max_contour_segments = k;
  772|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarInteger(k)));
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  773|      0|	    }
  774|    130|	    else if (streql(CHAR(namei), "rl_word_breaks")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  775|      0|		if (TYPEOF(argi) != STRSXP || LENGTH(argi) != 1)
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (775:7): [True: 0, False: 0]
  |  Branch (775:33): [True: 0, False: 0]
  ------------------
  776|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  777|      0|#ifdef HAVE_RL_COMPLETION_MATCHES
  778|      0|		set_rl_word_breaks(CHAR(STRING_ELT(argi, 0)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  779|      0|#endif
  780|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, duplicate(argi)));
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
  781|      0|	    }
  782|    130|	    else if (streql(CHAR(namei), "warnPartialMatchDollar")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  783|      0|		check_TRUE_FALSE(argi, CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  784|      0|		R_warn_partial_match_dollar = asRbool(argi, call);
  ------------------
  |  | 1861|      0|# define asRbool		Rf_asRbool
  ------------------
  785|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, argi));
  786|      0|	    }
  787|    130|	    else if (streql(CHAR(namei), "warnPartialMatchArgs")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  788|      0|		check_TRUE_FALSE(argi, CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  789|      0|		R_warn_partial_match_args = asRbool(argi, call);
  ------------------
  |  | 1861|      0|# define asRbool		Rf_asRbool
  ------------------
  790|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, argi));
  791|      0|	    }
  792|    130|	    else if (streql(CHAR(namei), "warnPartialMatchAttr")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  793|      0|		check_TRUE_FALSE(argi, CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  794|      0|		R_warn_partial_match_attr = asRbool(argi, call);
  ------------------
  |  | 1861|      0|# define asRbool		Rf_asRbool
  ------------------
  795|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, argi));
  796|      0|	    }
  797|    130|	    else if (streql(CHAR(namei), "showWarnCalls")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  798|      0|		check_TRUE_FALSE(argi, CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  799|      0|		R_ShowWarnCalls = asRbool(argi, call);
  ------------------
  |  | 1861|      0|# define asRbool		Rf_asRbool
  ------------------
  800|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, argi));
  801|      0|	    }
  802|    130|	    else if (streql(CHAR(namei), "showErrorCalls")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  803|      0|		check_TRUE_FALSE(argi, CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  804|      0|		R_ShowErrorCalls = asRbool(argi, call);
  ------------------
  |  | 1861|      0|# define asRbool		Rf_asRbool
  ------------------
  805|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, argi));
  806|      0|	    }
  807|    130|	    else if (streql(CHAR(namei), "showNCalls")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  808|      0|		int k = asInteger(argi);
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
  809|      0|		if (k < 30 || k > 500 || k == NA_INTEGER || LENGTH(argi) != 1)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (809:7): [True: 0, False: 0]
  |  Branch (809:17): [True: 0, False: 0]
  |  Branch (809:28): [True: 0, False: 0]
  |  Branch (809:47): [True: 0, False: 0]
  ------------------
  810|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  811|      0|		R_NShowCalls = k;
  812|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarInteger(k)));
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  813|      0|	    }
  814|    130|	    else if (streql(CHAR(namei), "par.ask.default")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  815|      0|		error(_("\"par.ask.default\" has been replaced by \"device.ask.default\""));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("\"par.ask.default\" has been replaced by \"device.ask.default\""));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  816|      0|	    }
  817|    130|	    else if (streql(CHAR(namei), "browserNLdisabled")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  818|      0|		check_TRUE_FALSE(argi, CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  819|      0|		R_DisableNLinBrowser = asRbool(argi, call);
  ------------------
  |  | 1861|      0|# define asRbool		Rf_asRbool
  ------------------
  820|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, argi));
  821|      0|	    }
  822|    130|	    else if (streql(CHAR(namei), "CBoundsCheck")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  823|      0|		check_TRUE_FALSE(argi, CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  824|      0|		R_CBoundsCheck = asRbool(argi, call);
  ------------------
  |  | 1861|      0|# define asRbool		Rf_asRbool
  ------------------
  825|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, argi));
  826|      0|	    }
  827|    130|	    else if (streql(CHAR(namei), "matprod")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  828|      0|		SEXP s = asChar(argi);
  ------------------
  |  |  882|      0|#define asChar			Rf_asChar
  ------------------
  829|      0|		if (s == NA_STRING || LENGTH(s) == 0)
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (829:7): [True: 0, False: 0]
  |  Branch (829:25): [True: 0, False: 0]
  ------------------
  830|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  831|      0|		if (streql(CHAR(s), "default"))
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  832|      0|		    R_Matprod = MATPROD_DEFAULT;
  833|      0|		else if (streql(CHAR(s), "internal"))
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  834|      0|		    R_Matprod = MATPROD_INTERNAL;
  835|      0|		else if (streql(CHAR(s), "blas"))
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  836|      0|		    R_Matprod = MATPROD_BLAS;
  837|      0|		else if (streql(CHAR(s), "default.simd")) {
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  838|      0|		    R_Matprod = MATPROD_DEFAULT_SIMD;
  839|      0|#if !defined(_OPENMP) || !defined(HAVE_OPENMP_SIMDRED)
  840|      0|		    warning(_("OpenMP SIMD is not supported in this build of R"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		    warning(_("OpenMP SIMD is not supported in this build of R"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  841|      0|#endif
  842|      0|		} else
  843|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  844|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, duplicate(argi)));
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
  845|      0|	    }
  846|    130|	    else if (streql(CHAR(namei), "PCRE_study")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  847|      0|		if (TYPEOF(argi) == LGLSXP) {
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (847:7): [True: 0, False: 0]
  ------------------
  848|      0|		    int k = asLogical(argi) > 0;
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
  849|      0|		    R_PCRE_study = k ? -1 : -2;
  ------------------
  |  Branch (849:22): [True: 0, False: 0]
  ------------------
  850|      0|		    SET_VECTOR_ELT(value, i,
  851|      0|				   SetOption(tag, ScalarLogical(k)));
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  852|      0|		} else {
  853|      0|		    R_PCRE_study = asInteger(argi);
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
  854|      0|		    if (R_PCRE_study < 0) {
  ------------------
  |  Branch (854:11): [True: 0, False: 0]
  ------------------
  855|      0|			R_PCRE_study = -2;
  856|      0|			SET_VECTOR_ELT(value, i,
  857|      0|				       SetOption(tag, ScalarLogical(-2)));
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  858|      0|		    } else
  859|      0|			SET_VECTOR_ELT(value, i,
  860|      0|				       SetOption(tag, ScalarInteger(R_PCRE_study)));
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  861|      0|		}
  862|      0|#ifdef HAVE_PCRE2
  863|      0|		if (R_PCRE_study != -2)
  ------------------
  |  Branch (863:7): [True: 0, False: 0]
  ------------------
  864|      0|		    warning(_("'PCRE_study' has no effect with PCRE2"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		    warning(_("'PCRE_study' has no effect with PCRE2"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  865|      0|#endif
  866|      0|	    }
  867|    130|	    else if (streql(CHAR(namei), "PCRE_use_JIT")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  868|      0|		int use_JIT = asLogical(argi);
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
  869|      0|		R_PCRE_use_JIT = (use_JIT > 0); // NA_LOGICAL is < 0
  870|      0|		SET_VECTOR_ELT(value, i,
  871|      0|			       SetOption(tag, ScalarLogical(R_PCRE_use_JIT)));
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  872|      0|	    }
  873|    130|	    else if (streql(CHAR(namei), "PCRE_limit_recursion")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  874|      0|		R_PCRE_limit_recursion = asLogical(argi);
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
  875|      0|		SET_VECTOR_ELT(value, i,
  876|      0|			       SetOption(tag, ScalarLogical(R_PCRE_limit_recursion)));
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  877|       |		/* could warn for PCRE2 >= 10.30, but the value is ignored also when
  878|       |		   JIT is used  */
  879|      0|	    }
  880|    130|	    else if (streql(CHAR(namei), "stringsAsFactors")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  881|      0|		int strings_as_fact;
  882|      0|		if (TYPEOF(argi) != LGLSXP || LENGTH(argi) != 1 ||
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (882:7): [True: 0, False: 0]
  |  Branch (882:33): [True: 0, False: 0]
  ------------------
  883|      0|		    (strings_as_fact = asLogical(argi)) == NA_LOGICAL)
  ------------------
  |  |  886|      0|#define asLogical		Rf_asLogical
  ------------------
              		    (strings_as_fact = asLogical(argi)) == NA_LOGICAL)
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (883:7): [True: 0, False: 0]
  ------------------
  884|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  885|      0|		if(strings_as_fact && !warned_on_strings_as_fact) {
  ------------------
  |  Branch (885:6): [True: 0, False: 0]
  |  Branch (885:25): [True: 0, False: 0]
  ------------------
  886|      0|		    warned_on_strings_as_fact = TRUE;
  887|      0|		    warning(_("'%s' is deprecated and will be disabled"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		    warning(_("'%s' is deprecated and will be disabled"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  888|      0|			    "options(stringsAsFactors = TRUE)");
  889|      0|		}
  890|      0|		SET_VECTOR_ELT(value, i,
  891|      0|			       SetOption(tag, ScalarLogical(strings_as_fact)));
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  892|      0|	    }
  893|    130|	    else if (streql(CHAR(namei), "quiet")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  894|      0|		if (TYPEOF(argi) != LGLSXP || LENGTH(argi) != 1)
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (894:7): [True: 0, False: 0]
  |  Branch (894:33): [True: 0, False: 0]
  ------------------
  895|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  896|      0|		Rboolean k = asRbool(argi, call);
  ------------------
  |  | 1861|      0|# define asRbool		Rf_asRbool
  ------------------
  897|       |#ifdef NO_QUIET_AND_VERBOSE
  898|       |		if(k && R_Verbose)
  899|       |		    error(_("cannot set both options 'quiet' and 'verbose' to TRUE"));
  900|       |#endif
  901|      0|		R_Quiet = k;
  902|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarLogical(k)));
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  903|      0|	    }
  904|    130|	    else if (streql(CHAR(namei), "verbose")) {
  ------------------
  |  | 1498|    130|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 130]
  |  |  ------------------
  ------------------
  905|      0|		if (TYPEOF(argi) != LGLSXP || LENGTH(argi) != 1)
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (905:7): [True: 0, False: 0]
  |  Branch (905:33): [True: 0, False: 0]
  ------------------
  906|      0|		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		    error(_("invalid value for '%s'"), CHAR(namei));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  907|      0|		Rboolean k = asRbool(argi, call);
  ------------------
  |  | 1861|      0|# define asRbool		Rf_asRbool
  ------------------
  908|       |#ifdef NO_QUIET_AND_VERBOSE
  909|       |		if(k && R_Quiet)
  910|       |		    error(_("cannot set both options 'quiet' and 'verbose' to TRUE"));
  911|       |#endif
  912|      0|		R_Verbose = k;
  913|      0|		SET_VECTOR_ELT(value, i, SetOption(tag, ScalarLogical(k)));
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  914|      0|	    }
  915|    130|	    else {
  916|    130|		SET_VECTOR_ELT(value, i, SetOption(tag, duplicate(argi)));
  ------------------
  |  |  909|    130|#define duplicate		Rf_duplicate
  ------------------
  917|    130|	    }
  918|    184|	}
  919|      0|	else { /* querying arg */
  920|      0|	    const char *tag;
  921|      0|	    if (!isString(argi) || LENGTH(argi) <= 0)
  ------------------
  |  |  966|      0|#define isString		Rf_isString
  ------------------
  |  Branch (921:10): [True: 0, False: 0]
  |  Branch (921:29): [True: 0, False: 0]
  ------------------
  922|      0|		error(_("invalid argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("invalid argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  923|      0|	    tag = translateChar(STRING_ELT(argi, 0));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  924|      0|	    if (streql(tag, "par.ask.default")) {
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  925|      0|		error(_("\"par.ask.default\" has been replaced by \"device.ask.default\""));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("\"par.ask.default\" has been replaced by \"device.ask.default\""));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  926|      0|	    }
  927|       |
  928|      0|	    SET_VECTOR_ELT(value, i, duplicate(CAR(FindTaggedItem(options, install(tag)))));
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
              	    SET_VECTOR_ELT(value, i, duplicate(CAR(FindTaggedItem(options, install(tag)))));
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
  929|      0|	    SET_STRING_ELT(names, i, STRING_ELT(argi, 0));
  930|      0|	    visible = TRUE;
  931|      0|	}
  932|    184|    } /* for() */
  933|     78|    setAttrib(value, R_NamesSymbol, names);
  ------------------
  |  | 1027|     78|#define setAttrib		Rf_setAttrib
  ------------------
  934|     78|    UNPROTECT(3); /* value, names, argnames */
  ------------------
  |  |  358|     78|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  935|     78|    R_Visible = visible;
  936|     78|    return value;
  937|     78|}
options.c:Options:
  101|   787k|{
  102|   787k|    static SEXP sOptions = NULL;
  103|   787k|    if(!sOptions) sOptions = install(".Options");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  |  Branch (103:8): [True: 2, False: 787k]
  ------------------
  104|   787k|    return sOptions;
  105|   787k|}
options.c:FindTaggedItem:
  108|   787k|{
  109|  41.2M|    for ( ; lst != R_NilValue ; lst = CDR(lst)) {
  ------------------
  |  Branch (109:13): [True: 40.8M, False: 388k]
  ------------------
  110|  40.8M|	if (TAG(lst) == tag) {
  ------------------
  |  Branch (110:6): [True: 399k, False: 40.4M]
  ------------------
  111|   399k|	    if (CAR(lst) == R_NilValue)
  ------------------
  |  Branch (111:10): [True: 0, False: 399k]
  ------------------
  112|      0|		error("option %s has NULL value", CHAR(PRINTNAME(tag)));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error("option %s has NULL value", CHAR(PRINTNAME(tag)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  113|   399k|	    return lst;
  114|   399k|	}
  115|  40.8M|    }
  116|   388k|    return R_NilValue;
  117|   787k|}
options.c:SetOption:
  230|    184|{
  231|    184|    SEXP opt, old, t;
  232|    184|    PROTECT(value);
  ------------------
  |  |  357|    184|#define PROTECT(s)	Rf_protect(s)
  ------------------
  233|    184|    t = opt = SYMVALUE(Options());
  234|    184|    if (!isList(opt))
  ------------------
  |  |  951|    184|#define isList			Rf_isList
  ------------------
  |  Branch (234:9): [True: 0, False: 184]
  ------------------
  235|      0|	error(_("corrupted options list"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("corrupted options list"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  236|    184|    opt = FindTaggedItem(opt, tag);
  237|       |
  238|       |    /* The option is being removed. */
  239|    184|    if (value == R_NilValue) {
  ------------------
  |  Branch (239:9): [True: 12, False: 172]
  ------------------
  240|    726|	for ( ; t != R_NilValue ; t = CDR(t))
  ------------------
  |  Branch (240:10): [True: 726, False: 0]
  ------------------
  241|    726|	    if (TAG(CDR(t)) == tag) {
  ------------------
  |  Branch (241:10): [True: 12, False: 714]
  ------------------
  242|     12|		old = CAR(CDR(t));
  243|     12|		SETCDR(t, CDDR(t));
  244|     12|		UNPROTECT(1); /* value */
  ------------------
  |  |  358|     12|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  245|     12|		return old;
  246|     12|	    }
  247|      0|	UNPROTECT(1); /* value */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  248|      0|	return R_NilValue;
  249|     12|    }
  250|       |    /* If the option is new, a new slot */
  251|       |    /* is added to the end of .Options */
  252|    172|    if (opt == R_NilValue) {
  ------------------
  |  Branch (252:9): [True: 96, False: 76]
  ------------------
  253|  5.05k|	while (CDR(t) != R_NilValue)
  ------------------
  |  Branch (253:9): [True: 4.95k, False: 96]
  ------------------
  254|  4.95k|	    t = CDR(t);
  255|     96|	SETCDR(t, allocList(1));
  ------------------
  |  |  871|     96|#define allocList		Rf_allocList
  ------------------
  256|     96|	opt = CDR(t);
  257|     96|	SET_TAG(opt, tag);
  258|     96|    }
  259|    172|    old = CAR(opt);
  260|    172|    SETCAR(opt, value);
  261|    172|    UNPROTECT(1); /* value */
  ------------------
  |  |  358|    172|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  262|    172|    return old;
  263|    184|}
options.c:FixupScipen:
  175|      2|{
  176|      2|    if (!isNumeric(scipen) || LENGTH(scipen) != 1)
  ------------------
  |  |  957|      2|#define isNumeric		Rf_isNumeric
  ------------------
  |  Branch (176:9): [True: 0, False: 2]
  |  Branch (176:31): [True: 0, False: 2]
  ------------------
  177|      0|	error(_("invalid 'scipen'"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid 'scipen'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  178|      2|    int d;
  179|      2|    if(TYPEOF(scipen) == REALSXP) { /* preventing warning + error : */
  ------------------
  |  |  124|      2|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (179:8): [True: 2, False: 0]
  ------------------
  180|      2|	int w = 0;
  181|      2|	d = IntegerFromReal(REAL_ELT(scipen, 0), &w);
  ------------------
  |  | 1927|      2|# define IntegerFromReal	Rf_IntegerFromReal
  ------------------
  182|      2|	if(w && d == NA_INTEGER)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (182:5): [True: 0, False: 2]
  |  Branch (182:10): [True: 0, False: 0]
  ------------------
  183|      0|	    error(_("setting scipen=%g is out of range"), REAL_ELT(scipen,0));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("setting scipen=%g is out of range"), REAL_ELT(scipen,0));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  184|      2|    } else
  185|      0|	d = asInteger(scipen);
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
  186|      2|    if (d == NA_INTEGER || d < R_MIN_SCIPEN_OPT || d > R_MAX_SCIPEN_OPT) {
  ------------------
  |  |   56|      4|#define NA_INTEGER	R_NaInt
  ------------------
                  if (d == NA_INTEGER || d < R_MIN_SCIPEN_OPT || d > R_MAX_SCIPEN_OPT) {
  ------------------
  |  |   82|      4|#define R_MIN_SCIPEN_OPT        -9
  ------------------
                  if (d == NA_INTEGER || d < R_MIN_SCIPEN_OPT || d > R_MAX_SCIPEN_OPT) {
  ------------------
  |  |   83|      2|#define R_MAX_SCIPEN_OPT	9999
  ------------------
  |  Branch (186:9): [True: 0, False: 2]
  |  Branch (186:28): [True: 0, False: 2]
  |  Branch (186:52): [True: 0, False: 2]
  ------------------
  187|      0|	int dnew = (d == NA_INTEGER) ? 0 :
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (187:13): [True: 0, False: 0]
  ------------------
  188|      0|	      (d < R_MIN_SCIPEN_OPT) ? R_MIN_SCIPEN_OPT :
  ------------------
  |  |   82|      0|#define R_MIN_SCIPEN_OPT        -9
  ------------------
              	      (d < R_MIN_SCIPEN_OPT) ? R_MIN_SCIPEN_OPT :
  ------------------
  |  |   82|      0|#define R_MIN_SCIPEN_OPT        -9
  ------------------
  |  Branch (188:8): [True: 0, False: 0]
  ------------------
  189|      0|	    /* d > R_MAX_SCIPEN_OPT */ R_MAX_SCIPEN_OPT;
  ------------------
  |  |   83|      0|#define R_MAX_SCIPEN_OPT	9999
  ------------------
  190|      0|	switch(warn) {
  ------------------
  |  Branch (190:9): [True: 0, False: 0]
  ------------------
  191|      0|	case iWARN: warning(_("invalid 'scipen' %d, used %d"), d, dnew);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	case iWARN: warning(_("invalid 'scipen' %d, used %d"), d, dnew);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (191:2): [True: 0, False: 0]
  ------------------
  192|      0|	case iSILENT:
  ------------------
  |  Branch (192:2): [True: 0, False: 0]
  ------------------
  193|      0|	    return dnew; // for SILENT and WARN
  194|      0|	case iERROR: error(_("invalid 'scipen' %d"), d);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	case iERROR: error(_("invalid 'scipen' %d"), d);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (194:2): [True: 0, False: 0]
  ------------------
  195|      0|	}
  196|      0|    }
  197|      2|    return d;
  198|      2|}
options.c:check_TRUE_FALSE:
  476|      4|static void check_TRUE_FALSE(SEXP arg, const char *chname) {
  477|      4|    if(TYPEOF(arg) != LGLSXP || LENGTH(arg) != 1 || LOGICAL(arg)[0] == NA_LOGICAL)
  ------------------
  |  |  121|      8|#define LGLSXP	    10	  /* logical vectors */
  ------------------
                  if(TYPEOF(arg) != LGLSXP || LENGTH(arg) != 1 || LOGICAL(arg)[0] == NA_LOGICAL)
  ------------------
  |  |   55|      4|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (477:8): [True: 0, False: 4]
  |  Branch (477:33): [True: 0, False: 4]
  |  Branch (477:53): [True: 0, False: 4]
  ------------------
  478|      0|	error(_("invalid value for '%s'"), chname);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid value for '%s'"), chname);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  479|      4|}

do_paste:
   56|    969|{
   57|       |/* do_paste uses two passes to paste the arguments (in CAR(args)) together.
   58|       | * The first pass calculates the width of the paste buffer,
   59|       | * then it is alloc-ed and the second pass stuffs the information in.
   60|       |
   61|       | * Note that NA_STRING is not handled separately here.  This is
   62|       | *  deliberate -- see ?paste -- and implicitly coerces it to "NA"
   63|       | */
   64|       |
   65|    969|    SEXP collapse, sep;
   66|    969|    bool recycle_0;
   67|       |
   68|       |/* We need to be careful here.  For example currently Windows 4.1
   69|       | * packages are links to 4.0, 4.0.0 uses only 3 args for paste and
   70|       | * 4.0.x (x >= 1) use 3 unless recycle0 is true.  So 4.1 needs to
   71|       | * accept 3-arg form, silently.
   72|       | */
   73|       |
   74|       |// TODO !??
   75|       |#ifdef future_R_4_1_or_newer
   76|       |    checkArity(op, args);
   77|       |#else
   78|    969|    int nargs = length(args);
  ------------------
  |  |  987|    969|#define length(x)		Rf_length(x)
  ------------------
   79|    969|    bool correct_nargs = (PRIMARITY(op) == nargs);
  ------------------
  |  | 1348|    969|#define PRIMARITY(x)	(R_FunTab[PRIMOFFSET(x)].arity)
  ------------------
   80|    969|    if(!correct_nargs) { // we allow one less for capture from earlier versions
  ------------------
  |  Branch (80:8): [True: 0, False: 969]
  ------------------
   81|      0|	if(PRIMARITY(op) == nargs + 1) {
  ------------------
  |  | 1348|      0|#define PRIMARITY(x)	(R_FunTab[PRIMOFFSET(x)].arity)
  ------------------
  |  Branch (81:5): [True: 0, False: 0]
  ------------------
   82|      0|	    recycle_0 = false;
   83|       |#if 0
   84|       |	    REprintf("%d arguments passed to .Internal(%s) which requires %d;\n an S4 method"
   85|       |		     " may need to be redefined, typically by re-installing a package\n",
   86|       |		     nargs, PRIMNAME(op), PRIMARITY(op));
   87|       |#endif
   88|      0|	}
   89|      0|	else // not even "ok":
   90|      0|	    error(ngettext("%d argument passed to .Internal(%s) which requires %d",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
   91|      0|			   "%d arguments passed to .Internal(%s) which requires %d",
   92|      0|			   (unsigned long) nargs),
   93|      0|		  nargs, PRIMNAME(op), PRIMARITY(op));
  ------------------
  |  | 1346|      0|#define PRIMNAME(x)	(R_FunTab[PRIMOFFSET(x)].name)
  ------------------
              		  nargs, PRIMNAME(op), PRIMARITY(op));
  ------------------
  |  | 1348|      0|#define PRIMARITY(x)	(R_FunTab[PRIMOFFSET(x)].arity)
  ------------------
   94|      0|    }
   95|    969|#endif
   96|       |
   97|       |    /* We use formatting and so we must initialize printing. */
   98|       |
   99|    969|    PrintDefaults();
  ------------------
  |  | 1970|    969|# define PrintDefaults		Rf_PrintDefaults
  ------------------
  100|       |
  101|       |    /* Check the arguments */
  102|       |
  103|    969|    SEXP x = CAR(args);
  104|    969|    if (!isVectorList(x))
  ------------------
  |  |  977|    969|#define isVectorList		Rf_isVectorList
  ------------------
  |  Branch (104:9): [True: 0, False: 969]
  ------------------
  105|      0|	error(_("invalid first argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid first argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  106|    969|    R_xlen_t nx = xlength(x);
  ------------------
  |  | 1049|    969|#define xlength(x)		Rf_xlength(x)
  ------------------
  107|       |
  108|    969|    const char *csep = NULL;
  109|    969|    int sepw, u_sepw;
  110|    969|    bool sepASCII = true, sepUTF8 = false, sepBytes = false,
  111|    969|	sepKnown = false, use_sep = (PRIMVAL(op) == 0);
  ------------------
  |  | 1347|    969|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  112|    969|    if(use_sep) { /* paste(..., sep, .) */
  ------------------
  |  Branch (112:8): [True: 102, False: 867]
  ------------------
  113|    102|	sep = CADR(args);
  114|    102|	if (!isString(sep) || LENGTH(sep) <= 0 || STRING_ELT(sep, 0) == NA_STRING)
  ------------------
  |  |  966|    102|#define isString		Rf_isString
  ------------------
              	if (!isString(sep) || LENGTH(sep) <= 0 || STRING_ELT(sep, 0) == NA_STRING)
  ------------------
  |  |  433|    102|#define NA_STRING	R_NaString
  ------------------
  |  Branch (114:6): [True: 0, False: 102]
  |  Branch (114:24): [True: 0, False: 102]
  |  Branch (114:44): [True: 0, False: 102]
  ------------------
  115|      0|	    error(_("invalid separator"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid separator"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  116|    102|	sep = STRING_ELT(sep, 0);
  117|    102|	csep = translateChar(sep);
  ------------------
  |  | 1037|    102|#define translateChar		Rf_translateChar
  ------------------
  118|    102|	u_sepw = sepw = (int) strlen(csep); // will be short
  119|    102|	sepASCII = IS_ASCII(sep);
  120|    102|	sepKnown = ENC_KNOWN(sep) > 0;
  121|    102|	sepUTF8 = IS_UTF8(sep);
  122|    102|	sepBytes = IS_BYTES(sep);
  123|    102|	collapse = CADDR(args);
  124|    102|	if(correct_nargs)
  ------------------
  |  Branch (124:5): [True: 102, False: 0]
  ------------------
  125|    102|	    recycle_0 = asBool2(CADDDR(args), call);
  ------------------
  |  | 1860|    102|# define asBool2	       	Rf_asBool2
  ------------------
  126|    867|    } else { /* paste0(..., .) */
  127|    867|	u_sepw = sepw = 0; sep = R_NilValue;/* -Wall */
  128|    867|	collapse = CADR(args);
  129|    867|	if(correct_nargs)
  ------------------
  |  Branch (129:5): [True: 867, False: 0]
  ------------------
  130|    867|	    recycle_0 = asBool2(CADDR(args), call);
  ------------------
  |  | 1860|    867|# define asBool2	       	Rf_asBool2
  ------------------
  131|    867|    }
  132|    969|    bool do_collapse = (collapse != R_NilValue); // == !isNull(collapse)
  133|    969|    if (do_collapse)
  ------------------
  |  Branch (133:9): [True: 18, False: 951]
  ------------------
  134|     18|	if(!isString(collapse) || LENGTH(collapse) <= 0 ||
  ------------------
  |  |  966|     18|#define isString		Rf_isString
  ------------------
  |  Branch (134:5): [True: 0, False: 18]
  |  Branch (134:28): [True: 0, False: 18]
  ------------------
  135|     18|	   STRING_ELT(collapse, 0) == NA_STRING)
  ------------------
  |  |  433|     18|#define NA_STRING	R_NaString
  ------------------
  |  Branch (135:5): [True: 0, False: 18]
  ------------------
  136|      0|	    error(_("invalid '%s' argument"), "collapse");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' argument"), "collapse");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  137|       |
  138|    969|#define zero_return  \
  139|    969|    return (do_collapse ? mkString("") : allocVector(STRSXP, 0))
  140|       |
  141|    969|    if(nx == 0)
  ------------------
  |  Branch (141:8): [True: 0, False: 969]
  ------------------
  142|      0|	zero_return;
  ------------------
  |  |  139|      0|    return (do_collapse ? mkString("") : allocVector(STRSXP, 0))
  |  |  ------------------
  |  |  |  | 1003|      0|#define mkString		Rf_mkString
  |  |  ------------------
  |  |                   return (do_collapse ? mkString("") : allocVector(STRSXP, 0))
  |  |  ------------------
  |  |  |  |  875|      0|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  |                   return (do_collapse ? mkString("") : allocVector(STRSXP, 0))
  |  |  ------------------
  |  |  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (139:13): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  143|       |
  144|       |    /* Maximum argument length, coerce if needed */
  145|       |
  146|    969|    R_xlen_t maxlen = 0;
  147|    969|    bool has_0_len = false;
  148|  3.61k|    for (R_xlen_t j = 0; j < nx; j++) {
  ------------------
  |  Branch (148:26): [True: 2.64k, False: 969]
  ------------------
  149|  2.64k|	if (!isString(VECTOR_ELT(x, j))) {
  ------------------
  |  |  966|  2.64k|#define isString		Rf_isString
  ------------------
  |  Branch (149:6): [True: 27, False: 2.61k]
  ------------------
  150|       |	    /* formerly in R code: moved to C for speed */
  151|     27|	    SEXP call, xj = VECTOR_ELT(x, j);
  152|     27|	    if(OBJECT(xj)) { /* method dispatch */
  ------------------
  |  Branch (152:9): [True: 16, False: 11]
  ------------------
  153|     16|		PROTECT(call = lang2(R_AsCharacterSymbol, xj));
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
  154|     16|		SET_VECTOR_ELT(x, j, eval(call, env));
  ------------------
  |  |  913|     16|#define eval			Rf_eval
  ------------------
  155|     16|		UNPROTECT(1);
  ------------------
  |  |  358|     16|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  156|     16|	    } else if (isSymbol(xj))
  ------------------
  |  |  953|     11|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (156:17): [True: 0, False: 11]
  ------------------
  157|      0|		SET_VECTOR_ELT(x, j, ScalarString(PRINTNAME(xj)));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
  158|     11|	    else
  159|     11|		SET_VECTOR_ELT(x, j, coerceVector(xj, STRSXP));
  ------------------
  |  |  895|     11|#define coerceVector		Rf_coerceVector
  ------------------
              		SET_VECTOR_ELT(x, j, coerceVector(xj, STRSXP));
  ------------------
  |  |  126|     11|#define STRSXP	    16	  /* string vectors */
  ------------------
  160|       |
  161|     27|	    if (!isString(VECTOR_ELT(x, j)))
  ------------------
  |  |  966|     27|#define isString		Rf_isString
  ------------------
  |  Branch (161:10): [True: 0, False: 27]
  ------------------
  162|      0|		error(_("non-string argument to .Internal(%s)"), PRIMNAME(op));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("non-string argument to .Internal(%s)"), PRIMNAME(op));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		error(_("non-string argument to .Internal(%s)"), PRIMNAME(op));
  ------------------
  |  | 1346|      0|#define PRIMNAME(x)	(R_FunTab[PRIMOFFSET(x)].name)
  ------------------
  163|     27|	}
  164|  2.64k|	if(recycle_0 && !has_0_len && XLENGTH(VECTOR_ELT(x, j)) == 0) {
  ------------------
  |  Branch (164:5): [True: 6, False: 2.64k]
  |  Branch (164:18): [True: 6, False: 0]
  |  Branch (164:32): [True: 0, False: 6]
  ------------------
  165|      0|	    has_0_len = true;
  166|      0|	    break;
  167|      0|	}
  168|  2.64k|	else if(maxlen < XLENGTH(VECTOR_ELT(x, j)))
  ------------------
  |  Branch (168:10): [True: 969, False: 1.67k]
  ------------------
  169|    969|	        maxlen = XLENGTH(VECTOR_ELT(x, j));
  170|  2.64k|    }
  171|    969|    if(recycle_0 && has_0_len) // one of the args was character(0)
  ------------------
  |  Branch (171:8): [True: 2, False: 967]
  |  Branch (171:21): [True: 0, False: 2]
  ------------------
  172|      0|	zero_return;
  ------------------
  |  |  139|      0|    return (do_collapse ? mkString("") : allocVector(STRSXP, 0))
  |  |  ------------------
  |  |  |  | 1003|      0|#define mkString		Rf_mkString
  |  |  ------------------
  |  |                   return (do_collapse ? mkString("") : allocVector(STRSXP, 0))
  |  |  ------------------
  |  |  |  |  875|      0|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  |                   return (do_collapse ? mkString("") : allocVector(STRSXP, 0))
  |  |  ------------------
  |  |  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (139:13): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  173|    969|    if(maxlen == 0) // all of the arguments where (equivalent to)  character(0)
  ------------------
  |  Branch (173:8): [True: 0, False: 969]
  ------------------
  174|      0|	zero_return;
  ------------------
  |  |  139|      0|    return (do_collapse ? mkString("") : allocVector(STRSXP, 0))
  |  |  ------------------
  |  |  |  | 1003|      0|#define mkString		Rf_mkString
  |  |  ------------------
  |  |                   return (do_collapse ? mkString("") : allocVector(STRSXP, 0))
  |  |  ------------------
  |  |  |  |  875|      0|#define allocVector		Rf_allocVector
  |  |  ------------------
  |  |                   return (do_collapse ? mkString("") : allocVector(STRSXP, 0))
  |  |  ------------------
  |  |  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (139:13): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  175|       |
  176|    969|    SEXP ans = PROTECT( allocVector(STRSXP, maxlen));
  ------------------
  |  |  357|    969|#define PROTECT(s)	Rf_protect(s)
  ------------------
  177|       |
  178|    969|    bool allKnown, anyKnown, use_UTF8, use_Bytes;
  179|       |
  180|  4.05k|    for (R_xlen_t i = 0; i < maxlen; i++) {
  ------------------
  |  Branch (180:26): [True: 3.08k, False: 969]
  ------------------
  181|       |	/* Strategy for marking the encoding: if all inputs (including
  182|       |	 * the separator) are ASCII, so is the output and we don't
  183|       |	 * need to mark.  Otherwise if all non-ASCII inputs are of
  184|       |	 * declared encoding, we should mark.
  185|       |	 * Need to be careful only to include separator if it is used.
  186|       |	 */
  187|  3.08k|	anyKnown = false; allKnown = true; use_UTF8 = false; use_Bytes = false;
  188|  3.08k|	if(nx > 1) {
  ------------------
  |  Branch (188:5): [True: 3.05k, False: 36]
  ------------------
  189|  3.05k|	    allKnown = sepKnown || sepASCII;
  ------------------
  |  Branch (189:17): [True: 0, False: 3.05k]
  |  Branch (189:29): [True: 3.05k, False: 0]
  ------------------
  190|  3.05k|	    anyKnown = sepKnown;
  191|  3.05k|	    use_UTF8 = sepUTF8;
  192|  3.05k|	    use_Bytes = sepBytes;
  193|  3.05k|	}
  194|       |
  195|  10.7k|	for (R_xlen_t j = 0; j < nx; j++) {
  ------------------
  |  Branch (195:23): [True: 7.66k, False: 3.08k]
  ------------------
  196|  7.66k|	    R_xlen_t k = XLENGTH(VECTOR_ELT(x, j));
  197|  7.66k|	    if (k > 0) {
  ------------------
  |  Branch (197:10): [True: 7.66k, False: 0]
  ------------------
  198|  7.66k|		SEXP cs = STRING_ELT(VECTOR_ELT(x, j), i % k);
  199|  7.66k|		if(IS_UTF8(cs)) use_UTF8 = true;
  ------------------
  |  Branch (199:6): [True: 0, False: 7.66k]
  ------------------
  200|  7.66k|		if(IS_BYTES(cs)) use_Bytes = true;
  ------------------
  |  Branch (200:6): [True: 0, False: 7.66k]
  ------------------
  201|  7.66k|	    }
  202|  7.66k|	}
  203|  3.08k|	if (use_Bytes) use_UTF8 = false;
  ------------------
  |  Branch (203:6): [True: 0, False: 3.08k]
  ------------------
  204|  3.08k|	R_xlen_t pwidth = 0;
  205|  3.08k|	const void *vmax = vmaxget();
  206|  10.7k|	for (R_xlen_t j = 0; j < nx; j++) {
  ------------------
  |  Branch (206:23): [True: 7.66k, False: 3.08k]
  ------------------
  207|  7.66k|	    R_xlen_t k = XLENGTH(VECTOR_ELT(x, j));
  208|  7.66k|	    if (k > 0) {
  ------------------
  |  Branch (208:10): [True: 7.66k, False: 0]
  ------------------
  209|  7.66k|		if(use_Bytes)
  ------------------
  |  Branch (209:6): [True: 0, False: 7.66k]
  ------------------
  210|      0|		    pwidth += strlen(CHAR             (STRING_ELT(VECTOR_ELT(x, j), i % k)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  211|  7.66k|		else if(use_UTF8)
  ------------------
  |  Branch (211:11): [True: 0, False: 7.66k]
  ------------------
  212|      0|		    pwidth += strlen(translateCharUTF8(STRING_ELT(VECTOR_ELT(x, j), i % k)));
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  213|  7.66k|		else
  214|  7.66k|		    pwidth += strlen(translateChar    (STRING_ELT(VECTOR_ELT(x, j), i % k)));
  ------------------
  |  | 1037|  7.66k|#define translateChar		Rf_translateChar
  ------------------
  215|  7.66k|		vmaxset(vmax);
  216|  7.66k|	    }
  217|  7.66k|	}
  218|  3.08k|	const char *u_csep = NULL;
  219|  3.08k|	if(use_sep) {
  ------------------
  |  Branch (219:5): [True: 1.42k, False: 1.66k]
  ------------------
  220|  1.42k|	    if (use_UTF8 && !u_csep) {
  ------------------
  |  Branch (220:10): [True: 0, False: 1.42k]
  |  Branch (220:22): [True: 0, False: 0]
  ------------------
  221|      0|		u_csep = translateCharUTF8(sep);
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  222|      0|		u_sepw = (int) strlen(u_csep); // will be short
  223|      0|	    }
  224|  1.42k|	    pwidth += (nx - 1) * (use_UTF8 ? u_sepw : sepw);
  ------------------
  |  Branch (224:28): [True: 0, False: 1.42k]
  ------------------
  225|  1.42k|	}
  226|  3.08k|	if (pwidth > INT_MAX)
  ------------------
  |  Branch (226:6): [True: 0, False: 3.08k]
  ------------------
  227|      0|	    error(_("result would exceed 2^31-1 bytes"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("result would exceed 2^31-1 bytes"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  228|  3.08k|	char *buf = R_AllocStringBuffer(pwidth, &cbuff);
  229|  3.08k|	const char *cbuf = buf;
  230|  3.08k|	vmax = vmaxget();
  231|  10.7k|	for (R_xlen_t j = 0; j < nx; j++) {
  ------------------
  |  Branch (231:23): [True: 7.66k, False: 3.08k]
  ------------------
  232|  7.66k|	    R_xlen_t k = XLENGTH(VECTOR_ELT(x, j));
  233|  7.66k|	    if (k > 0) {
  ------------------
  |  Branch (233:10): [True: 7.66k, False: 0]
  ------------------
  234|  7.66k|		SEXP cs = STRING_ELT(VECTOR_ELT(x, j), i % k);
  235|  7.66k|		if (use_UTF8) {
  ------------------
  |  Branch (235:7): [True: 0, False: 7.66k]
  ------------------
  236|      0|		    const char *s = translateCharUTF8(cs);
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  237|      0|		    buf = R_stpcpy(buf, s);
  ------------------
  |  |   48|      0|# define R_stpcpy stpcpy
  ------------------
  238|  7.66k|		} else {
  239|  7.66k|		    const char *s = use_Bytes ? CHAR(cs) : translateChar(cs);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
              		    const char *s = use_Bytes ? CHAR(cs) : translateChar(cs);
  ------------------
  |  | 1037|  7.66k|#define translateChar		Rf_translateChar
  ------------------
  |  Branch (239:23): [True: 0, False: 7.66k]
  ------------------
  240|  7.66k|		    buf = R_stpcpy(buf, s);
  ------------------
  |  |   48|  7.66k|# define R_stpcpy stpcpy
  ------------------
  241|  7.66k|		    allKnown = allKnown && (IS_ASCII(cs) || (ENC_KNOWN(cs)> 0));
  ------------------
  |  Branch (241:18): [True: 7.66k, False: 0]
  |  Branch (241:31): [True: 7.66k, False: 0]
  |  Branch (241:47): [True: 0, False: 0]
  ------------------
  242|  7.66k|		    anyKnown = anyKnown || (ENC_KNOWN(cs)> 0);
  ------------------
  |  Branch (242:18): [True: 0, False: 7.66k]
  |  Branch (242:30): [True: 0, False: 7.66k]
  ------------------
  243|  7.66k|		}
  244|  7.66k|	    }
  245|  7.66k|	    if (sepw != 0 && j != nx - 1) {
  ------------------
  |  Branch (245:10): [True: 2.85k, False: 4.80k]
  |  Branch (245:23): [True: 1.42k, False: 1.42k]
  ------------------
  246|  1.42k|		if (use_UTF8) {
  ------------------
  |  Branch (246:7): [True: 0, False: 1.42k]
  ------------------
  247|      0|		    strcpy(buf, u_csep);
  248|      0|		    buf += u_sepw;
  249|  1.42k|		} else {
  250|  1.42k|		    strcpy(buf, csep);
  251|  1.42k|		    buf += sepw;
  252|  1.42k|		}
  253|  1.42k|	    }
  254|  7.66k|	    vmax = vmaxget();
  255|  7.66k|	}
  256|  3.08k|	int ienc = 0;
  257|  3.08k|	if(use_UTF8) ienc = CE_UTF8;
  ------------------
  |  Branch (257:5): [True: 0, False: 3.08k]
  ------------------
  258|  3.08k|	else if(use_Bytes) ienc = CE_BYTES;
  ------------------
  |  Branch (258:10): [True: 0, False: 3.08k]
  ------------------
  259|  3.08k|	else if(anyKnown && allKnown) {
  ------------------
  |  Branch (259:10): [True: 0, False: 3.08k]
  |  Branch (259:22): [True: 0, False: 0]
  ------------------
  260|      0|	    if(known_to_be_latin1) ienc = CE_LATIN1;
  ------------------
  |  Branch (260:9): [True: 0, False: 0]
  ------------------
  261|      0|	    if(known_to_be_utf8) ienc = CE_UTF8;
  ------------------
  |  Branch (261:9): [True: 0, False: 0]
  ------------------
  262|      0|	}
  263|  3.08k|	SET_STRING_ELT(ans, i, mkCharCE(cbuf, ienc));
  ------------------
  |  |  999|  3.08k|#define mkCharCE		Rf_mkCharCE
  ------------------
  264|  3.08k|    }
  265|       |
  266|       |    /* Now collapse, if required. */
  267|       |
  268|    969|    if(do_collapse && (nx = XLENGTH(ans)) > 0) {
  ------------------
  |  Branch (268:8): [True: 18, False: 951]
  |  Branch (268:23): [True: 18, False: 0]
  ------------------
  269|     18|	sep = STRING_ELT(collapse, 0);
  270|     18|	use_UTF8 = IS_UTF8(sep);
  271|     18|	use_Bytes = IS_BYTES(sep);
  272|     54|	for (R_xlen_t i = 0; i < nx; i++) {
  ------------------
  |  Branch (272:23): [True: 36, False: 18]
  ------------------
  273|     36|	    if(!use_UTF8  && IS_UTF8 (STRING_ELT(ans, i))) use_UTF8  = true;
  ------------------
  |  Branch (273:9): [True: 36, False: 0]
  |  Branch (273:23): [True: 0, False: 36]
  ------------------
  274|     36|	    if(!use_Bytes && IS_BYTES(STRING_ELT(ans, i))) use_Bytes = true;
  ------------------
  |  Branch (274:9): [True: 36, False: 0]
  |  Branch (274:23): [True: 0, False: 36]
  ------------------
  275|     36|	}
  276|     18|	if(use_Bytes) {
  ------------------
  |  Branch (276:5): [True: 0, False: 18]
  ------------------
  277|      0|	    csep = CHAR(sep);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  278|      0|	    use_UTF8 = false;
  279|     18|	} else if(use_UTF8)
  ------------------
  |  Branch (279:12): [True: 0, False: 18]
  ------------------
  280|      0|	    csep = translateCharUTF8(sep);
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  281|     18|	else
  282|     18|	    csep = translateChar(sep);
  ------------------
  |  | 1037|     18|#define translateChar		Rf_translateChar
  ------------------
  283|     18|	sepw = (int) strlen(csep);
  284|     18|	anyKnown = ENC_KNOWN(sep) > 0;
  285|     18|	allKnown = anyKnown || IS_ASCII(sep);
  ------------------
  |  Branch (285:13): [True: 0, False: 18]
  |  Branch (285:25): [True: 18, False: 0]
  ------------------
  286|     18|	R_xlen_t pwidth = 0;
  287|     18|	const void *vmax = vmaxget();
  288|     54|	for (R_xlen_t i = 0; i < nx; i++)
  ------------------
  |  Branch (288:23): [True: 36, False: 18]
  ------------------
  289|     36|	    if(use_UTF8) {
  ------------------
  |  Branch (289:9): [True: 0, False: 36]
  ------------------
  290|      0|		pwidth += strlen(translateCharUTF8(STRING_ELT(ans, i)));
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  291|      0|		vmaxset(vmax);
  292|      0|	    } else /* already translated */
  293|     36|		pwidth += strlen(CHAR(STRING_ELT(ans, i)));
  ------------------
  |  |  203|     36|#define CHAR(x) R_CHAR(x)
  ------------------
  294|     18|	pwidth += (nx - 1) * sepw;
  295|     18|	if (pwidth > INT_MAX)
  ------------------
  |  Branch (295:6): [True: 0, False: 18]
  ------------------
  296|      0|	    error(_("result would exceed 2^31-1 bytes"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("result would exceed 2^31-1 bytes"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  297|     18|	char *buf = R_AllocStringBuffer(pwidth, &cbuff);
  298|     18|	const char *cbuf = buf;
  299|     18|	vmax = vmaxget();
  300|     54|	for (R_xlen_t i = 0; i < nx; i++) {
  ------------------
  |  Branch (300:23): [True: 36, False: 18]
  ------------------
  301|     36|	    if(i > 0) {
  ------------------
  |  Branch (301:9): [True: 18, False: 18]
  ------------------
  302|     18|		strcpy(buf, csep);
  303|     18|		buf += sepw;
  304|     18|	    }
  305|     36|	    const char *s;
  306|     36|	    SEXP el = STRING_ELT(ans, i);
  307|     36|	    if(use_UTF8)
  ------------------
  |  Branch (307:9): [True: 0, False: 36]
  ------------------
  308|      0|		s = translateCharUTF8(el);
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  309|     36|	    else /* already translated */
  310|     36|		s = CHAR(el);
  ------------------
  |  |  203|     36|#define CHAR(x) R_CHAR(x)
  ------------------
  311|     36|	    buf = R_stpcpy(buf, s);
  ------------------
  |  |   48|     36|# define R_stpcpy stpcpy
  ------------------
  312|     36|	    allKnown = allKnown && (IS_ASCII(el) || (ENC_KNOWN(el) > 0));
  ------------------
  |  Branch (312:17): [True: 36, False: 0]
  |  Branch (312:30): [True: 36, False: 0]
  |  Branch (312:46): [True: 0, False: 0]
  ------------------
  313|     36|	    anyKnown = anyKnown || (ENC_KNOWN(el) > 0);
  ------------------
  |  Branch (313:17): [True: 0, False: 36]
  |  Branch (313:29): [True: 0, False: 36]
  ------------------
  314|     36|	    if(use_UTF8) vmaxset(vmax);
  ------------------
  |  Branch (314:9): [True: 0, False: 36]
  ------------------
  315|     36|	}
  316|     18|	UNPROTECT(1);
  ------------------
  |  |  358|     18|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  317|     18|	int ienc = CE_NATIVE;
  318|     18|	if(use_UTF8) ienc = CE_UTF8;
  ------------------
  |  Branch (318:5): [True: 0, False: 18]
  ------------------
  319|     18|	else if(use_Bytes) ienc = CE_BYTES;
  ------------------
  |  Branch (319:10): [True: 0, False: 18]
  ------------------
  320|     18|	else if(anyKnown && allKnown) {
  ------------------
  |  Branch (320:10): [True: 0, False: 18]
  |  Branch (320:22): [True: 0, False: 0]
  ------------------
  321|      0|	    if(known_to_be_latin1) ienc = CE_LATIN1;
  ------------------
  |  Branch (321:9): [True: 0, False: 0]
  ------------------
  322|      0|	    if(known_to_be_utf8)   ienc = CE_UTF8;
  ------------------
  |  Branch (322:9): [True: 0, False: 0]
  ------------------
  323|      0|	}
  324|     18|	PROTECT(ans = allocVector(STRSXP, 1));
  ------------------
  |  |  357|     18|#define PROTECT(s)	Rf_protect(s)
  ------------------
  325|     18|	SET_STRING_ELT(ans, 0, mkCharCE(cbuf, ienc));
  ------------------
  |  |  999|     18|#define mkCharCE		Rf_mkCharCE
  ------------------
  326|     18|    }
  327|    969|    R_FreeStringBufferL(&cbuff);
  328|    969|    UNPROTECT(1);
  ------------------
  |  |  358|    969|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  329|    969|    return ans;
  330|    969|}
do_filepath:
  340|    254|{
  341|    254|    checkArity(op, args);
  ------------------
  |  | 1788|    254|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  342|       |
  343|       |    /* Check the arguments */
  344|       |
  345|    254|    SEXP x = CAR(args);
  346|    254|    if (!isVectorList(x))
  ------------------
  |  |  977|    254|#define isVectorList		Rf_isVectorList
  ------------------
  |  Branch (346:9): [True: 0, False: 254]
  ------------------
  347|      0|	error(_("invalid first argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid first argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  348|    254|    int nx = length(x);
  ------------------
  |  |  987|    254|#define length(x)		Rf_length(x)
  ------------------
  349|    254|    if (nx == 0) return allocVector(STRSXP, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
                  if (nx == 0) return allocVector(STRSXP, 0);
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (349:9): [True: 0, False: 254]
  ------------------
  350|       |
  351|    254|    SEXP sep = CADR(args);
  352|    254|    if (!isString(sep) || LENGTH(sep) <= 0 || STRING_ELT(sep, 0) == NA_STRING)
  ------------------
  |  |  966|    254|#define isString		Rf_isString
  ------------------
                  if (!isString(sep) || LENGTH(sep) <= 0 || STRING_ELT(sep, 0) == NA_STRING)
  ------------------
  |  |  433|    254|#define NA_STRING	R_NaString
  ------------------
  |  Branch (352:9): [True: 0, False: 254]
  |  Branch (352:27): [True: 0, False: 254]
  |  Branch (352:47): [True: 0, False: 254]
  ------------------
  353|      0|	error(_("invalid separator"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid separator"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  354|    254|    sep = STRING_ELT(sep, 0);
  355|    254|    const char *csep = CHAR(sep);
  ------------------
  |  |  203|    254|#define CHAR(x) R_CHAR(x)
  ------------------
  356|    254|    int sepw = (int) strlen(csep); /* hopefully 1 */
  357|       |
  358|       |    /* Any zero-length argument gives zero-length result */
  359|    254|    int maxlen = 0, nzero = 0;
  360|    910|    for (int j = 0; j < nx; j++) {
  ------------------
  |  Branch (360:21): [True: 656, False: 254]
  ------------------
  361|    656|	if (!isString(VECTOR_ELT(x, j))) {
  ------------------
  |  |  966|    656|#define isString		Rf_isString
  ------------------
  |  Branch (361:6): [True: 0, False: 656]
  ------------------
  362|      0|	    SEXP call, xj = VECTOR_ELT(x, j);
  363|      0|	    if(OBJECT(xj)) { /* method dispatch */
  ------------------
  |  Branch (363:9): [True: 0, False: 0]
  ------------------
  364|      0|		PROTECT(call = lang2(R_AsCharacterSymbol, xj));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  365|      0|		SET_VECTOR_ELT(x, j, eval(call, env));
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
  366|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  367|      0|	    } else if (isSymbol(xj))
  ------------------
  |  |  953|      0|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (367:17): [True: 0, False: 0]
  ------------------
  368|      0|		SET_VECTOR_ELT(x, j, ScalarString(PRINTNAME(xj)));
  ------------------
  |  | 1025|      0|#define ScalarString		Rf_ScalarString
  ------------------
  369|      0|	    else
  370|      0|		SET_VECTOR_ELT(x, j, coerceVector(xj, STRSXP));
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              		SET_VECTOR_ELT(x, j, coerceVector(xj, STRSXP));
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  371|       |
  372|      0|	    if (!isString(VECTOR_ELT(x, j)))
  ------------------
  |  |  966|      0|#define isString		Rf_isString
  ------------------
  |  Branch (372:10): [True: 0, False: 0]
  ------------------
  373|      0|		error(_("non-string argument to .Internal(%s)"), PRIMNAME(op));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("non-string argument to .Internal(%s)"), PRIMNAME(op));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              		error(_("non-string argument to .Internal(%s)"), PRIMNAME(op));
  ------------------
  |  | 1346|      0|#define PRIMNAME(x)	(R_FunTab[PRIMOFFSET(x)].name)
  ------------------
  374|      0|	}
  375|    656|	int ln = LENGTH(VECTOR_ELT(x, j));
  376|    656|	if (ln == 0) {nzero++; break;}
  ------------------
  |  Branch (376:6): [True: 0, False: 656]
  ------------------
  377|    656|	if (ln > maxlen) maxlen = ln;
  ------------------
  |  Branch (377:6): [True: 254, False: 402]
  ------------------
  378|    656|    }
  379|    254|    if (nzero || maxlen == 0) return allocVector(STRSXP, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
                  if (nzero || maxlen == 0) return allocVector(STRSXP, 0);
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (379:9): [True: 0, False: 254]
  |  Branch (379:18): [True: 0, False: 254]
  ------------------
  380|       |
  381|    910|    for (int j = 0; j < nx; j++) {
  ------------------
  |  Branch (381:21): [True: 656, False: 254]
  ------------------
  382|    656|	int k = LENGTH(VECTOR_ELT(x, j));
  383|  1.31k|	for (int i = 0; i < k; i++) {
  ------------------
  |  Branch (383:18): [True: 656, False: 656]
  ------------------
  384|    656|	    SEXP cs = STRING_ELT(VECTOR_ELT(x, j), i);
  385|    656|	    if (IS_BYTES(cs))
  ------------------
  |  Branch (385:10): [True: 0, False: 656]
  ------------------
  386|      0|		error(_("strings with \"bytes\" encoding are not allowed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("strings with \"bytes\" encoding are not allowed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  387|    656|	}
  388|    656|    }
  389|    254|    SEXP ans = PROTECT(allocVector(STRSXP, maxlen));
  ------------------
  |  |  357|    254|#define PROTECT(s)	Rf_protect(s)
  ------------------
  390|       |
  391|    508|    for (int i = 0; i < maxlen; i++) {
  ------------------
  |  Branch (391:21): [True: 254, False: 254]
  ------------------
  392|    254|	bool use_UTF8;
  393|    254|	if (utf8locale)
  ------------------
  |  Branch (393:6): [True: 0, False: 254]
  ------------------
  394|      0|	    use_UTF8 = true;
  395|    254|	else {
  396|    254|	    use_UTF8 = false;
  397|    910|	    for (int j = 0; j < nx; j++) {
  ------------------
  |  Branch (397:22): [True: 656, False: 254]
  ------------------
  398|    656|		int k = LENGTH(VECTOR_ELT(x, j));
  399|    656|		SEXP cs = STRING_ELT(VECTOR_ELT(x, j), i % k);
  400|    656|		if(IS_UTF8(cs)) {use_UTF8 = true; break;}
  ------------------
  |  Branch (400:6): [True: 0, False: 656]
  ------------------
  401|    656|		if(!latin1locale && IS_LATIN1(cs)) {use_UTF8 = true; break;}
  ------------------
  |  Branch (401:6): [True: 656, False: 0]
  |  Branch (401:23): [True: 0, False: 656]
  ------------------
  402|    656|	    }
  403|    254|	}
  404|    254|	int pwidth = 0;
  405|    910|	for (int j = 0; j < nx; j++) {
  ------------------
  |  Branch (405:18): [True: 656, False: 254]
  ------------------
  406|    656|	    int k = LENGTH(VECTOR_ELT(x, j));
  407|    656|	    SEXP cs = STRING_ELT(VECTOR_ELT(x, j), i % k);
  408|    656|	    if(use_UTF8)
  ------------------
  |  Branch (408:9): [True: 0, False: 656]
  ------------------
  409|      0|		pwidth += (int) strlen(trCharUTF8(cs));
  ------------------
  |  | 2000|      0|# define trCharUTF8      	Rf_trCharUTF8
  ------------------
  410|    656|	    else
  411|    656|		pwidth += (int) strlen(translateCharFP(cs));
  ------------------
  |  | 1998|    656|# define translateCharFP	Rf_translateCharFP
  ------------------
  412|    656|	}
  413|    254|	pwidth += (nx - 1) * sepw;
  414|    254|	char *buf = R_AllocStringBuffer(pwidth, &cbuff);
  415|    254|	const char *cbuf = buf;
  416|    910|	for (int j = 0; j < nx; j++) {
  ------------------
  |  Branch (416:18): [True: 656, False: 254]
  ------------------
  417|    656|	    int k = LENGTH(VECTOR_ELT(x, j));
  418|       |	    // k == 0 already handled above
  419|    656|	    SEXP cs = STRING_ELT(VECTOR_ELT(x, j), i % k);
  420|    656|	    const char *s;
  421|    656|	    if (use_UTF8)
  ------------------
  |  Branch (421:10): [True: 0, False: 656]
  ------------------
  422|      0|		s = trCharUTF8(cs);
  ------------------
  |  | 2000|      0|# define trCharUTF8      	Rf_trCharUTF8
  ------------------
  423|    656|	    else
  424|    656|		s = translateCharFP(cs);
  ------------------
  |  | 1998|    656|# define translateCharFP	Rf_translateCharFP
  ------------------
  425|    656|	    buf = R_stpcpy(buf, s);
  ------------------
  |  |   48|    656|# define R_stpcpy stpcpy
  ------------------
  426|    656|	    if (j != nx - 1 && sepw != 0) {
  ------------------
  |  Branch (426:10): [True: 402, False: 254]
  |  Branch (426:25): [True: 402, False: 0]
  ------------------
  427|    402|		strcpy(buf, csep);
  428|    402|		buf += sepw;
  429|    402|	    }
  430|    656|	}
  431|       |#ifdef Win32
  432|       |	// Trailing seps are invalid for file paths except for / and d:/
  433|       |	if(streql(csep, "/") || streql(csep, "\\")) {
  434|       |	    if(buf > cbuf) {
  435|       |		buf--;
  436|       |		if(*buf == csep[0] && buf > cbuf &&
  437|       |		   (buf != cbuf+2 || cbuf[1] != ':')) *buf = '\0';
  438|       |	    }
  439|       |	}
  440|       |#endif
  441|    254|	SET_STRING_ELT(ans, i, mkCharCE(cbuf, use_UTF8 ? CE_UTF8 : 0));
  ------------------
  |  |  999|    254|#define mkCharCE		Rf_mkCharCE
  ------------------
  |  Branch (441:40): [True: 0, False: 254]
  ------------------
  442|    254|    }
  443|    254|    R_FreeStringBufferL(&cbuff);
  444|    254|    UNPROTECT(1);
  ------------------
  |  |  358|    254|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  445|    254|    return ans;
  446|    254|}

Init_R_Variables:
  145|      2|{
  146|      2|    Init_R_Machine(rho);
  147|      2|    Init_R_Platform(rho);
  148|      2|}
R_check_locale:
  207|      2|{
  208|      2|    known_to_be_utf8 = utf8locale = FALSE;
  209|      2|    known_to_be_latin1 = latin1locale = FALSE;
  210|      2|    mbcslocale = FALSE;
  211|      2|    strcpy(native_enc, "ASCII");
  212|      2|    strcpy(codeset, "");
  213|      2|#ifdef HAVE_LANGINFO_CODESET
  214|       |    /* not on Windows */
  215|      2|    {
  216|      2|	char  *p = nl_langinfo(CODESET);
  217|      2|	strcpy(codeset, p);  // copy just in case something else calls nl_langinfo.
  218|       |	/* more relaxed due to Darwin: CODESET is case-insensitive and
  219|       |	   latin1 is ISO8859-1 */
  220|      2|	if (R_strieql(p, "UTF-8")) known_to_be_utf8 = utf8locale = TRUE;
  ------------------
  |  Branch (220:6): [True: 0, False: 2]
  ------------------
  221|      2|	if (streql(p, "ISO-8859-1")) known_to_be_latin1 = latin1locale = TRUE;
  ------------------
  |  | 1498|      2|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  222|      2|	if (R_strieql(p, "ISO8859-1")) known_to_be_latin1 = latin1locale = TRUE;
  ------------------
  |  Branch (222:6): [True: 0, False: 2]
  ------------------
  223|       |# if __APPLE__
  224|       |	/* On Darwin 'regular' locales such as 'en_US' are UTF-8 (hence
  225|       |	   MB_CUR_MAX == 6), but CODESET is ""
  226|       |	   2021: that comment dated from 2008: MB_CUR_MAX is now 4 in
  227|       |	   a UTF-8 locale, even on 10.13.
  228|       |	*/
  229|       |	if (*p == 0 && (MB_CUR_MAX == 4 || MB_CUR_MAX == 6)) {
  230|       |	    known_to_be_utf8 = utf8locale = TRUE;
  231|       |	    strcpy(codeset, "UTF-8");
  232|       |	}
  233|       |# endif
  234|      2|	if (utf8locale)
  ------------------
  |  Branch (234:6): [True: 0, False: 2]
  ------------------
  235|      0|	    strcpy(native_enc, "UTF-8");
  236|      2|	else if (latin1locale)
  ------------------
  |  Branch (236:11): [True: 0, False: 2]
  ------------------
  237|      0|	    strcpy(native_enc, "ISO-8859-1");
  238|      2|	else {
  239|      2|	    strncpy(native_enc, p, R_CODESET_MAX);
  ------------------
  |  |  738|      2|#define R_CODESET_MAX 63
  ------------------
  240|      2|	    native_enc[R_CODESET_MAX] = 0;
  ------------------
  |  |  738|      2|#define R_CODESET_MAX 63
  ------------------
  241|      2|	}
  242|      2|    }
  243|      2|#endif
  244|      2|    mbcslocale = MB_CUR_MAX > 1;
  245|      2|    R_MB_CUR_MAX = (int)MB_CUR_MAX;
  246|       |#ifdef __sun
  247|       |    /* Solaris 10 (at least) has MB_CUR_MAX == 3 in some, but ==4
  248|       |       in other UTF-8 locales. The former does not allow working
  249|       |       with non-BMP characters using mbrtowc(). Work-around by
  250|       |       allowing to use more. */
  251|       |    if (utf8locale && R_MB_CUR_MAX < 4)
  252|       |	R_MB_CUR_MAX = 4;
  253|       |#endif
  254|       |#ifdef Win32
  255|       |    {
  256|       |	char *ctype = setlocale(LC_CTYPE, NULL), *p;
  257|       |	p = strrchr(ctype, '.');
  258|       |	localeCP = 0;
  259|       |	if (p) {
  260|       |	    if (isdigit(p[1]))
  261|       |		localeCP = atoi(p+1);
  262|       |	    else if (!strcasecmp(p+1, "UTF-8") || !strcasecmp(p+1, "UTF8"))
  263|       |		localeCP = 65001;
  264|       |	} else if (strcmp(ctype, "C"))
  265|       |	    /* setlocale() will fill in the codepage automatically for
  266|       |	       "English", but not "en-US" */
  267|       |	    localeCP = defaultLocaleACP(ctype);
  268|       |
  269|       |	/* Not 100% correct, but CP1252 is a superset */
  270|       |	known_to_be_latin1 = latin1locale = (localeCP == 1252);
  271|       |	known_to_be_utf8 = utf8locale = (localeCP == 65001);
  272|       |	if (localeCP == 65001)
  273|       |	    strcpy(native_enc, "UTF-8");
  274|       |	else if (localeCP) {
  275|       |	    /* CP1252 when latin1locale is true */
  276|       |	    snprintf(native_enc, R_CODESET_MAX, "CP%d", localeCP);
  277|       |	    native_enc[R_CODESET_MAX] = 0;
  278|       |	}
  279|       |	systemCP = GetACP();
  280|       |    }
  281|       |#endif
  282|      2|}
do_fileinfo:
  814|      2|{
  815|      2|    SEXP fn, ans, ansnames, fsize, mtime, ctime, atime, isdir,
  816|      2|	mode, xxclass, uname = R_NilValue;
  817|      2|    const void *vmax = vmaxget();
  818|      2|#ifdef UNIX_EXTRAS
  819|      2|    SEXP uid = R_NilValue, gid = R_NilValue,
  820|      2|	grname = R_NilValue; // silence -Wall
  821|      2|#endif
  822|       |#ifdef Win32
  823|       |    SEXP exe = R_NilValue, udomain = R_NilValue;
  824|       |    char *ubuf = NULL;
  825|       |    DWORD ubuflen = 0;
  826|       |    char *dbuf = NULL;
  827|       |    DWORD dbuflen = 0;
  828|       |    struct _stati64 sb;
  829|       |#else
  830|      2|    struct stat sb;
  831|      2|#endif
  832|       |
  833|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  834|      2|    fn = CAR(args);
  835|      2|    if (!isString(fn))
  ------------------
  |  |  966|      2|#define isString		Rf_isString
  ------------------
  |  Branch (835:9): [True: 0, False: 2]
  ------------------
  836|      0|	error(_("invalid filename argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid filename argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  837|      2|    int extras = asInteger(CADR(args));
  ------------------
  |  |  885|      2|#define asInteger		Rf_asInteger
  ------------------
  838|      2|    if(extras == NA_INTEGER)
  ------------------
  |  |   56|      2|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (838:8): [True: 0, False: 2]
  ------------------
  839|      0|	error(_("invalid '%s' argument"), "extra_cols");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "extra_cols");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  840|      2|    int n = LENGTH(fn), ncols = 6;
  841|      2|    if(extras) {
  ------------------
  |  Branch (841:8): [True: 0, False: 2]
  ------------------
  842|      0|#ifdef UNIX_EXTRAS
  843|      0|	ncols = 10;
  ------------------
  |  | 1005|      0|#define ncols			Rf_ncols
  ------------------
  844|       |#elif defined(Win32)
  845|       |	ncols = 9;
  846|       |#endif
  847|      0|    }
  848|      2|    PROTECT(ans = allocVector(VECSXP, ncols));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
  849|      2|    PROTECT(ansnames = allocVector(STRSXP, ncols));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
  850|      2|    fsize = SET_VECTOR_ELT(ans, 0, allocVector(REALSXP, n));
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
                  fsize = SET_VECTOR_ELT(ans, 0, allocVector(REALSXP, n));
  ------------------
  |  |  124|      2|#define REALSXP	    14	  /* real variables */
  ------------------
  851|      2|    SET_STRING_ELT(ansnames, 0, mkChar("size"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  852|      2|    isdir = SET_VECTOR_ELT(ans, 1, allocVector(LGLSXP, n));
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
                  isdir = SET_VECTOR_ELT(ans, 1, allocVector(LGLSXP, n));
  ------------------
  |  |  121|      2|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  853|      2|    SET_STRING_ELT(ansnames, 1, mkChar("isdir"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  854|      2|    mode  = SET_VECTOR_ELT(ans, 2, allocVector(INTSXP, n));
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
                  mode  = SET_VECTOR_ELT(ans, 2, allocVector(INTSXP, n));
  ------------------
  |  |  123|      2|#define INTSXP	    13	  /* integer vectors */
  ------------------
  855|      2|    SET_STRING_ELT(ansnames, 2, mkChar("mode"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  856|      2|    mtime = SET_VECTOR_ELT(ans, 3, allocVector(REALSXP, n));
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
                  mtime = SET_VECTOR_ELT(ans, 3, allocVector(REALSXP, n));
  ------------------
  |  |  124|      2|#define REALSXP	    14	  /* real variables */
  ------------------
  857|      2|    SET_STRING_ELT(ansnames, 3, mkChar("mtime"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  858|      2|    ctime = SET_VECTOR_ELT(ans, 4, allocVector(REALSXP, n));
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
                  ctime = SET_VECTOR_ELT(ans, 4, allocVector(REALSXP, n));
  ------------------
  |  |  124|      2|#define REALSXP	    14	  /* real variables */
  ------------------
  859|      2|    SET_STRING_ELT(ansnames, 4, mkChar("ctime"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  860|      2|    atime = SET_VECTOR_ELT(ans, 5, allocVector(REALSXP, n));
  ------------------
  |  |  875|      2|#define allocVector		Rf_allocVector
  ------------------
                  atime = SET_VECTOR_ELT(ans, 5, allocVector(REALSXP, n));
  ------------------
  |  |  124|      2|#define REALSXP	    14	  /* real variables */
  ------------------
  861|      2|    SET_STRING_ELT(ansnames, 5, mkChar("atime"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  862|      2|    if (extras) {
  ------------------
  |  Branch (862:9): [True: 0, False: 2]
  ------------------
  863|      0|#ifdef UNIX_EXTRAS
  864|      0|	uid = SET_VECTOR_ELT(ans, 6, allocVector(INTSXP, n));
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	uid = SET_VECTOR_ELT(ans, 6, allocVector(INTSXP, n));
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  865|      0|	SET_STRING_ELT(ansnames, 6, mkChar("uid"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  866|      0|	gid = SET_VECTOR_ELT(ans, 7, allocVector(INTSXP, n));
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	gid = SET_VECTOR_ELT(ans, 7, allocVector(INTSXP, n));
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  867|      0|	SET_STRING_ELT(ansnames, 7, mkChar("gid"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  868|      0|	uname = SET_VECTOR_ELT(ans, 8, allocVector(STRSXP, n));
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	uname = SET_VECTOR_ELT(ans, 8, allocVector(STRSXP, n));
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  869|      0|	SET_STRING_ELT(ansnames, 8, mkChar("uname"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  870|      0|	grname = SET_VECTOR_ELT(ans, 9, allocVector(STRSXP, n));
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	grname = SET_VECTOR_ELT(ans, 9, allocVector(STRSXP, n));
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  871|      0|	SET_STRING_ELT(ansnames, 9, mkChar("grname"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  872|      0|#endif
  873|       |#ifdef Win32
  874|       |	exe = SET_VECTOR_ELT(ans, 6, allocVector(STRSXP, n));
  875|       |	SET_STRING_ELT(ansnames, 6, mkChar("exe"));
  876|       |	uname = SET_VECTOR_ELT(ans, 7, allocVector(STRSXP, n));
  877|       |	SET_STRING_ELT(ansnames, 7, mkChar("uname"));
  878|       |	udomain = SET_VECTOR_ELT(ans, 8, allocVector(STRSXP, n));
  879|       |	SET_STRING_ELT(ansnames, 8, mkChar("udomain"));
  880|       |#endif
  881|      0|    }
  882|      4|    for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (882:21): [True: 2, False: 2]
  ------------------
  883|       |#ifdef Win32
  884|       |	wchar_t *wfn = filenameToWchar(STRING_ELT(fn, i), TRUE);
  885|       |	/* trailing \ is not valid on Windows except for the
  886|       |	   root directory on a drive, specified as "\", or "D:\",
  887|       |	   or "\\?\D:\", etc.  We remove it in other cases,
  888|       |	   to help those who think they're on Unix. */
  889|       |	size_t len = wcslen(wfn);
  890|       |	if (len) {
  891|       |	    wchar_t *p = wfn + (len - 1);
  892|       |	    if (len > 1 && (*p == L'/' || *p == L'\\') &&
  893|       |		*(p-1) != L':') *p = 0;
  894|       |	}
  895|       |#else
  896|      2|	const char *p = translateCharFP2(STRING_ELT(fn, i));
  ------------------
  |  | 1999|      2|# define translateCharFP2	Rf_translateCharFP2
  ------------------
  897|      2|	const char *efn = p ? R_ExpandFileName(p) : p;
  ------------------
  |  Branch (897:20): [True: 2, False: 0]
  ------------------
  898|      2|#endif
  899|      2|	if (STRING_ELT(fn, i) != NA_STRING &&
  ------------------
  |  |  433|      4|#define NA_STRING	R_NaString
  ------------------
  |  Branch (899:6): [True: 2, False: 0]
  ------------------
  900|       |#ifdef Win32
  901|       |	    _wstati64(wfn, &sb)
  902|       |#else
  903|       |	    /* Target not link */
  904|      2|	    p && stat(efn, &sb)
  ------------------
  |  Branch (904:6): [True: 2, False: 0]
  |  Branch (904:11): [True: 0, False: 2]
  ------------------
  905|      2|#endif
  906|      2|	    == 0) {
  907|      0|	    REAL(fsize)[i] = (double) sb.st_size;
  908|      0|	    LOGICAL(isdir)[i] = (sb.st_mode & S_IFDIR) > 0;
  909|      0|	    INTEGER(mode)[i]  = (int) sb.st_mode & 0007777;
  910|       |
  911|      0|#if defined STAT_TIMESPEC
  912|       |	    /* POSIX 2008 changed this to a struct timespec st_mtim etc
  913|       |	       Not all OSes (e.g. Darwin) agree on this. */
  914|      0|	    REAL(mtime)[i] = (double) STAT_TIMESPEC(sb, st_mtim).tv_sec
  ------------------
  |  |  801|      0|#  define STAT_TIMESPEC(st, st_xtim) ((st).st_xtim)
  ------------------
  915|      0|		+ 1e-9 * (double) STAT_TIMESPEC(sb, st_mtim).tv_nsec;
  ------------------
  |  |  801|      0|#  define STAT_TIMESPEC(st, st_xtim) ((st).st_xtim)
  ------------------
  916|      0|	    REAL(ctime)[i] = (double) STAT_TIMESPEC(sb, st_ctim).tv_sec
  ------------------
  |  |  801|      0|#  define STAT_TIMESPEC(st, st_xtim) ((st).st_xtim)
  ------------------
  917|      0|		+ 1e-9 * (double) STAT_TIMESPEC(sb, st_ctim).tv_nsec;
  ------------------
  |  |  801|      0|#  define STAT_TIMESPEC(st, st_xtim) ((st).st_xtim)
  ------------------
  918|      0|	    REAL(atime)[i] = (double) STAT_TIMESPEC(sb, st_atim).tv_sec
  ------------------
  |  |  801|      0|#  define STAT_TIMESPEC(st, st_xtim) ((st).st_xtim)
  ------------------
  919|      0|		+ 1e-9 * (double) STAT_TIMESPEC(sb, st_atim).tv_nsec;
  ------------------
  |  |  801|      0|#  define STAT_TIMESPEC(st, st_xtim) ((st).st_xtim)
  ------------------
  920|       |#else
  921|       |#ifdef Win32
  922|       |#define WINDOWS_TICK 10000000
  923|       |#define SEC_TO_UNIX_EPOCH 11644473600LL
  924|       |	    {
  925|       |		FILETIME c_ft, a_ft, m_ft;
  926|       |		HANDLE h;
  927|       |		int success = 0;
  928|       |		h = CreateFileW(wfn, 0,
  929|       |		                FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
  930|       |		                NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
  931|       |		if (h != INVALID_HANDLE_VALUE) {
  932|       |		    int res  = GetFileTime(h, &c_ft, &a_ft, &m_ft);
  933|       |		    CloseHandle(h);
  934|       |		    if (res) {
  935|       |			ULARGE_INTEGER time;
  936|       |			time.LowPart = m_ft.dwLowDateTime;
  937|       |			time.HighPart = m_ft.dwHighDateTime;
  938|       |			REAL(mtime)[i] = (((double) time.QuadPart) / WINDOWS_TICK - SEC_TO_UNIX_EPOCH);
  939|       |			time.LowPart = c_ft.dwLowDateTime;
  940|       |			time.HighPart = c_ft.dwHighDateTime;
  941|       |			REAL(ctime)[i] = (((double) time.QuadPart) / WINDOWS_TICK - SEC_TO_UNIX_EPOCH);
  942|       |			time.LowPart = a_ft.dwLowDateTime;
  943|       |			time.HighPart = a_ft.dwHighDateTime;
  944|       |			REAL(atime)[i] = (((double) time.QuadPart) / WINDOWS_TICK - SEC_TO_UNIX_EPOCH);
  945|       |			success = 1;
  946|       |		    }
  947|       |		} else
  948|       |		    warning(_("cannot open file '%ls': %s"),
  949|       |		            wfn, formatError(GetLastError()));
  950|       |		if (!success) {
  951|       |		    REAL(mtime)[i] = NA_REAL;
  952|       |		    REAL(ctime)[i] = NA_REAL;
  953|       |		    REAL(atime)[i] = NA_REAL;
  954|       |	        }
  955|       |	    }
  956|       |#else
  957|       |	    REAL(mtime)[i] = (double) sb.st_mtime;
  958|       |	    REAL(ctime)[i] = (double) sb.st_ctime;
  959|       |	    REAL(atime)[i] = (double) sb.st_atime;
  960|       |# ifdef STAT_TIMESPEC_NS
  961|       |	    REAL(mtime)[i] += STAT_TIMESPEC_NS (sb, st_mtim);
  962|       |	    REAL(ctime)[i] += STAT_TIMESPEC_NS (sb, st_ctim);
  963|       |	    REAL(atime)[i] += STAT_TIMESPEC_NS (sb, st_atim);
  964|       |# endif
  965|       |#endif
  966|       |#endif
  967|      0|	    if (extras) {
  ------------------
  |  Branch (967:10): [True: 0, False: 0]
  ------------------
  968|      0|#ifdef UNIX_EXTRAS
  969|      0|		INTEGER(uid)[i] = (int) sb.st_uid;
  970|      0|		INTEGER(gid)[i] = (int) sb.st_gid;
  971|       |
  972|       |		/* Usually all of the uid and gid values in a list of
  973|       |		 * files are the same so we can avoid most of the calls
  974|       |		 * to getpwuid() and getgrgid(), which can be quite slow
  975|       |		 * on some systems.  (PR#15804)
  976|       |		 */
  977|      0|		if (i && INTEGER(uid)[i - 1] == (int) sb.st_uid)
  ------------------
  |  Branch (977:7): [True: 0, False: 0]
  |  Branch (977:12): [True: 0, False: 0]
  ------------------
  978|      0|		    SET_STRING_ELT(uname, i, STRING_ELT(uname, i - 1));
  979|      0|		else {
  980|      0|		    struct passwd *stpwd = getpwuid(sb.st_uid);
  981|      0|		    SET_STRING_ELT(uname, i,
  982|      0|				   stpwd ? mkChar(stpwd->pw_name): NA_STRING);
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
              				   stpwd ? mkChar(stpwd->pw_name): NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (982:8): [True: 0, False: 0]
  ------------------
  983|      0|		}
  984|       |
  985|      0|		if (i && INTEGER(gid)[i - 1] == (int) sb.st_gid)
  ------------------
  |  Branch (985:7): [True: 0, False: 0]
  |  Branch (985:12): [True: 0, False: 0]
  ------------------
  986|      0|		    SET_STRING_ELT(grname, i, STRING_ELT(grname, i - 1));
  987|      0|		else {
  988|      0|		    struct group *stgrp = getgrgid(sb.st_gid);
  989|      0|		    SET_STRING_ELT(grname, i,
  990|      0|				   stgrp ? mkChar(stgrp->gr_name): NA_STRING);
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
              				   stgrp ? mkChar(stgrp->gr_name): NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (990:8): [True: 0, False: 0]
  ------------------
  991|      0|		}
  992|      0|#endif
  993|       |#ifdef Win32
  994|       |		{
  995|       |		    char *s="no";
  996|       |		    DWORD type;
  997|       |		    if (GetBinaryTypeW(wfn, &type))
  998|       |			switch(type) {
  999|       |			case SCS_64BIT_BINARY:
 1000|       |			    s = "win64";
 1001|       |			    break;
 1002|       |			case SCS_32BIT_BINARY:
 1003|       |			    s = "win32";
 1004|       |			    break;
 1005|       |			case SCS_DOS_BINARY:
 1006|       |			case SCS_PIF_BINARY:
 1007|       |			    s = "msdos";
 1008|       |			    break;
 1009|       |			case SCS_WOW_BINARY:
 1010|       |			    s = "win16";
 1011|       |			    break;
 1012|       |			default:
 1013|       |			    s = "unknown";
 1014|       |			}
 1015|       |		    SET_STRING_ELT(exe, i, mkChar(s));
 1016|       |		}
 1017|       |		{
 1018|       |		    HANDLE h;
 1019|       |		    PSID owner_sid;
 1020|       |		    SID_NAME_USE suse = SidTypeUnknown;
 1021|       |		    PSECURITY_DESCRIPTOR sd = NULL;
 1022|       |		    DWORD saveerr = ERROR_SUCCESS;
 1023|       |		    int ok = 0;
 1024|       |		    /* NOTE: GENERIC_READ would be asking too much
 1025|       |		       (e.g. junctions under Users/Default in Windows 10) */
 1026|       |		    h = CreateFileW(wfn, READ_CONTROL,
 1027|       |				    FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
 1028|       |				    NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
 1029|       |		    ok = (h != INVALID_HANDLE_VALUE);
 1030|       |
 1031|       |		    ok = ok && (GetSecurityInfo(h, SE_FILE_OBJECT,
 1032|       |					        OWNER_SECURITY_INFORMATION,
 1033|       |					        &owner_sid,
 1034|       |					        NULL, NULL, NULL, &sd)
 1035|       |		                == ERROR_SUCCESS);
 1036|       |		    if (ok) {
 1037|       |			DWORD ulen = ubuflen;
 1038|       |			DWORD dlen = dbuflen;
 1039|       |			ok = LookupAccountSid(NULL, owner_sid, ubuf, &ulen,
 1040|       |			                      dbuf, &dlen, &suse);
 1041|       |			if (!ok
 1042|       |			    && GetLastError() == ERROR_INSUFFICIENT_BUFFER
 1043|       |			    && (ulen > ubuflen || dlen > dbuflen)) {
 1044|       |
 1045|       |			    if (ulen > ubuflen) {
 1046|       |				ubuf = R_alloc(ulen, 1);
 1047|       |				ubuflen = ulen;
 1048|       |			    }
 1049|       |			    if (dlen > dbuflen) {
 1050|       |				dbuf = R_alloc(dlen, 1);
 1051|       |				dbuflen = dlen;
 1052|       |			    }
 1053|       |			    ok = LookupAccountSid(NULL, owner_sid, ubuf, &ulen,
 1054|       |			                          dbuf, &dlen, &suse);
 1055|       |			}
 1056|       |		    }
 1057|       |		    if (!ok)
 1058|       |			saveerr = GetLastError();
 1059|       |		    if (sd)
 1060|       |			LocalFree(sd);
 1061|       |		    if (h != INVALID_HANDLE_VALUE)
 1062|       |			CloseHandle(h);
 1063|       |		    if (ok) {
 1064|       |			SET_STRING_ELT(uname, i, mkChar(ubuf));
 1065|       |			SET_STRING_ELT(udomain, i, mkChar(dbuf));
 1066|       |		    } else {
 1067|       |			warning(_("cannot resolve owner of file '%ls': %s"),
 1068|       |				wfn, formatError(saveerr));
 1069|       |			SET_STRING_ELT(uname, i, NA_STRING);
 1070|       |			SET_STRING_ELT(udomain, i, NA_STRING);
 1071|       |		    }
 1072|       |		}
 1073|       |#endif
 1074|      0|	    }
 1075|      2|	} else {
 1076|      2|	    REAL(fsize)[i] = NA_REAL;
  ------------------
  |  |   58|      2|#define NA_REAL		R_NaReal
  ------------------
 1077|      2|	    LOGICAL(isdir)[i] = NA_INTEGER;
  ------------------
  |  |   56|      2|#define NA_INTEGER	R_NaInt
  ------------------
 1078|      2|	    INTEGER(mode)[i]  = NA_INTEGER;
  ------------------
  |  |   56|      2|#define NA_INTEGER	R_NaInt
  ------------------
 1079|      2|	    REAL(mtime)[i] = NA_REAL;
  ------------------
  |  |   58|      2|#define NA_REAL		R_NaReal
  ------------------
 1080|      2|	    REAL(ctime)[i] = NA_REAL;
  ------------------
  |  |   58|      2|#define NA_REAL		R_NaReal
  ------------------
 1081|      2|	    REAL(atime)[i] = NA_REAL;
  ------------------
  |  |   58|      2|#define NA_REAL		R_NaReal
  ------------------
 1082|      2|	    if (extras) {
  ------------------
  |  Branch (1082:10): [True: 0, False: 2]
  ------------------
 1083|      0|#ifdef UNIX_EXTRAS
 1084|      0|		INTEGER(uid)[i] = NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
 1085|      0|		INTEGER(gid)[i] = NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
 1086|      0|		SET_STRING_ELT(uname, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
 1087|      0|		SET_STRING_ELT(grname, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
 1088|      0|#endif
 1089|       |#ifdef Win32
 1090|       |		SET_STRING_ELT(exe, i, NA_STRING);
 1091|       |#endif
 1092|      0|	    }
 1093|      2|	}
 1094|      2|    }
 1095|      2|    setAttrib(ans, R_NamesSymbol, ansnames);
  ------------------
  |  | 1027|      2|#define setAttrib		Rf_setAttrib
  ------------------
 1096|      2|    PROTECT(xxclass = mkString("octmode"));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1097|      2|    classgets(mode, xxclass);
  ------------------
  |  |  894|      2|#define classgets		Rf_classgets
  ------------------
 1098|      2|    vmaxset(vmax);
 1099|      2|    UNPROTECT(3);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1100|      2|    return ans;
 1101|      2|}
do_direxists:
 1104|     30|{
 1105|     30|    SEXP fn, ans;
 1106|       |
 1107|       |#ifdef Win32
 1108|       |    struct _stati64 sb;
 1109|       |#else
 1110|     30|    struct stat sb;
 1111|     30|#endif
 1112|       |
 1113|     30|    checkArity(op, args);
  ------------------
  |  | 1788|     30|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1114|     30|    fn = CAR(args);
 1115|     30|    if (!isString(fn))
  ------------------
  |  |  966|     30|#define isString		Rf_isString
  ------------------
  |  Branch (1115:9): [True: 0, False: 30]
  ------------------
 1116|      0|	error(_("invalid filename argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid filename argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1117|     30|    int n = LENGTH(fn);
 1118|     30|    PROTECT(ans = allocVector(LGLSXP, n));
  ------------------
  |  |  357|     30|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1119|     60|    for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (1119:21): [True: 30, False: 30]
  ------------------
 1120|       |#ifdef Win32
 1121|       |	wchar_t *wfn = filenameToWchar(STRING_ELT(fn, i), TRUE);
 1122|       |	/* trailing \ is not valid on Windows except for the
 1123|       |	   root directory on a drive, specified as "\", or "D:\",
 1124|       |	   or "\\?\D:\", etc.  We remove it in other cases,
 1125|       |	   to help those who think they're on Unix. */
 1126|       |	size_t len = wcslen(wfn);
 1127|       |	if (len) {
 1128|       |	    wchar_t *p = wfn + (len - 1);
 1129|       |	    if (len > 1 && (*p == L'/' || *p == L'\\') &&
 1130|       |		*(p-1) != L':') *p = 0;
 1131|       |	}
 1132|       |	if (STRING_ELT(fn, i) != NA_STRING && _wstati64(wfn, &sb) == 0) {
 1133|       |	    LOGICAL(ans)[i] = (sb.st_mode & S_IFDIR) > 0;
 1134|       |
 1135|       |	} else LOGICAL(ans)[i] = 0;
 1136|       |#else
 1137|     30|	const char *p = translateCharFP2(STRING_ELT(fn, i));
  ------------------
  |  | 1999|     30|# define translateCharFP2	Rf_translateCharFP2
  ------------------
 1138|     30|	if (p && STRING_ELT(fn, i) != NA_STRING &&
  ------------------
  |  |  433|     60|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1138:6): [True: 30, False: 0]
  |  Branch (1138:11): [True: 30, False: 0]
  ------------------
 1139|       |	    /* Target not link */
 1140|     30|	    stat(R_ExpandFileName(p), &sb) == 0) {
  ------------------
  |  Branch (1140:6): [True: 28, False: 2]
  ------------------
 1141|     28|	    LOGICAL(ans)[i] = (sb.st_mode & S_IFDIR) > 0;
 1142|     28|	} else LOGICAL(ans)[i] = 0;
 1143|     30|#endif
 1144|     30|    }
 1145|       |    // copy names?
 1146|     30|    UNPROTECT(1);
  ------------------
  |  |  358|     30|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1147|     30|    return ans;
 1148|     30|}
do_Rhome:
 1738|     12|{
 1739|     12|    char *path;
 1740|     12|    checkArity(op, args);
  ------------------
  |  | 1788|     12|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1741|     12|    if (!(path = R_HomeDir()))
  ------------------
  |  Branch (1741:9): [True: 0, False: 12]
  ------------------
 1742|      0|	error(_("unable to determine R home location"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("unable to determine R home location"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1743|     12|    return mkString(path);
  ------------------
  |  | 1003|     12|#define mkString		Rf_mkString
  ------------------
 1744|     12|}
do_fileexists:
 1755|    156|{
 1756|    156|    SEXP file, ans;
 1757|    156|    int i, nfile, ic = 16;
 1758|    156|    checkArity(op, args);
  ------------------
  |  | 1788|    156|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1759|    156|    if (!isString(file = CAR(args)))
  ------------------
  |  |  966|    156|#define isString		Rf_isString
  ------------------
  |  Branch (1759:9): [True: 0, False: 156]
  ------------------
 1760|      0|	error(_("invalid '%s' argument"), "file");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "file");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1761|    156|    nfile = LENGTH(file);
 1762|    156|    ans = PROTECT(allocVector(LGLSXP, nfile));
  ------------------
  |  |  357|    156|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1763|    312|    for (i = 0; i < nfile; i++) {
  ------------------
  |  Branch (1763:17): [True: 156, False: 156]
  ------------------
 1764|    156|	if (!(--ic)) {
  ------------------
  |  Branch (1764:6): [True: 0, False: 156]
  ------------------
 1765|      0|	    R_CheckUserInterrupt();
 1766|      0|	    ic = 16;
 1767|      0|	}
 1768|    156|	LOGICAL(ans)[i] = 0;
 1769|    156|	if (STRING_ELT(file, i) != NA_STRING) {
  ------------------
  |  |  433|    156|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1769:6): [True: 156, False: 0]
  ------------------
 1770|       |	    /* documented to silently report false for paths that would be too
 1771|       |	       long after expansion */
 1772|       |#ifdef Win32
 1773|       |	    /* Package XML sends arbitrarily long strings to file.exists! */
 1774|       |	    size_t len = strlen(CHAR(STRING_ELT(file, i)));
 1775|       |	    /* 32767 bytes will still fit to the wide char buffer used
 1776|       |	       by filenameToWchar */
 1777|       |	    if (len > 32767)
 1778|       |		LOGICAL(ans)[i] = FALSE;
 1779|       |	    else
 1780|       |		LOGICAL(ans)[i] =
 1781|       |		    R_WFileExists(filenameToWchar(STRING_ELT(file, i), TRUE));
 1782|       |#else
 1783|       |	    // returns NULL if not translatable
 1784|    156|	    const char *p = translateCharFP2(STRING_ELT(file, i));
  ------------------
  |  | 1999|    156|# define translateCharFP2	Rf_translateCharFP2
  ------------------
 1785|       |	    /* Package XML sends arbitrarily long strings to file.exists! */
 1786|    156|	    if (!p || strlen(p) > R_PATH_MAX)
  ------------------
  |  | 1150|    156|# define R_PATH_MAX PATH_MAX
  ------------------
  |  Branch (1786:10): [True: 0, False: 156]
  |  Branch (1786:16): [True: 0, False: 156]
  ------------------
 1787|      0|		LOGICAL(ans)[i] = FALSE;
 1788|    156|	    else
 1789|    156|		LOGICAL(ans)[i] = R_FileExists(p);
 1790|    156|#endif
 1791|    156|	} else LOGICAL(ans)[i] = FALSE;
 1792|    156|    }
 1793|    156|    UNPROTECT(1); /* ans */
  ------------------
  |  |  358|    156|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1794|    156|    return ans;
 1795|    156|}
do_getlocale:
 2192|      1|{
 2193|      1|    int cat;
 2194|      1|    char *p = NULL;
 2195|       |
 2196|      1|    checkArity(op, args);
  ------------------
  |  | 1788|      1|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2197|      1|    cat = asInteger(CAR(args));
  ------------------
  |  |  885|      1|#define asInteger		Rf_asInteger
  ------------------
 2198|      1|    if (cat == NA_INTEGER || cat < 0)
  ------------------
  |  |   56|      2|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (2198:9): [True: 0, False: 1]
  |  Branch (2198:30): [True: 0, False: 1]
  ------------------
 2199|      0|	error(_("invalid '%s' argument"), "category");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "category");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2200|      1|    switch(cat) {
 2201|      0|    case 1: cat = LC_ALL; break;
  ------------------
  |  Branch (2201:5): [True: 0, False: 1]
  ------------------
 2202|      0|    case 2: cat = LC_COLLATE; break;
  ------------------
  |  Branch (2202:5): [True: 0, False: 1]
  ------------------
 2203|      0|    case 3: cat = LC_CTYPE; break;
  ------------------
  |  Branch (2203:5): [True: 0, False: 1]
  ------------------
 2204|      0|    case 4: cat = LC_MONETARY; break;
  ------------------
  |  Branch (2204:5): [True: 0, False: 1]
  ------------------
 2205|      0|    case 5: cat = LC_NUMERIC; break;
  ------------------
  |  Branch (2205:5): [True: 0, False: 1]
  ------------------
 2206|      0|    case 6: cat = LC_TIME; break;
  ------------------
  |  Branch (2206:5): [True: 0, False: 1]
  ------------------
 2207|      0|#ifndef Win32
 2208|      0|# ifdef LC_MESSAGES
 2209|      0|    case 7: cat = LC_MESSAGES; break;
  ------------------
  |  Branch (2209:5): [True: 0, False: 1]
  ------------------
 2210|      0|# endif
 2211|      0|# ifdef LC_PAPER
 2212|      1|    case 8: cat = LC_PAPER; break;
  ------------------
  |  Branch (2212:5): [True: 1, False: 0]
  ------------------
 2213|      0|# endif
 2214|      0|# ifdef LC_MEASUREMENT
 2215|      0|    case 9: cat = LC_MEASUREMENT; break;
  ------------------
  |  Branch (2215:5): [True: 0, False: 1]
  ------------------
 2216|      0|# endif
 2217|      0|#endif
 2218|      0|    default: cat = NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (2218:5): [True: 0, False: 1]
  ------------------
 2219|      1|    }
 2220|      1|    if (cat != NA_INTEGER) p = setlocale(cat, NULL);
  ------------------
  |  |   56|      1|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (2220:9): [True: 1, False: 0]
  ------------------
 2221|      1|    return mkString(p ? p : "");
  ------------------
  |  | 1003|      1|#define mkString		Rf_mkString
  ------------------
  |  Branch (2221:21): [True: 1, False: 0]
  ------------------
 2222|      1|}
do_pathexpand:
 2413|     46|{
 2414|     46|    SEXP fn, ans;
 2415|     46|    int i, n;
 2416|       |
 2417|     46|    checkArity(op, args);
  ------------------
  |  | 1788|     46|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2418|     46|    fn = CAR(args);
 2419|     46|    if (!isString(fn))
  ------------------
  |  |  966|     46|#define isString		Rf_isString
  ------------------
  |  Branch (2419:9): [True: 0, False: 46]
  ------------------
 2420|      0|	error(_("invalid '%s' argument"), "path");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "path");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2421|     46|    n = LENGTH(fn);
 2422|     46|    PROTECT(ans = allocVector(STRSXP, n));
  ------------------
  |  |  357|     46|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2423|     92|    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (2423:17): [True: 46, False: 46]
  ------------------
 2424|     46|	SEXP tmp = STRING_ELT(fn, i);
 2425|     46|	if (tmp != NA_STRING) {
  ------------------
  |  |  433|     46|#define NA_STRING	R_NaString
  ------------------
  |  Branch (2425:6): [True: 46, False: 0]
  ------------------
 2426|       |#ifdef Win32
 2427|       |	    /* Windows can have files and home directories that aren't
 2428|       |	       representable in the native encoding (e.g. latin1). Translate
 2429|       |	       to UTF-8 when the input is in UTF-8 already or is in latin1,
 2430|       |	       but the native encoding is not latin1.
 2431|       |
 2432|       |	       R (including R_ExpandFileNameUTF8) for now only supports R home
 2433|       |	       directories representable in native encoding.
 2434|       |	    */
 2435|       |	    if (IS_UTF8(tmp) || (IS_LATIN1(tmp) && !latin1locale))
 2436|       |		tmp = mkCharCE(R_ExpandFileNameUTF8(trCharUTF8(tmp)), CE_UTF8);
 2437|       |	    else
 2438|       |#endif
 2439|     46|	    {
 2440|     46|		const char *p = translateCharFP2(tmp);
  ------------------
  |  | 1999|     46|# define translateCharFP2	Rf_translateCharFP2
  ------------------
 2441|     46|		if (p)
  ------------------
  |  Branch (2441:7): [True: 46, False: 0]
  ------------------
 2442|     46|		    tmp = markKnown(R_ExpandFileName(p), tmp);
  ------------------
  |  | 1942|     46|# define markKnown		Rf_markKnown
  ------------------
 2443|     46|	    }
 2444|     46|	}
 2445|     46|	SET_STRING_ELT(ans, i, tmp);
 2446|     46|    }
 2447|     46|    UNPROTECT(1);
  ------------------
  |  |  358|     46|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2448|     46|    return ans;
 2449|     46|}
do_capabilities:
 2487|      2|{
 2488|      2|    SEXP ans, ansnames;
 2489|      2|    int i = 0;
 2490|      2|#ifdef Unix
 2491|       |# ifdef HAVE_X11
 2492|       |    int X11 = NA_LOGICAL;
 2493|       |# else
 2494|      2|    int X11 = FALSE;
 2495|      2|# endif
 2496|      2|#endif
 2497|       |
 2498|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2499|       |
 2500|      2|    PROTECT(ans      = allocVector(LGLSXP, 20));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2501|      2|    PROTECT(ansnames = allocVector(STRSXP, 20));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2502|       |
 2503|      2|    SET_STRING_ELT(ansnames, i, mkChar("jpeg"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2504|       |#ifdef HAVE_JPEG
 2505|       |# if defined Unix && !defined HAVE_WORKING_CAIRO
 2506|       |    LOGICAL(ans)[i++] = X11;
 2507|       |# else
 2508|       |    LOGICAL(ans)[i++] = TRUE;
 2509|       |# endif
 2510|       |#else
 2511|      2|    LOGICAL(ans)[i++] = FALSE;
 2512|      2|#endif
 2513|       |
 2514|      2|    SET_STRING_ELT(ansnames, i, mkChar("png"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2515|       |#ifdef HAVE_PNG
 2516|       |# if defined Unix && !defined HAVE_WORKING_CAIRO
 2517|       |    LOGICAL(ans)[i++] = X11;
 2518|       |# else /* Windows */
 2519|       |    LOGICAL(ans)[i++] = TRUE;
 2520|       |# endif
 2521|       |#else
 2522|      2|    LOGICAL(ans)[i++] = FALSE;
 2523|      2|#endif
 2524|       |
 2525|      2|    SET_STRING_ELT(ansnames, i, mkChar("tiff"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2526|       |#ifdef HAVE_TIFF
 2527|       |# if defined Unix && !defined HAVE_WORKING_CAIRO
 2528|       |    LOGICAL(ans)[i++] = X11;
 2529|       |# else /* Windows */
 2530|       |    LOGICAL(ans)[i++] = TRUE;
 2531|       |# endif
 2532|       |#else
 2533|      2|    LOGICAL(ans)[i++] = FALSE;
 2534|      2|#endif
 2535|       |
 2536|      2|    SET_STRING_ELT(ansnames, i, mkChar("tcltk"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2537|       |#ifdef HAVE_TCLTK
 2538|       |    LOGICAL(ans)[i++] = TRUE;
 2539|       |#else
 2540|      2|    LOGICAL(ans)[i++] = FALSE;
 2541|      2|#endif
 2542|       |
 2543|      2|    SET_STRING_ELT(ansnames, i, mkChar("X11"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2544|       |#ifdef HAVE_X11
 2545|       |# if defined(Unix)
 2546|       |    LOGICAL(ans)[i++] = X11;
 2547|       |# else
 2548|       |    LOGICAL(ans)[i++] = TRUE;
 2549|       |# endif
 2550|       |#else
 2551|      2|    LOGICAL(ans)[i++] = FALSE;
 2552|      2|#endif
 2553|       |
 2554|      2|    SET_STRING_ELT(ansnames, i, mkChar("aqua"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2555|       |#ifdef HAVE_AQUA
 2556|       |    LOGICAL(ans)[i++] = TRUE;
 2557|       |#else
 2558|      2|    LOGICAL(ans)[i++] = FALSE;
 2559|      2|#endif
 2560|       |
 2561|      2|    SET_STRING_ELT(ansnames, i, mkChar("http/ftp"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2562|      2|    LOGICAL(ans)[i++] = TRUE;
 2563|       |
 2564|      2|    SET_STRING_ELT(ansnames, i, mkChar("sockets"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2565|      2|    LOGICAL(ans)[i++] = TRUE;
 2566|       |
 2567|      2|    SET_STRING_ELT(ansnames, i, mkChar("libxml"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2568|      2|    LOGICAL(ans)[i++] = FALSE;
 2569|       |
 2570|      2|    SET_STRING_ELT(ansnames, i, mkChar("fifo"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2571|      2|#if (defined(HAVE_MKFIFO) && defined(HAVE_FCNTL_H)) || defined(_WIN32)
 2572|      2|    LOGICAL(ans)[i++] = TRUE;
 2573|       |#else
 2574|       |    LOGICAL(ans)[i++] = FALSE;
 2575|       |#endif
 2576|       |
 2577|       |    /* This one is complex.  Set it to be true only in interactive use,
 2578|       |       with the Windows and GNOME GUIs (but not Tk GUI) or under Unix
 2579|       |       if readline is available and in use. */
 2580|      2|    SET_STRING_ELT(ansnames, i, mkChar("cledit"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2581|      2|    LOGICAL(ans)[i] = FALSE;
 2582|       |#if defined(Win32)
 2583|       |    if (R_Interactive) LOGICAL(ans)[i] = TRUE;
 2584|       |#endif
 2585|      2|#ifdef Unix
 2586|      2|    if (strcmp(R_GUIType, "GNOME") == 0) {  /* always interactive */
  ------------------
  |  Branch (2586:9): [True: 0, False: 2]
  ------------------
 2587|      0|	LOGICAL(ans)[i] = TRUE;  /* also AQUA ? */
 2588|      2|    } else {
 2589|      2|#if defined(HAVE_LIBREADLINE)
 2590|      2|	extern Rboolean UsingReadline; // from ../unix/system.c
 2591|      2|	if (R_Interactive && UsingReadline) LOGICAL(ans)[i] = TRUE;
  ------------------
  |  Branch (2591:6): [True: 2, False: 0]
  |  Branch (2591:23): [True: 2, False: 0]
  ------------------
 2592|      2|#endif
 2593|      2|    }
 2594|      2|#endif
 2595|      2|    i++;
 2596|       |
 2597|       |/* always true as from R 2.10.0 */
 2598|      2|    SET_STRING_ELT(ansnames, i, mkChar("iconv"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2599|      2|    LOGICAL(ans)[i++] = TRUE;
 2600|       |
 2601|      2|    SET_STRING_ELT(ansnames, i, mkChar("NLS"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2602|      2|#ifdef ENABLE_NLS
 2603|      2|    LOGICAL(ans)[i++] = TRUE;
 2604|       |#else
 2605|       |    LOGICAL(ans)[i++] = FALSE;
 2606|       |#endif
 2607|       |
 2608|      2|    SET_STRING_ELT(ansnames, i, mkChar("Rprof"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2609|      2|#ifdef R_PROFILING
 2610|      2|    LOGICAL(ans)[i++] = TRUE;
 2611|       |#else
 2612|       |    LOGICAL(ans)[i++] = FALSE;
 2613|       |#endif
 2614|       |
 2615|      2|    SET_STRING_ELT(ansnames, i, mkChar("profmem"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2616|       |#ifdef R_MEMORY_PROFILING
 2617|       |    LOGICAL(ans)[i++] = TRUE;
 2618|       |#else
 2619|      2|    LOGICAL(ans)[i++] = FALSE;
 2620|      2|#endif
 2621|       |
 2622|      2|    SET_STRING_ELT(ansnames, i, mkChar("cairo"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2623|       |#ifdef HAVE_WORKING_CAIRO
 2624|       |    LOGICAL(ans)[i++] = TRUE;
 2625|       |#elif defined(Win32)
 2626|       |{
 2627|       |    /* This is true iff winCairo.dll is available */
 2628|       |    struct stat sb;
 2629|       |    char path[1000]; // R_HomeDir() should be at most 260 chars
 2630|       |# ifdef R_ARCH
 2631|       |    snprintf(path, 1000, "%s/library/grDevices/libs/%s/winCairo.dll",
 2632|       |	     R_HomeDir(), R_ARCH);
 2633|       |# else
 2634|       |    snprintf(path, 1000, "%s/library/grDevices/libs/winCairo.dll",
 2635|       |	     R_HomeDir());
 2636|       |# endif
 2637|       |    LOGICAL(ans)[i++] = stat(path, &sb) == 0;
 2638|       |}
 2639|       |#else
 2640|      2|    LOGICAL(ans)[i++] = FALSE;
 2641|      2|#endif
 2642|       |
 2643|      2|    SET_STRING_ELT(ansnames, i, mkChar("ICU"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2644|       |#ifdef USE_ICU
 2645|       |    LOGICAL(ans)[i++] = TRUE;
 2646|       |#else
 2647|      2|    LOGICAL(ans)[i++] = FALSE;
 2648|      2|#endif
 2649|       |
 2650|      2|    SET_STRING_ELT(ansnames, i, mkChar("long.double"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2651|      2|    LOGICAL(ans)[i++] = sizeof(LDOUBLE) > sizeof(double);
 2652|       |
 2653|      2|    SET_STRING_ELT(ansnames, i, mkChar("libcurl"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2654|      2|#ifdef HAVE_LIBCURL
 2655|      2|    LOGICAL(ans)[i++] = TRUE;
 2656|       |#else
 2657|       |    LOGICAL(ans)[i++] = FALSE;
 2658|       |#endif
 2659|       |
 2660|      2|    SET_STRING_ELT(ansnames, i, mkChar("zstd"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
 2661|      2|#ifdef HAVE_ZSTD
 2662|      2|    LOGICAL(ans)[i++] = TRUE;
 2663|       |#else
 2664|       |    LOGICAL(ans)[i++] = FALSE;
 2665|       |#endif
 2666|       |
 2667|      2|    setAttrib(ans, R_NamesSymbol, ansnames);
  ------------------
  |  | 1027|      2|#define setAttrib		Rf_setAttrib
  ------------------
 2668|      2|    UNPROTECT(2);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2669|      2|    return ans;
 2670|      2|}
platform.c:Init_R_Platform:
   90|      2|{
   91|      2|    SEXP value, names;
   92|      2|    char *pkgType;
   93|       |
   94|      2|    PROTECT(value = allocVector(VECSXP, 8));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
   95|      2|    PROTECT(names = allocVector(STRSXP, 8));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
   96|      2|    SET_STRING_ELT(names, 0, mkChar("OS.type"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   97|      2|    SET_STRING_ELT(names, 1, mkChar("file.sep"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   98|      2|    SET_STRING_ELT(names, 2, mkChar("dynlib.ext"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   99|      2|    SET_STRING_ELT(names, 3, mkChar("GUI"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  100|      2|    SET_STRING_ELT(names, 4, mkChar("endian"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  101|      2|    SET_STRING_ELT(names, 5, mkChar("pkgType"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  102|      2|    SET_STRING_ELT(names, 6, mkChar("path.sep"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  103|      2|    SET_STRING_ELT(names, 7, mkChar("r_arch"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  104|      2|    SET_VECTOR_ELT(value, 0, mkString(R_OSType));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
  105|      2|    SET_VECTOR_ELT(value, 1, mkString(R_FileSep));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
  106|      2|    SET_VECTOR_ELT(value, 2, mkString(SHLIB_EXT));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
                  SET_VECTOR_ELT(value, 2, mkString(SHLIB_EXT));
  ------------------
  |  | 1116|      2|#define SHLIB_EXT ".so"
  ------------------
  107|      2|    SET_VECTOR_ELT(value, 3, mkString(R_GUIType));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
  108|       |#ifdef WORDS_BIGENDIAN
  109|       |    SET_VECTOR_ELT(value, 4, mkString("big"));
  110|       |#else
  111|      2|    SET_VECTOR_ELT(value, 4, mkString("little"));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
  112|      2|#endif
  113|       |/* pkgType should be "mac.binary" for CRAN build *only*, not for all
  114|       |   AQUA builds. Also we want to be able to use "mac.binary.mavericks",
  115|       |   "mac.binary.el-capitan" and similar. */
  116|       |/* since R 4.6.0 we extend the support to other platforms, so we allow
  117|       |   R_PLATFORM_PKGTYPE env var to override this such that other builds can
  118|       |   set this in their Renviron */
  119|      2|    if ((pkgType = getenv("R_PLATFORM_PKGTYPE")) && *pkgType)
  ------------------
  |  Branch (119:9): [True: 0, False: 2]
  |  Branch (119:53): [True: 0, False: 0]
  ------------------
  120|      0|	SET_VECTOR_ELT(value, 5, mkString(pkgType));
  ------------------
  |  | 1003|      0|#define mkString		Rf_mkString
  ------------------
  121|      2|    else
  122|       |#ifdef PLATFORM_PKGTYPE
  123|       |    SET_VECTOR_ELT(value, 5, mkString(PLATFORM_PKGTYPE));
  124|       |#else /* unix default */
  125|      2|    SET_VECTOR_ELT(value, 5, mkString("source"));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
  126|      2|#endif
  127|       |#ifdef Win32
  128|       |    SET_VECTOR_ELT(value, 6, mkString(";"));
  129|       |#else /* not Win32 */
  130|      2|    SET_VECTOR_ELT(value, 6, mkString(":"));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
  131|      2|#endif
  132|      2|#ifdef R_ARCH
  133|      2|    SET_VECTOR_ELT(value, 7, mkString(R_ARCH));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
                  SET_VECTOR_ELT(value, 7, mkString(R_ARCH));
  ------------------
  |  | 1085|      2|#define R_ARCH ""
  ------------------
  134|       |#else
  135|       |    SET_VECTOR_ELT(value, 7, mkString(""));
  136|       |#endif
  137|      2|    setAttrib(value, R_NamesSymbol, names);
  ------------------
  |  | 1027|      2|#define setAttrib		Rf_setAttrib
  ------------------
  138|      2|    defineVar(install(".Platform"), value, rho);
  ------------------
  |  |  905|      2|#define defineVar		Rf_defineVar
  ------------------
                  defineVar(install(".Platform"), value, rho);
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  139|      2|    UNPROTECT(2);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  140|      2|}
platform.c:R_strieql:
  153|      4|{
  154|      4|    while (*a && *b && toupper(*a) == toupper(*b)) { a++; b++; }
  ------------------
  |  Branch (154:12): [True: 4, False: 0]
  |  Branch (154:18): [True: 4, False: 0]
  |  Branch (154:24): [True: 0, False: 0]
  |  Branch (154:24): [True: 0, False: 0]
  |  Branch (154:24): [Folded, False: 4]
  |  Branch (154:24): [True: 0, False: 4]
  |  Branch (154:39): [True: 0, False: 0]
  |  Branch (154:39): [True: 0, False: 0]
  |  Branch (154:39): [Folded, False: 4]
  ------------------
  155|      4|    return (*a == 0 && *b == 0);
  ------------------
  |  Branch (155:13): [True: 0, False: 4]
  |  Branch (155:24): [True: 0, False: 0]
  ------------------
  156|      4|}

Rf_PrintInit:
   88|  2.95k|{
   89|  2.95k|    data->na_string = NA_STRING;
  ------------------
  |  |  433|  2.95k|#define NA_STRING	R_NaString
  ------------------
   90|  2.95k|    data->na_string_noquote = mkChar("<NA>");
  ------------------
  |  |  998|  2.95k|#define mkChar			Rf_mkChar
  ------------------
   91|  2.95k|    data->na_width = Rstrlen(data->na_string, 0);
   92|  2.95k|    data->na_width_noquote = Rstrlen(data->na_string_noquote, 0);
   93|  2.95k|    data->quote = 1;
   94|  2.95k|    data->right = Rprt_adj_left;
   95|  2.95k|    data->digits = GetOptionDigits();
  ------------------
  |  |  929|  2.95k|#define GetOptionDigits		Rf_GetOptionDigits
  ------------------
   96|  2.95k|    data->scipen = asInteger(GetOption1(install("scipen")));
  ------------------
  |  |  885|  2.95k|#define asInteger		Rf_asInteger
  ------------------
                  data->scipen = asInteger(GetOption1(install("scipen")));
  ------------------
  |  |  928|  2.95k|#define GetOption1		Rf_GetOption1
  ------------------
                  data->scipen = asInteger(GetOption1(install("scipen")));
  ------------------
  |  |  934|  2.95k|#define install			Rf_install
  ------------------
   97|  2.95k|    if (data->scipen == NA_INTEGER) data->scipen = 0;
  ------------------
  |  |   56|  2.95k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (97:9): [True: 32, False: 2.92k]
  ------------------
   98|  2.95k|    data->max = asInteger(GetOption1(install("max.print")));
  ------------------
  |  |  885|  2.95k|#define asInteger		Rf_asInteger
  ------------------
                  data->max = asInteger(GetOption1(install("max.print")));
  ------------------
  |  |  928|  2.95k|#define GetOption1		Rf_GetOption1
  ------------------
                  data->max = asInteger(GetOption1(install("max.print")));
  ------------------
  |  |  934|  2.95k|#define install			Rf_install
  ------------------
   99|  2.95k|    if (data->max == NA_INTEGER || data->max < 0) data->max = 99999;
  ------------------
  |  |   56|  5.91k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (99:9): [True: 32, False: 2.92k]
  |  Branch (99:36): [True: 0, False: 2.92k]
  ------------------
  100|  2.92k|    else if(data->max == INT_MAX) data->max--; // so we can add
  ------------------
  |  Branch (100:13): [True: 0, False: 2.92k]
  ------------------
  101|  2.95k|    data->gap = 1;
  102|  2.95k|    data->width = GetOptionWidth();
  ------------------
  |  |  930|  2.95k|#define GetOptionWidth		Rf_GetOptionWidth
  ------------------
  103|  2.95k|    data->useSource = USESOURCE;
  ------------------
  |  | 2071|  2.95k|#define USESOURCE 		8
  ------------------
  104|  2.95k|    data->cutoff = GetOptionCutoff();
  ------------------
  |  | 1907|  2.95k|# define GetOptionCutoff       	Rf_GetOptionCutoff
  ------------------
  105|  2.95k|    data->env = env;
  106|  2.95k|    data->callArgs = R_NilValue;
  107|  2.95k|}
Rf_PrintDefaults:
  113|  2.95k|{
  114|  2.95k|    PrintInit(&R_print, R_GlobalEnv);
  ------------------
  |  | 1969|  2.95k|# define PrintInit              Rf_PrintInit
  ------------------
  115|  2.95k|}
do_invisible:
  118|  1.02k|{
  119|  1.02k|    switch (length(args)) {
  ------------------
  |  |  987|  1.02k|#define length(x)		Rf_length(x)
  ------------------
  120|    964|    case 0:
  ------------------
  |  Branch (120:5): [True: 964, False: 64]
  ------------------
  121|    964|	return R_NilValue;
  122|     64|    case 1:
  ------------------
  |  Branch (122:5): [True: 64, False: 964]
  ------------------
  123|     64|	check1arg(args, call, "x");
  ------------------
  |  | 1867|     64|# define check1arg		Rf_check1arg
  ------------------
  124|     64|	return CAR(args);
  125|      0|    default:
  ------------------
  |  Branch (125:5): [True: 0, False: 1.02k]
  ------------------
  126|      0|	checkArity(op, args); /* must fail */
  ------------------
  |  | 1788|      0|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  127|      0|	return call;/* never used, just for -Wall */
  128|  1.02k|    }
  129|  1.02k|}

R_Decode2Long:
   92|      2|{
   93|      2|    R_size_t v = strtol(p, &p, 10);
   94|      2|    *ierr = 0;
   95|      2|    if(p[0] == '\0') return v;
  ------------------
  |  Branch (95:8): [True: 0, False: 2]
  ------------------
   96|       |    /* else look for letter-code ending : */
   97|      2|    if(R_Verbose)
  ------------------
  |  Branch (97:8): [True: 0, False: 2]
  ------------------
   98|      0|	REprintf("R_Decode2Long(): v=%ld\n", (long)v);
   99|       |    // NOTE: currently, positive *ierr are not differentiated in the callers:
  100|      2|    if(p[0] == 'G') {
  ------------------
  |  Branch (100:8): [True: 2, False: 0]
  ------------------
  101|      2|	if((Giga * (double)v) > (double) R_SIZE_T_MAX) { *ierr = 4; return(v); }
  ------------------
  |  | 1051|      2|#define Giga 1073741824. /* Misnomer !! 1 GiB (gibibyte) := 2^30 = (2^10)^3 Bytes */
  ------------------
              	if((Giga * (double)v) > (double) R_SIZE_T_MAX) { *ierr = 4; return(v); }
  ------------------
  |  | 1044|      2|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  |  Branch (101:5): [True: 0, False: 2]
  ------------------
  102|      2|	return (R_size_t) Giga * v;
  ------------------
  |  | 1051|      2|#define Giga 1073741824. /* Misnomer !! 1 GiB (gibibyte) := 2^30 = (2^10)^3 Bytes */
  ------------------
  103|      2|    }
  104|      0|    else if(p[0] == 'M') {
  ------------------
  |  Branch (104:13): [True: 0, False: 0]
  ------------------
  105|      0|	if((Mega * (double)v) > (double) R_SIZE_T_MAX) { *ierr = 1; return(v); }
  ------------------
  |  | 1050|      0|#define Mega 1048576.    /* Misnomer !! 1 MiB (mebibyte) := 2^20 (= 1048576) Bytes */
  ------------------
              	if((Mega * (double)v) > (double) R_SIZE_T_MAX) { *ierr = 1; return(v); }
  ------------------
  |  | 1044|      0|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  |  Branch (105:5): [True: 0, False: 0]
  ------------------
  106|      0|	return (R_size_t) Mega * v;
  ------------------
  |  | 1050|      0|#define Mega 1048576.    /* Misnomer !! 1 MiB (mebibyte) := 2^20 (= 1048576) Bytes */
  ------------------
  107|      0|    }
  108|      0|    else if(p[0] == 'K') {
  ------------------
  |  Branch (108:13): [True: 0, False: 0]
  ------------------
  109|      0|	if((1024 * (double)v) > (double) R_SIZE_T_MAX) { *ierr = 2; return(v); }
  ------------------
  |  | 1044|      0|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  |  Branch (109:5): [True: 0, False: 0]
  ------------------
  110|      0|	return (1024*v);
  111|      0|    }
  112|      0|    else if(p[0] == 'k') {
  ------------------
  |  Branch (112:13): [True: 0, False: 0]
  ------------------
  113|      0|	if((1000 * (double)v) > (double) R_SIZE_T_MAX) { *ierr = 3; return(v); }
  ------------------
  |  | 1044|      0|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  |  Branch (113:5): [True: 0, False: 0]
  ------------------
  114|      0|	return (1000*v);
  115|      0|    }
  116|      0|    else {
  117|      0|	*ierr = -1;
  118|      0|	return(v);
  119|      0|    }
  120|      2|}
Rf_EncodeLogical:
  126|    241|{
  127|       |    /* fast path when 'w' fits exactly */
  128|    241|    if(x == NA_LOGICAL) {
  ------------------
  |  |   55|    241|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (128:8): [True: 0, False: 241]
  ------------------
  129|      0|	if(w == R_print.na_width) return CHAR(R_print.na_string);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (129:5): [True: 0, False: 0]
  ------------------
  130|    241|    } else if(x) {
  ------------------
  |  Branch (130:15): [True: 233, False: 8]
  ------------------
  131|    233|	if(w == 4) return "TRUE";
  ------------------
  |  Branch (131:5): [True: 233, False: 0]
  ------------------
  132|    233|    } else
  133|      8|	if(w == 5) return "FALSE";
  ------------------
  |  Branch (133:5): [True: 8, False: 0]
  ------------------
  134|       |    /* general case */
  135|      0|    static char buff[NB];
  136|      0|    if(x == NA_LOGICAL) snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
                  if(x == NA_LOGICAL) snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
                  if(x == NA_LOGICAL) snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  if(x == NA_LOGICAL) snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (136:8): [True: 0, False: 0]
  ------------------
  137|      0|    else if(x) snprintf(buff, NB, "%*s", min(w, (NB-1)), "TRUE");
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
                  else if(x) snprintf(buff, NB, "%*s", min(w, (NB-1)), "TRUE");
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (137:13): [True: 0, False: 0]
  ------------------
  138|      0|    else snprintf(buff, NB, "%*s", min(w, (NB-1)), "FALSE");
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
                  else snprintf(buff, NB, "%*s", min(w, (NB-1)), "FALSE");
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  139|      0|    buff[NB-1] = '\0';
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
  140|      0|    return buff;
  141|    241|}
Rf_EncodeInteger:
  144|    256|{
  145|    256|    static char buff[NB];
  146|    256|    if(x == NA_INTEGER) snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |   56|    256|#define NA_INTEGER	R_NaInt
  ------------------
                  if(x == NA_INTEGER) snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
                  if(x == NA_INTEGER) snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
                  if(x == NA_INTEGER) snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (146:8): [True: 0, False: 256]
  ------------------
  147|    256|    else snprintf(buff, NB, "%*d", min(w, (NB-1)), x);
  ------------------
  |  |  124|    256|#define NB 1000
  ------------------
                  else snprintf(buff, NB, "%*d", min(w, (NB-1)), x);
  ------------------
  |  |   85|    256|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 256, False: 0]
  |  |  ------------------
  ------------------
  148|    256|    buff[NB-1] = '\0';
  ------------------
  |  |  124|    256|#define NB 1000
  ------------------
  149|    256|    return buff;
  150|    256|}
Rf_EncodeReal0:
  203|  3.80k|{
  204|  3.80k|    static char buff[NB], buff2[2*NB];
  205|  3.80k|    char fmt[20], *out = buff;
  206|       |
  207|       |    /* IEEE allows signed zeros (yuck!) */
  208|  3.80k|    if (x == 0.0) x = 0.0;
  ------------------
  |  Branch (208:9): [True: 32, False: 3.77k]
  ------------------
  209|  3.80k|    if (!R_FINITE(x)) {
  ------------------
  |  |   82|  3.80k|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (209:9): [True: 0, False: 3.80k]
  ------------------
  210|      0|	if(ISNA(x)) snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |   64|      0|#define ISNA(x)	       R_IsNA(x)
  |  |  ------------------
  |  |  |  Branch (64:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	if(ISNA(x)) snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
              	if(ISNA(x)) snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	if(ISNA(x)) snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  211|      0|	else if(ISNAN(x)) snprintf(buff, NB, "%*s", min(w, (NB-1)), "NaN");
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	else if(ISNAN(x)) snprintf(buff, NB, "%*s", min(w, (NB-1)), "NaN");
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
              	else if(ISNAN(x)) snprintf(buff, NB, "%*s", min(w, (NB-1)), "NaN");
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  212|      0|	else if(x > 0) snprintf(buff, NB, "%*s", min(w, (NB-1)), "Inf");
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
              	else if(x > 0) snprintf(buff, NB, "%*s", min(w, (NB-1)), "Inf");
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (212:10): [True: 0, False: 0]
  ------------------
  213|      0|	else snprintf(buff, NB, "%*s", min(w, (NB-1)), "-Inf");
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
              	else snprintf(buff, NB, "%*s", min(w, (NB-1)), "-Inf");
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  214|      0|    }
  215|  3.80k|    else if (e) {
  ------------------
  |  Branch (215:14): [True: 62, False: 3.74k]
  ------------------
  216|     62|	if(d) { // '#' flag
  ------------------
  |  Branch (216:5): [True: 0, False: 62]
  ------------------
  217|      0|	    snprintf(fmt, 20, "%%#%d.%de", min(w, (NB-1)), d);
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  218|      0|	}
  219|     62|	else {
  220|     62|	    snprintf(fmt, 20, "%%%d.%de", min(w, (NB-1)), d);
  ------------------
  |  |   85|     62|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 62, False: 0]
  |  |  ------------------
  ------------------
  221|     62|	}
  222|     62|	snprintf(buff, NB, fmt, x);
  ------------------
  |  |  124|     62|#define NB 1000
  ------------------
  223|     62|    }
  224|  3.74k|    else { /* e = 0 */
  225|  3.74k|	snprintf(fmt, 20, "%%%d.%df", min(w, (NB-1)), d);
  ------------------
  |  |   85|  3.74k|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 3.74k, False: 0]
  |  |  ------------------
  ------------------
  226|  3.74k|	snprintf(buff, NB, fmt, x);
  ------------------
  |  |  124|  3.74k|#define NB 1000
  ------------------
  227|  3.74k|    }
  228|  3.80k|    buff[NB-1] = '\0';
  ------------------
  |  |  124|  3.80k|#define NB 1000
  ------------------
  229|       |
  230|  3.80k|    if(strcmp(dec, ".")) { /* replace "." by dec */
  ------------------
  |  Branch (230:8): [True: 0, False: 3.80k]
  ------------------
  231|      0|	int len = strwidth(dec); /* 3·14 must work */
  ------------------
  |  |  192|      0|#define strwidth(x) Rstrwid(x, (int) strlen(x), CE_NATIVE, 0)
  ------------------
  232|      0|	if(len != 1) warning(
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  |  Branch (232:5): [True: 0, False: 0]
  ------------------
  233|      0|	    _("the decimal mark is %s than one character wide; this will become an error"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  234|      0|	    (len > 1) ? "more" : "less");
  ------------------
  |  Branch (234:6): [True: 0, False: 0]
  ------------------
  235|       |
  236|      0|	char *p, *q;
  237|      0|	for(p = buff, q = buff2; *p; p++) {
  ------------------
  |  Branch (237:27): [True: 0, False: 0]
  ------------------
  238|      0|	    if(*p == '.') for(const char *r = dec; *r; r++) *q++ = *r;
  ------------------
  |  Branch (238:9): [True: 0, False: 0]
  |  Branch (238:45): [True: 0, False: 0]
  ------------------
  239|      0|	    else *q++ = *p;
  240|      0|	}
  241|      0|	*q = '\0';
  242|      0|	out = buff2;
  243|      0|    }
  244|       |
  245|  3.80k|    return out;
  246|  3.80k|}
Rf_StringFromReal:
  311|     11|{
  312|     11|    int w, d, e;
  313|     11|    formatReal(&x, 1, &w, &d, &e, 0);
  ------------------
  |  |   41|     11|#define formatReal         Rf_formatReal
  ------------------
  314|     11|    if (ISNA(x)) return NA_STRING;
  ------------------
  |  |   64|     11|#define ISNA(x)	       R_IsNA(x)
  |  |  ------------------
  |  |  |  Branch (64:24): [True: 0, False: 11]
  |  |  ------------------
  ------------------
                  if (ISNA(x)) return NA_STRING;
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  315|     11|    else return mkChar(EncodeRealDrop0(x, w, d, e, OutDec));
  ------------------
  |  |  998|     11|#define mkChar			Rf_mkChar
  ------------------
  316|     11|}
Rstrwid:
  410|  8.33k|{
  411|  8.33k|    const char *p = str;
  412|  8.33k|    int len = 0, i;
  413|       |
  414|  8.33k|    if(ienc == CE_BYTES) { // not currently used for that encoding
  ------------------
  |  Branch (414:8): [True: 0, False: 8.33k]
  ------------------
  415|      0|	for (i = 0; i < slen; i++) {
  ------------------
  |  Branch (415:14): [True: 0, False: 0]
  ------------------
  416|      0|	    unsigned char k = str[i];
  417|      0|	    if (k >= 0x20 && k < 0x80) len += 1;
  ------------------
  |  Branch (417:10): [True: 0, False: 0]
  |  Branch (417:23): [True: 0, False: 0]
  ------------------
  418|      0|	    else len += 4;
  419|      0|	}
  420|      0|	return len;
  421|      0|    }
  422|       |    /* Future-proof: currently that is all Rstrlen calls it with,
  423|       |       and printarray has CE_NATIVE explicitly */
  424|  8.33k|    if(ienc > 2) // CE_NATIVE, CE_UTF8, CE_BYTES are supported
  ------------------
  |  Branch (424:8): [True: 0, False: 8.33k]
  ------------------
  425|      0|	warning("unsupported encoding (%d) in Rstrwid", ienc);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  426|  8.33k|    if(mbcslocale || ienc == CE_UTF8) {
  ------------------
  |  Branch (426:8): [True: 0, False: 8.33k]
  |  Branch (426:22): [True: 0, False: 8.33k]
  ------------------
  427|      0|	bool useUTF8 = (ienc == CE_UTF8);
  428|      0|	mbstate_t mb_st;
  429|       |
  430|      0|	if(!useUTF8)  mbs_init(&mb_st);
  ------------------
  |  | 2454|      0|#define mbs_init(x) memset(x, 0, sizeof(mbstate_t))
  ------------------
  |  Branch (430:5): [True: 0, False: 0]
  ------------------
  431|      0|	for (i = 0; i < slen; i++) {
  ------------------
  |  Branch (431:14): [True: 0, False: 0]
  ------------------
  432|      0|	    unsigned int k; /* not wint_t as it might be signed */
  433|      0|	    wchar_t wc;
  434|      0|	    int res = useUTF8 ? (int) utf8toucs(&wc, p):
  ------------------
  |  | 2009|      0|# define utf8toucs		Rf_utf8toucs
  ------------------
  |  Branch (434:16): [True: 0, False: 0]
  ------------------
  435|      0|		(int) mbrtowc(&wc, p, R_MB_CUR_MAX, &mb_st);
  436|      0|	    if(res >= 0) {
  ------------------
  |  Branch (436:9): [True: 0, False: 0]
  ------------------
  437|      0|		if (useUTF8 && IS_HIGH_SURROGATE(wc))
  ------------------
  |  |  173|      0|#define IS_HIGH_SURROGATE(wch) (((wch) >= HIGH_SURROGATE_START) && ((wch) <= HIGH_SURROGATE_END))
  |  |  ------------------
  |  |  |  |  162|      0|#define HIGH_SURROGATE_START 0xd800
  |  |  ------------------
  |  |               #define IS_HIGH_SURROGATE(wch) (((wch) >= HIGH_SURROGATE_START) && ((wch) <= HIGH_SURROGATE_END))
  |  |  ------------------
  |  |  |  |  163|      0|#define HIGH_SURROGATE_END 0xdbff
  |  |  ------------------
  |  |  |  Branch (173:33): [True: 0, False: 0]
  |  |  |  Branch (173:68): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (437:7): [True: 0, False: 0]
  ------------------
  438|      0|		    k = utf8toucs32(wc, p);
  ------------------
  |  |  177|      0|# define utf8toucs32		Rf_utf8toucs32
  ------------------
  439|      0|		else
  440|      0|		    k = wc;
  441|      0|		if(0x20 <= k && k < 0x7f && iswprint(k)) {
  ------------------
  |  Branch (441:6): [True: 0, False: 0]
  |  Branch (441:19): [True: 0, False: 0]
  |  Branch (441:31): [True: 0, False: 0]
  ------------------
  442|      0|		    switch(wc) {
  443|      0|		    case L'\\':
  ------------------
  |  Branch (443:7): [True: 0, False: 0]
  ------------------
  444|      0|			len += 2;
  445|      0|			break;
  446|      0|		    case L'\'':
  ------------------
  |  Branch (446:7): [True: 0, False: 0]
  ------------------
  447|      0|		    case L'"':
  ------------------
  |  Branch (447:7): [True: 0, False: 0]
  ------------------
  448|      0|		    case L'`':
  ------------------
  |  Branch (448:7): [True: 0, False: 0]
  ------------------
  449|      0|			len += (quote == *p) ? 2 : 1;
  ------------------
  |  Branch (449:11): [True: 0, False: 0]
  ------------------
  450|      0|			break;
  451|      0|		    default:
  ------------------
  |  Branch (451:7): [True: 0, False: 0]
  ------------------
  452|      0|			len++; /* assumes these are all width 1 */
  453|      0|			break;
  454|      0|		    }
  455|      0|		    p++;
  456|      0|		} else if (k < 0x80) {
  ------------------
  |  Branch (456:14): [True: 0, False: 0]
  ------------------
  457|      0|		    switch(wc) {
  458|      0|		    case L'\a':
  ------------------
  |  Branch (458:7): [True: 0, False: 0]
  ------------------
  459|      0|		    case L'\b':
  ------------------
  |  Branch (459:7): [True: 0, False: 0]
  ------------------
  460|      0|		    case L'\f':
  ------------------
  |  Branch (460:7): [True: 0, False: 0]
  ------------------
  461|      0|		    case L'\n':
  ------------------
  |  Branch (461:7): [True: 0, False: 0]
  ------------------
  462|      0|		    case L'\r':
  ------------------
  |  Branch (462:7): [True: 0, False: 0]
  ------------------
  463|      0|		    case L'\t':
  ------------------
  |  Branch (463:7): [True: 0, False: 0]
  ------------------
  464|      0|		    case L'\v':
  ------------------
  |  Branch (464:7): [True: 0, False: 0]
  ------------------
  465|      0|		    case L'\0':
  ------------------
  |  Branch (465:7): [True: 0, False: 0]
  ------------------
  466|      0|			len += 2; break;
  467|      0|		    default:
  ------------------
  |  Branch (467:7): [True: 0, False: 0]
  ------------------
  468|       |			/* print in octal */
  469|      0|			len += 4; break;
  470|      0|		    }
  471|      0|		    p++;
  472|      0|		} else {
  473|       |		    /* no need to worry about truncation as iswprint
  474|       |		     * and wcwidth get replaced on Windows */
  475|       |		    // conceivably an invalid \U escape could use 11 or 12
  476|      0|		    len += iswprint(k) ?
  ------------------
  |  Branch (476:14): [True: 0, False: 0]
  ------------------
  477|      0|#ifdef USE_RI18N_WIDTH
  478|      0|			Ri18n_wcwidth(k) :
  479|       |#else
  480|       |			/* this is expected to return -1 for
  481|       |			   non-printable (including unassigned)
  482|       |			   characters: that is unlikely to occur,
  483|       |			   although the system's idea of 'printing'
  484|       |			   may differ from the internal tables */
  485|       |			imax2(wcwidth((wchar_t) k), 0) :
  486|       |#endif
  487|      0|		    	(k > 0xffff ? 10 : 6);
  ------------------
  |  Branch (487:9): [True: 0, False: 0]
  ------------------
  488|      0|		    i += (res - 1);
  489|      0|		    p += res;
  490|      0|		}
  491|      0|	    } else { /* invalid char */
  492|      0|		len += 4;
  493|      0|		p++;
  494|      0|	    }
  495|      0|	}
  496|      0|    } else // not MBCS nor marked as UTF-8
  497|  38.3k|	for (i = 0; i < slen; i++) {
  ------------------
  |  Branch (497:14): [True: 30.0k, False: 8.33k]
  ------------------
  498|  30.0k|	    if((unsigned char) *p < 0x80) {
  ------------------
  |  Branch (498:9): [True: 30.0k, False: 0]
  ------------------
  499|       |		/* ASCII */
  500|  30.0k|		if(isprint((int)*p)) {
  ------------------
  |  Branch (500:6): [True: 29.8k, False: 224]
  ------------------
  501|  29.8k|		    switch(*p) {
  502|      0|		    case '\\':
  ------------------
  |  Branch (502:7): [True: 0, False: 29.8k]
  ------------------
  503|      0|			len += 2; break;
  504|      0|		    case '\'':
  ------------------
  |  Branch (504:7): [True: 0, False: 29.8k]
  ------------------
  505|      0|		    case '"':
  ------------------
  |  Branch (505:7): [True: 0, False: 29.8k]
  ------------------
  506|      0|		    case '`':
  ------------------
  |  Branch (506:7): [True: 0, False: 29.8k]
  ------------------
  507|      0|			len += (quote == *p)? 2 : 1; break;
  ------------------
  |  Branch (507:11): [True: 0, False: 0]
  ------------------
  508|  29.8k|		    default:
  ------------------
  |  Branch (508:7): [True: 29.8k, False: 0]
  ------------------
  509|  29.8k|			len++; break;
  510|  29.8k|		    }
  511|  29.8k|		} else switch(*p) {
  512|      0|		    case '\a':
  ------------------
  |  Branch (512:7): [True: 0, False: 224]
  ------------------
  513|      0|		    case '\b':
  ------------------
  |  Branch (513:7): [True: 0, False: 224]
  ------------------
  514|      0|		    case '\f':
  ------------------
  |  Branch (514:7): [True: 0, False: 224]
  ------------------
  515|    224|		    case '\n':
  ------------------
  |  Branch (515:7): [True: 224, False: 0]
  ------------------
  516|    224|		    case '\r':
  ------------------
  |  Branch (516:7): [True: 0, False: 224]
  ------------------
  517|    224|		    case '\t':
  ------------------
  |  Branch (517:7): [True: 0, False: 224]
  ------------------
  518|    224|		    case '\v':
  ------------------
  |  Branch (518:7): [True: 0, False: 224]
  ------------------
  519|    224|		    case '\0':
  ------------------
  |  Branch (519:7): [True: 0, False: 224]
  ------------------
  520|    224|			len += 2; break;
  521|      0|		    default:
  ------------------
  |  Branch (521:7): [True: 0, False: 224]
  ------------------
  522|       |			/* print in octal */
  523|      0|			len += 4; break;
  524|    224|		    }
  525|  30.0k|		p++;
  526|  30.0k|	    } else { /* 8 bit char */
  527|       |#ifdef Win32 /* It seems Windows does not know what is printable! */
  528|       |		len++;
  529|       |#else
  530|      0|		len += isprint((int)*p) ? 1 : 4;
  ------------------
  |  Branch (530:10): [True: 0, False: 0]
  ------------------
  531|      0|#endif
  532|      0|		p++;
  533|      0|	    }
  534|  30.0k|	}
  535|       |
  536|  8.33k|    return len;
  537|  8.33k|}
Rstrlen:
  542|  8.33k|{
  543|  8.33k|    cetype_t ienc = getCharCE(s);
  ------------------
  |  |  925|  8.33k|#define getCharCE		Rf_getCharCE
  ------------------
  544|  8.33k|    if (ienc == CE_UTF8 || ienc == CE_BYTES)
  ------------------
  |  Branch (544:9): [True: 0, False: 8.33k]
  |  Branch (544:28): [True: 0, False: 8.33k]
  ------------------
  545|      0|	return Rstrwid(CHAR(s), LENGTH(s), ienc, quote);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  546|  8.33k|    const void *vmax = vmaxget();
  547|  8.33k|    const char *p = translateChar(s);
  ------------------
  |  | 1037|  8.33k|#define translateChar		Rf_translateChar
  ------------------
  548|  8.33k|    int len = Rstrwid(p, (int)strlen(p), CE_NATIVE, quote);
  549|  8.33k|    vmaxset(vmax);
  550|  8.33k|    return len;
  551|  8.33k|}
Rf_EncodeString:
  565|  2.16k|{
  566|  2.16k|    int i, cnt;
  567|  2.16k|    const char *p; char *q, buf[13];
  568|  2.16k|    cetype_t ienc = getCharCE(s);
  ------------------
  |  |  925|  2.16k|#define getCharCE		Rf_getCharCE
  ------------------
  569|  2.16k|    bool useUTF8 = w < 0;
  570|  2.16k|    const void *vmax = vmaxget();
  571|       |
  572|  2.16k|    if (w < 0) w = w + 1000000;
  ------------------
  |  Branch (572:9): [True: 0, False: 2.16k]
  ------------------
  573|       |
  574|       |    /* We have to do something like this as the result is returned, and
  575|       |       passed on by EncodeElement -- so no way could be end user be
  576|       |       responsible for freeing it.  However, this is not thread-safe. */
  577|       |
  578|  2.16k|    static R_StringBuffer gBuffer = {NULL, 0, BUFSIZE};
  ------------------
  |  |   88|  2.16k|#define BUFSIZE 8192  /* used by Rprintf etc */
  ------------------
  579|  2.16k|    R_StringBuffer *buffer = &gBuffer;
  580|       |
  581|  2.16k|    if (s == NA_STRING) {
  ------------------
  |  |  433|  2.16k|#define NA_STRING	R_NaString
  ------------------
  |  Branch (581:9): [True: 0, False: 2.16k]
  ------------------
  582|      0|	p = quote ? CHAR(R_print.na_string) : CHAR(R_print.na_string_noquote);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
              	p = quote ? CHAR(R_print.na_string) : CHAR(R_print.na_string_noquote);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (582:6): [True: 0, False: 0]
  ------------------
  583|      0|	cnt = (int)(quote ? strlen(CHAR(R_print.na_string)) :
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (583:14): [True: 0, False: 0]
  ------------------
  584|      0|		strlen(CHAR(R_print.na_string_noquote)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  585|      0|	i = (quote ? Rstrlen(R_print.na_string, 0) :
  ------------------
  |  Branch (585:7): [True: 0, False: 0]
  ------------------
  586|      0|		Rstrlen(R_print.na_string_noquote, 0));
  587|      0|	quote = 0;
  588|  2.16k|    } else {
  589|  2.16k|	if(IS_BYTES(s)) {
  ------------------
  |  Branch (589:5): [True: 0, False: 2.16k]
  ------------------
  590|      0|	    ienc = CE_NATIVE;
  591|       |#ifdef Win32
  592|       |	    if (WinUTF8out)
  593|       |		ienc = CE_UTF8;
  594|       |#endif
  595|      0|	    p = CHAR(s);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  596|      0|	    cnt = (int) strlen(p);
  597|      0|	    const char *q;
  598|      0|	    char *pp = R_alloc(4*cnt+1, 1), *qq = pp, buf[5];
  599|      0|	    for (q = p; *q; q++) {
  ------------------
  |  Branch (599:18): [True: 0, False: 0]
  ------------------
  600|      0|		unsigned char k = (unsigned char) *q;
  601|      0|		if (k >= 0x20 && k < 0x80) {
  ------------------
  |  Branch (601:7): [True: 0, False: 0]
  |  Branch (601:20): [True: 0, False: 0]
  ------------------
  602|      0|		    *qq++ = *q;
  603|      0|		    if (quote && *q == '"') cnt++;
  ------------------
  |  Branch (603:11): [True: 0, False: 0]
  |  Branch (603:20): [True: 0, False: 0]
  ------------------
  604|      0|		} else {
  605|      0|		    snprintf(buf, 5, "\\x%02x", k);
  606|      0|		    for(int j = 0; j < 4; j++) *qq++ = buf[j];
  ------------------
  |  Branch (606:22): [True: 0, False: 0]
  ------------------
  607|      0|		    cnt += 3;
  608|      0|		}
  609|      0|	    }
  610|      0|	    *qq = '\0';
  611|      0|	    p = pp;
  612|      0|	    i = cnt;
  613|       |#ifdef Win32
  614|       |	} else if(WinUTF8out) {
  615|       |	    if(ienc == CE_UTF8) {
  616|       |		p = CHAR(s);
  617|       |		i = Rstrlen(s, quote);
  618|       |		cnt = LENGTH(s);
  619|       |	    } else {
  620|       |		p = translateCharUTF8(s);
  621|       |		if(p == CHAR(s)) {
  622|       |		    i = Rstrlen(s, quote);
  623|       |		    cnt = LENGTH(s);
  624|       |		} else {
  625|       |		    cnt = (int) strlen(p);
  626|       |		    i = Rstrwid(p, cnt, CE_UTF8, quote);
  627|       |		}
  628|       |		ienc = CE_UTF8;
  629|       |	    }
  630|       |#endif
  631|  2.16k|	} else {
  632|  2.16k|	    if (useUTF8 && ienc == CE_UTF8) {
  ------------------
  |  Branch (632:10): [True: 0, False: 2.16k]
  |  Branch (632:21): [True: 0, False: 0]
  ------------------
  633|      0|		p = CHAR(s);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  634|      0|		i = Rstrlen(s, quote);
  635|      0|		cnt = LENGTH(s);
  636|  2.16k|	    } else {
  637|  2.16k|		ienc = CE_NATIVE;
  638|  2.16k|		p = translateChar(s);
  ------------------
  |  | 1037|  2.16k|#define translateChar		Rf_translateChar
  ------------------
  639|  2.16k|		if(p == CHAR(s)) {
  ------------------
  |  |  203|  2.16k|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (639:6): [True: 2.16k, False: 0]
  ------------------
  640|  2.16k|		    i = Rstrlen(s, quote);
  641|  2.16k|		    cnt = LENGTH(s);
  642|  2.16k|		} else {
  643|      0|		    cnt = (int) strlen(p);
  644|      0|		    i = Rstrwid(p, cnt, CE_NATIVE, quote);
  645|      0|		}
  646|  2.16k|	    }
  647|  2.16k|	}
  648|  2.16k|    }
  649|       |
  650|       |    /* We need enough space for the encoded string, including escapes.
  651|       |       Octal encoding turns one byte into four.
  652|       |       \u encoding can turn a multibyte into six or ten,
  653|       |       but it turns 2/3 into 6, and 4 (and perhaps 5/6) into 10.
  654|       |       Let's be wasteful here (the worst case appears to be an MBCS with
  655|       |       one byte for an upper-plane Unicode point output as ten bytes,
  656|       |       but I doubt that such an MBCS exists: two bytes is plausible).
  657|       |
  658|       |       +2 allows for quotes, +6 for UTF_8 escapes.
  659|       |     */
  660|  2.16k|    if(5.*cnt + 8 > (double) SIZE_MAX)
  ------------------
  |  Branch (660:8): [True: 0, False: 2.16k]
  ------------------
  661|      0|	error(_("too large string (nchar=%d) => 5*nchar + 8 > SIZE_MAX"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("too large string (nchar=%d) => 5*nchar + 8 > SIZE_MAX"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  662|      0|	      cnt);
  663|  2.16k|    size_t q_len = 5*(size_t)cnt + 8;
  664|  2.16k|    if(q_len < w) q_len = (size_t) w;
  ------------------
  |  Branch (664:8): [True: 0, False: 2.16k]
  ------------------
  665|  2.16k|    q = R_AllocStringBuffer(q_len, buffer);
  666|       |
  667|  2.16k|    int b = w - i - (quote ? 2 : 0); /* total amount of padding */
  ------------------
  |  Branch (667:22): [True: 255, False: 1.90k]
  ------------------
  668|  2.16k|    if(justify == Rprt_adj_none) b = 0;
  ------------------
  |  Branch (668:8): [True: 0, False: 2.16k]
  ------------------
  669|  2.16k|    if(b > 0 && justify != Rprt_adj_left) {
  ------------------
  |  Branch (669:8): [True: 0, False: 2.16k]
  |  Branch (669:17): [True: 0, False: 0]
  ------------------
  670|      0|	int b0 = (justify == Rprt_adj_centre) ? b/2 : b;
  ------------------
  |  Branch (670:11): [True: 0, False: 0]
  ------------------
  671|      0|	for(i = 0 ; i < b0 ; i++) *q++ = ' ';
  ------------------
  |  Branch (671:14): [True: 0, False: 0]
  ------------------
  672|      0|	b -= b0;
  673|      0|    }
  674|  2.16k|    if(quote) *q++ = (char) quote;
  ------------------
  |  Branch (674:8): [True: 255, False: 1.90k]
  ------------------
  675|  2.16k|    if(mbcslocale || ienc == CE_UTF8) {
  ------------------
  |  Branch (675:8): [True: 0, False: 2.16k]
  |  Branch (675:22): [True: 0, False: 2.16k]
  ------------------
  676|      0|	bool useUTF8 = (ienc == CE_UTF8);
  677|      0|	bool wchar_is_ucs_or_utf16 = TRUE;
  678|      0|	mbstate_t mb_st;
  679|       |#ifndef __STDC_ISO_10646__
  680|       |	bool Unicode_warning = FALSE;
  681|       |#endif
  682|       |# if !defined (__STDC_ISO_10646__) && !defined (Win32)
  683|       |	wchar_is_ucs_or_utf16 = FALSE;
  684|       |# endif
  685|      0|	if(!useUTF8)  mbs_init(&mb_st);
  ------------------
  |  | 2454|      0|#define mbs_init(x) memset(x, 0, sizeof(mbstate_t))
  ------------------
  |  Branch (685:5): [True: 0, False: 0]
  ------------------
  686|       |#ifdef Win32
  687|       |	else if(WinUTF8out) { memcpy(q, UTF8in, 3); q += 3; }
  688|       |#endif
  689|      0|	for (i = 0; i < cnt; i++) {
  ------------------
  |  Branch (689:14): [True: 0, False: 0]
  ------------------
  690|      0|	    wchar_t wc;
  691|      0|	    int res = (int)(useUTF8 ? utf8toucs(&wc, p):
  ------------------
  |  | 2009|      0|# define utf8toucs		Rf_utf8toucs
  ------------------
  |  Branch (691:22): [True: 0, False: 0]
  ------------------
  692|      0|			    mbrtowc(&wc, p, R_MB_CUR_MAX, &mb_st));
  693|       |	    /* res = 0 is a terminator
  694|       |	     * some mbrtowc implementations return wc past end of UCS */
  695|      0|	    if(res >= 0 &&
  ------------------
  |  Branch (695:9): [True: 0, False: 0]
  ------------------
  696|      0|	       ((0 <= wc && (unsigned long)wc <= 0x10FFFF) || !wchar_is_ucs_or_utf16)) {
  ------------------
  |  Branch (696:11): [True: 0, False: 0]
  |  Branch (696:22): [True: 0, False: 0]
  |  Branch (696:56): [True: 0, False: 0]
  ------------------
  697|      0|		unsigned int k; /* not wint_t as it might be signed */
  698|      0|		if (useUTF8 && IS_HIGH_SURROGATE(wc))
  ------------------
  |  |  173|      0|#define IS_HIGH_SURROGATE(wch) (((wch) >= HIGH_SURROGATE_START) && ((wch) <= HIGH_SURROGATE_END))
  |  |  ------------------
  |  |  |  |  162|      0|#define HIGH_SURROGATE_START 0xd800
  |  |  ------------------
  |  |               #define IS_HIGH_SURROGATE(wch) (((wch) >= HIGH_SURROGATE_START) && ((wch) <= HIGH_SURROGATE_END))
  |  |  ------------------
  |  |  |  |  163|      0|#define HIGH_SURROGATE_END 0xdbff
  |  |  ------------------
  |  |  |  Branch (173:33): [True: 0, False: 0]
  |  |  |  Branch (173:68): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (698:7): [True: 0, False: 0]
  ------------------
  699|      0|		    k = utf8toucs32(wc, p);
  ------------------
  |  |  177|      0|# define utf8toucs32		Rf_utf8toucs32
  ------------------
  700|      0|		else
  701|      0|		    k = wc;
  702|       |		/* To be portable, treat \0 explicitly */
  703|      0|		if(res == 0) {k = 0; wc = L'\0';}
  ------------------
  |  Branch (703:6): [True: 0, False: 0]
  ------------------
  704|      0|		if(0x20 <= k && k < 0x7f && iswprint(k)) {
  ------------------
  |  Branch (704:6): [True: 0, False: 0]
  |  Branch (704:19): [True: 0, False: 0]
  |  Branch (704:31): [True: 0, False: 0]
  ------------------
  705|      0|		    switch(wc) {
  706|      0|		    case L'\\': *q++ = '\\'; *q++ = '\\'; p++; break;
  ------------------
  |  Branch (706:7): [True: 0, False: 0]
  ------------------
  707|      0|		    case L'\'':
  ------------------
  |  Branch (707:7): [True: 0, False: 0]
  ------------------
  708|      0|		    case L'"':
  ------------------
  |  Branch (708:7): [True: 0, False: 0]
  ------------------
  709|      0|		    case L'`':
  ------------------
  |  Branch (709:7): [True: 0, False: 0]
  ------------------
  710|      0|			{
  711|      0|			    if(quote == *p)  *q++ = '\\';
  ------------------
  |  Branch (711:11): [True: 0, False: 0]
  ------------------
  712|      0|			    *q++ = *p++;
  713|      0|			    break;
  714|      0|			}
  715|      0|		    default:
  ------------------
  |  Branch (715:7): [True: 0, False: 0]
  ------------------
  716|      0|			for(int j = 0; j < res; j++) *q++ = *p++;
  ------------------
  |  Branch (716:19): [True: 0, False: 0]
  ------------------
  717|      0|			break;
  718|      0|		    }
  719|      0|		} else if (k < 0x80) {
  ------------------
  |  Branch (719:14): [True: 0, False: 0]
  ------------------
  720|       |		    /* ANSI Escapes */
  721|      0|		    switch(wc) {
  722|      0|		    case L'\a': *q++ = '\\'; *q++ = 'a'; break;
  ------------------
  |  Branch (722:7): [True: 0, False: 0]
  ------------------
  723|      0|		    case L'\b': *q++ = '\\'; *q++ = 'b'; break;
  ------------------
  |  Branch (723:7): [True: 0, False: 0]
  ------------------
  724|      0|		    case L'\f': *q++ = '\\'; *q++ = 'f'; break;
  ------------------
  |  Branch (724:7): [True: 0, False: 0]
  ------------------
  725|      0|		    case L'\n': *q++ = '\\'; *q++ = 'n'; break;
  ------------------
  |  Branch (725:7): [True: 0, False: 0]
  ------------------
  726|      0|		    case L'\r': *q++ = '\\'; *q++ = 'r'; break;
  ------------------
  |  Branch (726:7): [True: 0, False: 0]
  ------------------
  727|      0|		    case L'\t': *q++ = '\\'; *q++ = 't'; break;
  ------------------
  |  Branch (727:7): [True: 0, False: 0]
  ------------------
  728|      0|		    case L'\v': *q++ = '\\'; *q++ = 'v'; break;
  ------------------
  |  Branch (728:7): [True: 0, False: 0]
  ------------------
  729|      0|		    case L'\0': *q++ = '\\'; *q++ = '0'; break;
  ------------------
  |  Branch (729:7): [True: 0, False: 0]
  ------------------
  730|       |
  731|      0|		    default:
  ------------------
  |  Branch (731:7): [True: 0, False: 0]
  ------------------
  732|       |			/* print in octal */
  733|       |			// gcc 7 requires cast here
  734|      0|			snprintf(buf, 5, "\\%03o", (unsigned char)k);
  735|      0|			for(int j = 0; j < 4; j++) *q++ = buf[j];
  ------------------
  |  Branch (735:19): [True: 0, False: 0]
  ------------------
  736|      0|			break;
  737|      0|		    }
  738|      0|		    p++;
  739|      0|		} else {
  740|       |		    /* wc could be an unpaired surrogate and this does
  741|       |		     * not do the same as Rstrwid */
  742|       |		    /* no need to worry about truncation as iswprint
  743|       |		     * gets replaced on Windows */
  744|      0|		    if(iswprint(k)) {
  ------------------
  |  Branch (744:10): [True: 0, False: 0]
  ------------------
  745|       |			/* The problem here is that wc may be
  746|       |			   printable according to the Unicode tables,
  747|       |			   but it may not be printable on the output
  748|       |			   device concerned.
  749|       |
  750|       |			   And the system iswprintf may not correspond
  751|       |			   to the latest Unicode tables.
  752|       |			*/
  753|      0|			for(int j = 0; j < res; j++) *q++ = *p++;
  ------------------
  |  Branch (753:19): [True: 0, False: 0]
  ------------------
  754|      0|		    } else {
  755|       |# if !defined (__STDC_ISO_10646__) && !defined (Win32)
  756|       |			Unicode_warning = TRUE;
  757|       |# endif
  758|      0|			if(k > 0xffff)
  ------------------
  |  Branch (758:7): [True: 0, False: 0]
  ------------------
  759|      0|			    snprintf(buf, 13, "\\U{%06x}", k);
  760|      0|			else
  761|      0|			    snprintf(buf, 11, "\\u%04x", k);
  762|      0|			int j = (int) strlen(buf);
  763|      0|			memcpy(q, buf, j);
  764|      0|			q += j;
  765|      0|			p += res;
  766|      0|		    }
  767|      0|		    i += (res - 1);
  768|      0|		}
  769|      0|	    } else { /* invalid char */
  770|      0|		snprintf(q, 5, "\\x%02x", *((unsigned char *)p));
  771|      0|		q += 4; p++;
  772|      0|	    }
  773|      0|	}
  774|       |#ifndef __STDC_ISO_10646__
  775|       |	if(Unicode_warning)
  776|       |	    warning(_("it is not known that wchar_t is Unicode on this platform"));
  777|       |#endif
  778|       |
  779|      0|    } else
  780|  13.8k|	for (i = 0; i < cnt; i++) {
  ------------------
  |  Branch (780:14): [True: 11.7k, False: 2.16k]
  ------------------
  781|       |
  782|       |	    /* ASCII */
  783|  11.7k|	    if((unsigned char) *p < 0x80) {
  ------------------
  |  Branch (783:9): [True: 11.7k, False: 0]
  ------------------
  784|  11.7k|		if(*p != '\t' && isprint((int)*p)) { /* Windows has \t as printable */
  ------------------
  |  Branch (784:6): [True: 11.7k, False: 0]
  |  Branch (784:20): [True: 11.6k, False: 112]
  ------------------
  785|  11.6k|		    switch(*p) {
  786|      0|		    case '\\': *q++ = '\\'; *q++ = '\\'; break;
  ------------------
  |  Branch (786:7): [True: 0, False: 11.6k]
  ------------------
  787|      0|		    case '\'':
  ------------------
  |  Branch (787:7): [True: 0, False: 11.6k]
  ------------------
  788|      0|		    case '"':
  ------------------
  |  Branch (788:7): [True: 0, False: 11.6k]
  ------------------
  789|      0|		    case '`':
  ------------------
  |  Branch (789:7): [True: 0, False: 11.6k]
  ------------------
  790|      0|		    {
  791|      0|			if(quote == *p)  *q++ = '\\';
  ------------------
  |  Branch (791:7): [True: 0, False: 0]
  ------------------
  792|      0|			*q++ = *p;
  793|      0|			break;
  794|      0|		    }
  795|  11.6k|		    default: *q++ = *p; break;
  ------------------
  |  Branch (795:7): [True: 11.6k, False: 0]
  ------------------
  796|  11.6k|		    }
  797|  11.6k|		} else switch(*p) {
  798|       |			/* ANSI Escapes */
  799|      0|		    case '\a': *q++ = '\\'; *q++ = 'a'; break;
  ------------------
  |  Branch (799:7): [True: 0, False: 112]
  ------------------
  800|      0|		    case '\b': *q++ = '\\'; *q++ = 'b'; break;
  ------------------
  |  Branch (800:7): [True: 0, False: 112]
  ------------------
  801|      0|		    case '\f': *q++ = '\\'; *q++ = 'f'; break;
  ------------------
  |  Branch (801:7): [True: 0, False: 112]
  ------------------
  802|    112|		    case '\n': *q++ = '\\'; *q++ = 'n'; break;
  ------------------
  |  Branch (802:7): [True: 112, False: 0]
  ------------------
  803|      0|		    case '\r': *q++ = '\\'; *q++ = 'r'; break;
  ------------------
  |  Branch (803:7): [True: 0, False: 112]
  ------------------
  804|      0|		    case '\t': *q++ = '\\'; *q++ = 't'; break;
  ------------------
  |  Branch (804:7): [True: 0, False: 112]
  ------------------
  805|      0|		    case '\v': *q++ = '\\'; *q++ = 'v'; break;
  ------------------
  |  Branch (805:7): [True: 0, False: 112]
  ------------------
  806|      0|		    case '\0': *q++ = '\\'; *q++ = '0'; break;
  ------------------
  |  Branch (806:7): [True: 0, False: 112]
  ------------------
  807|       |
  808|      0|		    default:
  ------------------
  |  Branch (808:7): [True: 0, False: 112]
  ------------------
  809|       |			/* print in octal */
  810|      0|			snprintf(buf, 5, "\\%03o", (unsigned char) *p);
  811|      0|			for(int j = 0; j < 4; j++) *q++ = buf[j];
  ------------------
  |  Branch (811:19): [True: 0, False: 0]
  ------------------
  812|      0|			break;
  813|    112|		    }
  814|  11.7k|		p++;
  815|  11.7k|	    } else {  /* 8 bit char */
  816|      0|		if(!isprint((int)*p & 0xff)) {
  ------------------
  |  Branch (816:6): [True: 0, False: 0]
  ------------------
  817|       |		    /* print in octal */
  818|      0|		    snprintf(buf, 5, "\\%03o", (unsigned char) *p);
  819|      0|		    for(int j = 0; j < 4; j++) *q++ = buf[j];
  ------------------
  |  Branch (819:22): [True: 0, False: 0]
  ------------------
  820|      0|		    p++;
  821|      0|		} else *q++ = *p++;
  822|      0|	    }
  823|  11.7k|	}
  824|       |
  825|       |#ifdef Win32
  826|       |    if(WinUTF8out && ienc == CE_UTF8)  { memcpy(q, UTF8out, 3); q += 3; }
  827|       |#endif
  828|  2.16k|    if(quote) *q++ = (char) quote;
  ------------------
  |  Branch (828:8): [True: 255, False: 1.90k]
  ------------------
  829|  2.16k|    if(b > 0 && justify != Rprt_adj_right) {
  ------------------
  |  Branch (829:8): [True: 0, False: 2.16k]
  |  Branch (829:17): [True: 0, False: 0]
  ------------------
  830|      0|	for(i = 0 ; i < b ; i++) *q++ = ' ';
  ------------------
  |  Branch (830:14): [True: 0, False: 0]
  ------------------
  831|      0|    }
  832|  2.16k|    *q = '\0';
  833|       |
  834|  2.16k|    vmaxset(vmax);
  835|  2.16k|    return buffer->data;
  836|  2.16k|}
Rf_EncodeElement:
  843|  4.55k|{
  844|  4.55k|    char dec[2];
  845|  4.55k|    dec[0] = cdec; dec[1] = '\0';
  846|  4.55k|    return EncodeElement0(x, indx, quote, dec);
  ------------------
  |  |   35|  4.55k|#define EncodeElement0      Rf_EncodeElement0
  ------------------
  847|  4.55k|}
Rf_EncodeElement0:
  850|  4.55k|{
  851|  4.55k|    int w, d, e, wi, di, ei;
  852|  4.55k|    const char *res;
  853|       |
  854|  4.55k|    switch(TYPEOF(x)) {
  855|    241|    case LGLSXP:
  ------------------
  |  |  121|    241|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (855:5): [True: 241, False: 4.31k]
  ------------------
  856|    241|	formatLogical(&LOGICAL_RO(x)[indx], 1, &w);
  ------------------
  |  |   39|    241|#define formatLogical      Rf_formatLogical
  ------------------
  857|    241|	res = EncodeLogical(LOGICAL_RO(x)[indx], w);
  ------------------
  |  |   43|    241|#define EncodeLogical      Rf_EncodeLogical
  ------------------
  858|    241|	break;
  859|    252|    case INTSXP:
  ------------------
  |  |  123|    252|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (859:5): [True: 252, False: 4.30k]
  ------------------
  860|    252|	formatInteger(&INTEGER_RO(x)[indx], 1, &w);
  ------------------
  |  |   40|    252|#define formatInteger      Rf_formatInteger
  ------------------
  861|    252|	res = EncodeInteger(INTEGER_RO(x)[indx], w);
  ------------------
  |  |   44|    252|#define EncodeInteger      Rf_EncodeInteger
  ------------------
  862|    252|	break;
  863|  3.80k|    case REALSXP:
  ------------------
  |  |  124|  3.80k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (863:5): [True: 3.80k, False: 748]
  ------------------
  864|  3.80k|	formatReal(&REAL_RO(x)[indx], 1, &w, &d, &e, 0);
  ------------------
  |  |   41|  3.80k|#define formatReal         Rf_formatReal
  ------------------
  865|  3.80k|	res = EncodeReal0(REAL_RO(x)[indx], w, d, e, dec);
  ------------------
  |  |   46|  3.80k|#define EncodeReal0        Rf_EncodeReal0
  ------------------
  866|  3.80k|	break;
  867|    255|    case STRSXP:
  ------------------
  |  |  126|    255|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (867:5): [True: 255, False: 4.29k]
  ------------------
  868|    255|	formatString(&STRING_PTR_RO(x)[indx], 1, &w, quote);
  ------------------
  |  |   31|    255|#define formatString        Rf_formatString
  ------------------
  869|    255|	res = EncodeString(STRING_ELT(x, indx), w, quote, Rprt_adj_left);
  ------------------
  |  | 1893|    255|# define EncodeString           Rf_EncodeString
  ------------------
  870|    255|	break;
  871|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (871:5): [True: 0, False: 4.55k]
  ------------------
  872|      0|	formatComplex(&COMPLEX_RO(x)[indx], 1, &w, &d, &e, &wi, &di, &ei, 0);
  ------------------
  |  |   42|      0|#define formatComplex      Rf_formatComplex
  ------------------
  873|      0|	res = EncodeComplex(COMPLEX_RO(x)[indx], w, d, e, wi, di, ei, dec);
  ------------------
  |  |   47|      0|#define EncodeComplex      Rf_EncodeComplex
  ------------------
  874|      0|	break;
  875|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (875:5): [True: 0, False: 4.55k]
  ------------------
  876|      0|	res = EncodeRaw(RAW_RO(x)[indx], "");
  ------------------
  |  | 1891|      0|# define EncodeRaw              Rf_EncodeRaw
  ------------------
  877|      0|	break;
  878|      0|    default:
  ------------------
  |  Branch (878:5): [True: 0, False: 4.55k]
  ------------------
  879|      0|	res = NULL; /* -Wall */
  880|      0|	UNIMPLEMENTED_TYPE("EncodeElement", x);
  881|  4.55k|    }
  882|  4.55k|    return res;
  883|  4.55k|}
Rf_EncodeChar:
  896|  1.90k|{
  897|  1.90k|    return EncodeString(x, 0, 0, Rprt_adj_left);
  ------------------
  |  | 1893|  1.90k|# define EncodeString           Rf_EncodeString
  ------------------
  898|  1.90k|}
Rf_IndexWidth:
 1085|    256|{
 1086|    256|    return (int) (log10((double)n + 0.5) + 1);
 1087|    256|}
printutils.c:EncodeRealDrop0:
  251|     11|{
  252|     11|    static char buff[NB], buff2[2*NB];
  253|     11|    char fmt[20], *out = buff;
  254|       |
  255|       |    /* IEEE allows signed zeros (yuck!) */
  256|     11|    if (x == 0.0) x = 0.0;
  ------------------
  |  Branch (256:9): [True: 0, False: 11]
  ------------------
  257|     11|    if (!R_FINITE(x)) {
  ------------------
  |  |   82|     11|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (257:9): [True: 0, False: 11]
  ------------------
  258|      0|	if(ISNA(x))       snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |   64|      0|#define ISNA(x)	       R_IsNA(x)
  |  |  ------------------
  |  |  |  Branch (64:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	if(ISNA(x))       snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
              	if(ISNA(x))       snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	if(ISNA(x))       snprintf(buff, NB, "%*s", min(w, (NB-1)), CHAR(R_print.na_string));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  259|      0|	else if(ISNAN(x)) snprintf(buff, NB, "%*s", min(w, (NB-1)), "NaN");
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	else if(ISNAN(x)) snprintf(buff, NB, "%*s", min(w, (NB-1)), "NaN");
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
              	else if(ISNAN(x)) snprintf(buff, NB, "%*s", min(w, (NB-1)), "NaN");
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  260|      0|	else if(x > 0)    snprintf(buff, NB, "%*s", min(w, (NB-1)), "Inf");
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
              	else if(x > 0)    snprintf(buff, NB, "%*s", min(w, (NB-1)), "Inf");
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (260:10): [True: 0, False: 0]
  ------------------
  261|      0|	else              snprintf(buff, NB, "%*s", min(w, (NB-1)), "-Inf");
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
              	else              snprintf(buff, NB, "%*s", min(w, (NB-1)), "-Inf");
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  262|      0|    }
  263|     11|    else if (e) {
  ------------------
  |  Branch (263:14): [True: 0, False: 11]
  ------------------
  264|      0|	if(d) {
  ------------------
  |  Branch (264:5): [True: 0, False: 0]
  ------------------
  265|      0|	    snprintf(fmt, 20, "%%#%d.%de", min(w, (NB-1)), d);
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  266|      0|	}
  267|      0|	else {
  268|      0|	    snprintf(fmt, 20, "%%%d.%de", min(w, (NB-1)), d);
  ------------------
  |  |   85|      0|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  269|      0|	}
  270|      0|	snprintf(buff, NB, fmt, x);
  ------------------
  |  |  124|      0|#define NB 1000
  ------------------
  271|      0|    }
  272|     11|    else { /* e = 0 */
  273|     11|	snprintf(fmt, 20, "%%%d.%df", min(w, (NB-1)), d);
  ------------------
  |  |   85|     11|#define min(a, b) (((a)<(b))?(a):(b))
  |  |  ------------------
  |  |  |  Branch (85:20): [True: 11, False: 0]
  |  |  ------------------
  ------------------
  274|     11|	snprintf(buff, NB, fmt, x);
  ------------------
  |  |  124|     11|#define NB 1000
  ------------------
  275|     11|    }
  276|     11|    buff[NB-1] = '\0';
  ------------------
  |  |  124|     11|#define NB 1000
  ------------------
  277|       |
  278|       |    // Drop trailing zeroes
  279|     24|    for (char *p = buff; *p; p++) {
  ------------------
  |  Branch (279:26): [True: 13, False: 11]
  ------------------
  280|     13|	if(*p == '.') {
  ------------------
  |  Branch (280:5): [True: 0, False: 13]
  ------------------
  281|      0|	    char *replace = p++;
  282|      0|	    while ('0' <= *p  &&  *p <= '9')
  ------------------
  |  Branch (282:13): [True: 0, False: 0]
  |  Branch (282:28): [True: 0, False: 0]
  ------------------
  283|      0|		if(*(p++) != '0')
  ------------------
  |  Branch (283:6): [True: 0, False: 0]
  ------------------
  284|      0|		    replace = p;
  285|      0|	    if(replace != p)
  ------------------
  |  Branch (285:9): [True: 0, False: 0]
  ------------------
  286|      0|		while((*(replace++) = *(p++)))
  ------------------
  |  Branch (286:9): [True: 0, False: 0]
  ------------------
  287|      0|		    ;
  288|      0|	    break;
  289|      0|	}
  290|     13|    }
  291|       |
  292|     11|    if(strcmp(dec, ".")) { /* replace "." by dec */
  ------------------
  |  Branch (292:8): [True: 0, False: 11]
  ------------------
  293|      0|	int len = strwidth(dec); /* 3·14 must work */
  ------------------
  |  |  192|      0|#define strwidth(x) Rstrwid(x, (int) strlen(x), CE_NATIVE, 0)
  ------------------
  294|      0|	if(len != 1) warning(
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  |  Branch (294:5): [True: 0, False: 0]
  ------------------
  295|      0|	    _("the decimal mark is %s than one character wide; this will become an error"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  296|      0|	    (len > 1) ? "more" : "less");
  ------------------
  |  Branch (296:6): [True: 0, False: 0]
  ------------------
  297|       |
  298|      0|	char *p, *q;
  299|      0|	for(p = buff, q = buff2; *p; p++) {
  ------------------
  |  Branch (299:27): [True: 0, False: 0]
  ------------------
  300|      0|	    if(*p == '.') for(const char *r = dec; *r; r++) *q++ = *r;
  ------------------
  |  Branch (300:9): [True: 0, False: 0]
  |  Branch (300:45): [True: 0, False: 0]
  ------------------
  301|      0|	    else *q++ = *p;
  302|      0|	}
  303|      0|	*q = '\0';
  304|      0|	out = buff2;
  305|      0|    }
  306|       |
  307|     11|    return out;
  308|     11|}

do_radixsort:
 1547|      2|{
 1548|      2|    int n = -1, narg = 0, ngrp, tmp, *osub, thisgrpn;
 1549|      2|    R_xlen_t nl = n;
 1550|      2|    bool isSorted = true, retGrp;
 1551|      2|    void *xd;
 1552|      2|    int *o = NULL;
 1553|       |
 1554|       |    /* ML: FIXME: Here are just two of the dangerous assumptions here */
 1555|      2|    if (sizeof(int) != 4) {
  ------------------
  |  Branch (1555:9): [Folded, False: 2]
  ------------------
 1556|      0|        error("radix sort assumes sizeof(int) == 4");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 1557|      0|    }
 1558|      2|    if (sizeof(double) != 8) {
  ------------------
  |  Branch (1558:9): [Folded, False: 2]
  ------------------
 1559|      0|        error("radix sort assumes sizeof(double) == 8");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 1560|      0|    }
 1561|       |    
 1562|      2|    nalast = (asLogical(CAR(args)) == NA_LOGICAL) ? 0 :
  ------------------
  |  |  886|      2|#define asLogical		Rf_asLogical
  ------------------
                  nalast = (asLogical(CAR(args)) == NA_LOGICAL) ? 0 :
  ------------------
  |  |   55|      2|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1562:14): [True: 0, False: 2]
  ------------------
 1563|      2|	(asLogical(CAR(args)) == TRUE) ? 1 : -1; // 1=TRUE, -1=FALSE, 0=NA
  ------------------
  |  |  886|      2|#define asLogical		Rf_asLogical
  ------------------
  |  Branch (1563:2): [True: 2, False: 0]
  ------------------
 1564|      2|    args = CDR(args);
 1565|      2|    SEXP decreasing = CAR(args);
 1566|      2|    args = CDR(args);
 1567|       |
 1568|       |    /* If TRUE, return starts of runs of identical values + max group size. */
 1569|      2|    retGrp = asBool2(CAR(args), call);
  ------------------
  |  | 1860|      2|# define asBool2	       	Rf_asBool2
  ------------------
 1570|      2|    args = CDR(args);
 1571|       |
 1572|       |    /* If FALSE, get order of strings in appearance order. Essentially
 1573|       |       abuses the CHARSXP table to group strings without hashing
 1574|       |       them. Only makes sense when retGrp=TRUE.
 1575|       |    */
 1576|      2|    sortStr = asBool2(CAR(args), call );
  ------------------
  |  | 1860|      2|# define asBool2	       	Rf_asBool2
  ------------------
 1577|      2|    args = CDR(args);
 1578|       |
 1579|       |    /* When grouping, we round off doubles to account for imprecision */
 1580|      2|    setNumericRounding(retGrp ? 2 : 0);
  ------------------
  |  Branch (1580:24): [True: 0, False: 2]
  ------------------
 1581|       |
 1582|      2|    if (args == R_NilValue)
  ------------------
  |  Branch (1582:9): [True: 0, False: 2]
  ------------------
 1583|      0|	return R_NilValue;
 1584|      2|    if (isVector(CAR(args)))
  ------------------
  |  |  974|      2|#define isVector		Rf_isVector
  ------------------
  |  Branch (1584:9): [True: 2, False: 0]
  ------------------
 1585|      2|	nl = XLENGTH(CAR(args));
 1586|      4|    for (SEXP ap = args; ap != R_NilValue; ap = CDR(ap), narg++) {
  ------------------
  |  Branch (1586:26): [True: 2, False: 2]
  ------------------
 1587|      2|	if (!isVector(CAR(ap)))
  ------------------
  |  |  974|      2|#define isVector		Rf_isVector
  ------------------
  |  Branch (1587:6): [True: 0, False: 2]
  ------------------
 1588|      0|	    error(_("argument %d is not a vector"), narg + 1);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("argument %d is not a vector"), narg + 1);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1589|       |        //Rprintf("%d, %d\n", XLENGTH(CAR(ap)), nl);
 1590|      2|	if (XLENGTH(CAR(ap)) != nl)
  ------------------
  |  Branch (1590:6): [True: 0, False: 2]
  ------------------
 1591|      0|	    error(_("argument lengths differ"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("argument lengths differ"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1592|      2|    }
 1593|       |
 1594|      2|    if (narg != length(decreasing))
  ------------------
  |  |  987|      2|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1594:9): [True: 0, False: 2]
  ------------------
 1595|      0|	error(_("length(decreasing) must match the number of order arguments"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("length(decreasing) must match the number of order arguments"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1596|      4|    for (int i = 0; i < narg; i++) {
  ------------------
  |  Branch (1596:21): [True: 2, False: 2]
  ------------------
 1597|      2|	if (LOGICAL(decreasing)[i] == NA_LOGICAL)
  ------------------
  |  |   55|      2|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1597:6): [True: 0, False: 2]
  ------------------
 1598|      0|	    error(_("'decreasing' elements must be TRUE or FALSE"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("'decreasing' elements must be TRUE or FALSE"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1599|      2|    }
 1600|      2|    order = asLogical(decreasing) ? -1 : 1;
  ------------------
  |  |  886|      2|#define asLogical		Rf_asLogical
  ------------------
  |  Branch (1600:13): [True: 0, False: 2]
  ------------------
 1601|       |
 1602|      2|    SEXP x = CAR(args);
 1603|      2|    args = CDR(args);
 1604|       |
 1605|       |    // (ML) FIXME: need to support long vectors
 1606|      2|    if (nl > INT_MAX) {
  ------------------
  |  Branch (1606:9): [True: 0, False: 2]
  ------------------
 1607|      0|	error(_("long vectors not supported"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("long vectors not supported"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1608|      0|    }
 1609|      2|    n = (int) nl;
 1610|       |
 1611|       |    // upper limit for stack size (all size 1 groups). We'll detect
 1612|       |    // and avoid that limit, but if just one non-1 group (say 2), that
 1613|       |    // can't be avoided.
 1614|      2|    gsmaxalloc = n;
 1615|       |
 1616|       |    // once for the result, needs to be length n.
 1617|       |
 1618|       |    // TO DO: save allocation if NULL is returned (isSorted = =TRUE) so
 1619|       |    // [i|c|d]sort know they can populate o directly with no working
 1620|       |    // memory needed to reorder existing order had to repace this from
 1621|       |    // '0' to '-1' because 'nalast = 0' replace 'o[.]' with 0 values.
 1622|       |
 1623|      2|    SEXP ans = PROTECT(allocVector(INTSXP, n));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1624|      2|    o = INTEGER(ans);
 1625|      2|    if (n > 0)
  ------------------
  |  Branch (1625:9): [True: 2, False: 0]
  ------------------
 1626|      2|	o[0] = -1;
 1627|      2|    xd = DATAPTR(x);
 1628|       |
 1629|      2|    stackgrps = narg > 1 || retGrp;
  ------------------
  |  Branch (1629:17): [True: 0, False: 2]
  |  Branch (1629:29): [True: 0, False: 2]
  ------------------
 1630|       |
 1631|      2|    if (TYPEOF(x) == STRSXP) {
  ------------------
  |  |  126|      2|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1631:9): [True: 0, False: 2]
  ------------------
 1632|      0|        checkEncodings(x);
 1633|      0|    }
 1634|       |    
 1635|      2|    savetl_init();   // from now on use Error not error.
 1636|       |
 1637|      2|    switch (TYPEOF(x)) {
 1638|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1638:5): [True: 0, False: 2]
  ------------------
 1639|      2|    case LGLSXP:
  ------------------
  |  |  121|      2|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1639:5): [True: 2, False: 0]
  ------------------
 1640|      2|	tmp = isorted(xd, n);
 1641|      2|	break;
 1642|      0|    case REALSXP :
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1642:5): [True: 0, False: 2]
  ------------------
 1643|      0|	twiddle = &dtwiddle;
 1644|      0|	is_nan  = &dnan;
 1645|      0|	tmp = dsorted(xd, n);
 1646|      0|	break;
 1647|      0|    case STRSXP :
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1647:5): [True: 0, False: 2]
  ------------------
 1648|      0|	tmp = csorted(xd, n);
 1649|      0|	break;
 1650|      0|    default :
  ------------------
  |  Branch (1650:5): [True: 0, False: 2]
  ------------------
 1651|      0|        Error("First arg is type '%s', not yet supported",
  ------------------
  |  |  126|      0|#define Error(...) do {savetl_end(); error(__VA_ARGS__);} while(0)
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (126:65): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1652|      2|              R_typeToChar(x));
 1653|      2|    }
 1654|      2|    if (tmp) {
  ------------------
  |  Branch (1654:9): [True: 2, False: 0]
  ------------------
 1655|       |	// -1 or 1. NEW: or -2 in case of nalast == 0 and all NAs
 1656|      2|	if (tmp == 1) {
  ------------------
  |  Branch (1656:6): [True: 2, False: 0]
  ------------------
 1657|       |	    // same as expected in 'order' (1 = increasing, -1 = decreasing)
 1658|      2|	    isSorted = true;
 1659|     14|	    for (int i = 0; i < n; i++)
  ------------------
  |  Branch (1659:22): [True: 12, False: 2]
  ------------------
 1660|     12|		o[i] = i + 1;
 1661|      2|	} else if (tmp == -1) {
  ------------------
  |  Branch (1661:13): [True: 0, False: 0]
  ------------------
 1662|       |	    // -1 (or -n for result of strcmp), strictly opposite to
 1663|       |	    // -expected 'order'
 1664|      0|	    isSorted = false;
 1665|      0|	    for (int i = 0; i < n; i++)
  ------------------
  |  Branch (1665:22): [True: 0, False: 0]
  ------------------
 1666|      0|		o[i] = n - i;
 1667|      0|	} else if (nalast == 0 && tmp == -2) {
  ------------------
  |  Branch (1667:13): [True: 0, False: 0]
  |  Branch (1667:28): [True: 0, False: 0]
  ------------------
 1668|       |	    // happens only when nalast=NA/0. Means all NAs, replace
 1669|       |	    // with 0's therefore!
 1670|      0|	    isSorted = false;
 1671|      0|	    for (int i = 0; i < n; i++)
  ------------------
  |  Branch (1671:22): [True: 0, False: 0]
  ------------------
 1672|      0|		o[i] = 0;
 1673|      0|	}
 1674|      2|    } else {
 1675|      0|	isSorted = false;
 1676|      0|	switch (TYPEOF(x)) {
 1677|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1677:2): [True: 0, False: 0]
  ------------------
 1678|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1678:2): [True: 0, False: 0]
  ------------------
 1679|      0|	    isort(xd, o, n);
 1680|      0|	    break;
 1681|      0|	case REALSXP :
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1681:2): [True: 0, False: 0]
  ------------------
 1682|      0|	    dsort(xd, o, n);
 1683|      0|	    break;
 1684|      0|	case STRSXP :
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1684:2): [True: 0, False: 0]
  ------------------
 1685|      0|	    if (sortStr) {
  ------------------
  |  Branch (1685:10): [True: 0, False: 0]
  ------------------
 1686|      0|		csort_pre(xd, n);
 1687|      0|		alloc_csort_otmp(n);
 1688|      0|		csort(xd, o, n);
 1689|      0|	    } else
 1690|      0|		cgroup(xd, o, n);
 1691|      0|	    break;
 1692|      0|	default:
  ------------------
  |  Branch (1692:2): [True: 0, False: 0]
  ------------------
 1693|      0|	    Error
  ------------------
  |  |  126|      0|#define Error(...) do {savetl_end(); error(__VA_ARGS__);} while(0)
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (126:65): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1694|      0|		("Internal error: previous default should have caught unsupported type");
 1695|      0|	}
 1696|      0|    }
 1697|       |    
 1698|      2|    int maxgrpn = gsmax[flip];   // biggest group in the first arg
 1699|      2|    void *xsub = NULL;           // local
 1700|       |// This was not valid C23, and clang 15 warns it was not valid C99 either.
 1701|       |//    int (*f) ();  // called with fn pointer, int
 1702|       |//    void (*g) (); // called with fn pointer, int *, int
 1703|      2|    int fgtype;
 1704|       |    
 1705|      2|    if (narg > 1 && gsngrp[flip] < n) {
  ------------------
  |  Branch (1705:9): [True: 0, False: 2]
  |  Branch (1705:21): [True: 0, False: 0]
  ------------------
 1706|       |        // double is the largest type, 8
 1707|      0|        xsub = (void *) malloc(maxgrpn * sizeof(double));
 1708|      0|        if (xsub == NULL)
  ------------------
  |  Branch (1708:13): [True: 0, False: 0]
  ------------------
 1709|      0|            Error("Couldn't allocate xsub in do_radixsort, requested %d * %d bytes.",
  ------------------
  |  |  126|      0|#define Error(...) do {savetl_end(); error(__VA_ARGS__);} while(0)
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (126:65): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1710|      0|                  maxgrpn, (int)sizeof(double));
 1711|       |        // global variable, used by isort, dsort, sort and cgroup
 1712|      0|        newo = (int *) malloc(maxgrpn * sizeof(int));
 1713|      0|        if (newo == NULL)
  ------------------
  |  Branch (1713:13): [True: 0, False: 0]
  ------------------
 1714|      0|            Error("Couldn't allocate newo in do_radixsort, requested %d * %d bytes.",
  ------------------
  |  |  126|      0|#define Error(...) do {savetl_end(); error(__VA_ARGS__);} while(0)
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (126:65): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1715|      0|                  maxgrpn, (int)sizeof(int));
 1716|      0|    }
 1717|       |
 1718|      2|    for (int col = 2; col <= narg; col++) {
  ------------------
  |  Branch (1718:23): [True: 0, False: 2]
  ------------------
 1719|      0|	x = CAR(args);
 1720|      0|	args = CDR(args);
 1721|      0|	xd = DATAPTR(x);
 1722|      0|	ngrp = gsngrp[flip];
 1723|      0|	if (ngrp == n && nalast != 0)
  ------------------
  |  Branch (1723:6): [True: 0, False: 0]
  |  Branch (1723:19): [True: 0, False: 0]
  ------------------
 1724|      0|	    break;
 1725|      0|	flipflop();
 1726|      0|	stackgrps = col != narg || retGrp;
  ------------------
  |  Branch (1726:14): [True: 0, False: 0]
  |  Branch (1726:29): [True: 0, False: 0]
  ------------------
 1727|      0|	order = LOGICAL(decreasing)[col - 1] ? -1 : 1;
  ------------------
  |  Branch (1727:10): [True: 0, False: 0]
  ------------------
 1728|      0|	switch (TYPEOF(x)) {
 1729|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1729:2): [True: 0, False: 0]
  ------------------
 1730|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1730:2): [True: 0, False: 0]
  ------------------
 1731|       |//	    f = &isorted;
 1732|       |//	    g = &isort;
 1733|      0|	    fgtype = 1;
 1734|      0|	    break;
 1735|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1735:2): [True: 0, False: 0]
  ------------------
 1736|      0|	    twiddle = &dtwiddle;
 1737|      0|	    is_nan = &dnan;
 1738|      0|	    fgtype = 2;
 1739|       |//	    f = &dsorted;
 1740|       |//	    g = &dsort;
 1741|      0|	    break;
 1742|      0|	case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1742:2): [True: 0, False: 0]
  ------------------
 1743|      0|	    fgtype = 3;
 1744|       |//	    f = &csorted;
 1745|      0|	    if (sortStr) {
  ------------------
  |  Branch (1745:10): [True: 0, False: 0]
  ------------------
 1746|      0|		csort_pre(xd, n);
 1747|      0|		alloc_csort_otmp(gsmax[1 - flip]);
 1748|       |//		g = &csort;
 1749|      0|	    }
 1750|       |	    // no increasing/decreasing order required if sortStr = FALSE,
 1751|       |	    // just a dummy argument
 1752|      0|	    else {
 1753|      0|		fgtype = 4;
 1754|       |//		g = &cgroup;
 1755|      0|	    }
 1756|      0|	    break;
 1757|      0|	default:
  ------------------
  |  Branch (1757:2): [True: 0, False: 0]
  ------------------
 1758|      0|	    Error("Arg %d is type '%s', not yet supported",
  ------------------
  |  |  126|      0|#define Error(...) do {savetl_end(); error(__VA_ARGS__);} while(0)
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (126:65): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1759|      0|		  col, R_typeToChar(x));
 1760|      0|	}
 1761|      0|	int i = 0;
 1762|      0|	for (int grp = 0; grp < ngrp; grp++) {
  ------------------
  |  Branch (1762:20): [True: 0, False: 0]
  ------------------
 1763|      0|	    thisgrpn = gs[1 - flip][grp];
 1764|      0|	    if (thisgrpn == 1) {
  ------------------
  |  Branch (1764:10): [True: 0, False: 0]
  ------------------
 1765|      0|		if (nalast == 0) {
  ------------------
  |  Branch (1765:7): [True: 0, False: 0]
  ------------------
 1766|       |		    // this edge case had to be taken care of
 1767|       |		    // here.. (see the bottom of this file for
 1768|       |		    // more explanation)
 1769|      0|                   if (o[i] == 0) { // already sorted as NA
  ------------------
  |  Branch (1769:24): [True: 0, False: 0]
  ------------------
 1770|      0|                       isSorted = false;
 1771|      0|                   } else switch (TYPEOF(x)) {
 1772|      0|		    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1772:7): [True: 0, False: 0]
  ------------------
 1773|      0|			if (INTEGER(x)[o[i] - 1] == NA_INTEGER) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1773:8): [True: 0, False: 0]
  ------------------
 1774|      0|			    isSorted = false;
 1775|      0|			    o[i] = 0;
 1776|      0|			}
 1777|      0|			break;
 1778|      0|		    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1778:7): [True: 0, False: 0]
  ------------------
 1779|      0|			if (LOGICAL(x)[o[i] - 1] == NA_LOGICAL) {
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1779:8): [True: 0, False: 0]
  ------------------
 1780|      0|			    isSorted = false;
 1781|      0|			    o[i] = 0;
 1782|      0|			}
 1783|      0|			break;
 1784|      0|		    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1784:7): [True: 0, False: 0]
  ------------------
 1785|      0|			if (ISNAN(REAL(x)[o[i] - 1])) {
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1786|      0|			    isSorted = false;
 1787|      0|			    o[i] = 0;
 1788|      0|			}
 1789|      0|			break;
 1790|      0|		    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1790:7): [True: 0, False: 0]
  ------------------
 1791|      0|			if (STRING_ELT(x, o[i] - 1) == NA_STRING) {
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1791:8): [True: 0, False: 0]
  ------------------
 1792|      0|			    isSorted = false;
 1793|      0|			    o[i] = 0;
 1794|      0|                        } break;
 1795|      0|                    default :
  ------------------
  |  Branch (1795:21): [True: 0, False: 0]
  ------------------
 1796|      0|                        Error("Internal error: previous default should have caught unsupported type");
  ------------------
  |  |  126|      0|#define Error(...) do {savetl_end(); error(__VA_ARGS__);} while(0)
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (126:65): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1797|      0|                    }
 1798|      0|                }
 1799|      0|                i++;
 1800|      0|                push(1);
 1801|      0|                continue;
 1802|      0|            }
 1803|      0|            osub = o+i;
 1804|       |            // ** TO DO **: if isSorted, we can just point xsub
 1805|       |            //        into x directly. If (*f)() returns 0,
 1806|       |            //        though, will have to copy x at that point
 1807|       |            //        When doing this, xsub could be allocated at
 1808|       |            //        that point for the first time.
 1809|      0|            if (TYPEOF(x) == STRSXP)
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1809:17): [True: 0, False: 0]
  ------------------
 1810|      0|                for (int j = 0; j < thisgrpn; j++)
  ------------------
  |  Branch (1810:33): [True: 0, False: 0]
  ------------------
 1811|      0|                    ((SEXP *) xsub)[j] = ((SEXP *) xd)[o[i++] - 1];
 1812|      0|            else if (TYPEOF(x) == REALSXP)
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1812:22): [True: 0, False: 0]
  ------------------
 1813|      0|                for (int j = 0; j < thisgrpn; j++)
  ------------------
  |  Branch (1813:33): [True: 0, False: 0]
  ------------------
 1814|      0|                    ((double *) xsub)[j] = ((double *) xd)[o[i++] - 1];
 1815|      0|            else
 1816|      0|                for (int j = 0; j < thisgrpn; j++)
  ------------------
  |  Branch (1816:33): [True: 0, False: 0]
  ------------------
 1817|      0|                    ((int *) xsub)[j] = ((int *) xd)[o[i++] - 1];
 1818|       |                
 1819|       |            // continue; // BASELINE short circuit timing
 1820|       |            // point. Up to here is the cost of creating xsub.
 1821|       |            // [i|d|c]sorted(); very low cost, sequential
 1822|       |//            tmp = (*f)(xsub, thisgrpn);
 1823|      0|	    switch(fgtype) {
  ------------------
  |  Branch (1823:13): [True: 0, False: 0]
  ------------------
 1824|      0|	    case 1:
  ------------------
  |  Branch (1824:6): [True: 0, False: 0]
  ------------------
 1825|      0|		tmp = isorted(xsub, thisgrpn);
 1826|      0|		break;
 1827|      0|	    case 2:
  ------------------
  |  Branch (1827:6): [True: 0, False: 0]
  ------------------
 1828|      0|		tmp = dsorted(xsub, thisgrpn);
 1829|      0|		break;
 1830|      0|	    case 3:
  ------------------
  |  Branch (1830:6): [True: 0, False: 0]
  ------------------
 1831|      0|	    case 4:
  ------------------
  |  Branch (1831:6): [True: 0, False: 0]
  ------------------
 1832|      0|		tmp = csorted(xsub, thisgrpn);
 1833|      0|	    }
 1834|      0|            if (tmp) {
  ------------------
  |  Branch (1834:17): [True: 0, False: 0]
  ------------------
 1835|       |                // *sorted will have already push()'d the groups
 1836|      0|                if (tmp == -1) {
  ------------------
  |  Branch (1836:21): [True: 0, False: 0]
  ------------------
 1837|      0|		    isSorted = false;
 1838|      0|		    for (int k = 0; k < thisgrpn / 2; k++) {
  ------------------
  |  Branch (1838:23): [True: 0, False: 0]
  ------------------
 1839|       |			// reverse the order in-place using no
 1840|       |			// function call or working memory
 1841|       |			// isorted only returns -1 for
 1842|       |			// _strictly_ decreasing order,
 1843|       |			// otherwise ties wouldn't be stable
 1844|      0|			tmp = osub[k];
 1845|      0|			osub[k] = osub[thisgrpn - 1 - k];
 1846|      0|			osub[thisgrpn - 1 - k] = tmp;
 1847|      0|		    }
 1848|      0|		} else if (nalast == 0 && tmp == -2) {
  ------------------
  |  Branch (1848:14): [True: 0, False: 0]
  |  Branch (1848:29): [True: 0, False: 0]
  ------------------
 1849|       |		    // all NAs, replace osub[.] with 0s.
 1850|      0|		    isSorted = false;
 1851|      0|		    for (int k = 0; k < thisgrpn; k++) osub[k] = 0;
  ------------------
  |  Branch (1851:23): [True: 0, False: 0]
  ------------------
 1852|      0|		}
 1853|      0|		continue;
 1854|      0|	    }
 1855|      0|	    isSorted = false;
 1856|       |	    // nalast=NA will result in newo[0] = 0. So had to change to -1.
 1857|      0|	    newo[0] = -1;
 1858|       |	    // may update osub directly, or if not will put the
 1859|       |	    // result in global newo
 1860|       |//	    (*g)(xsub, osub, thisgrpn);
 1861|      0|	    switch(fgtype) {
  ------------------
  |  Branch (1861:13): [True: 0, False: 0]
  ------------------
 1862|      0|	    case 1: isort(xsub, osub, thisgrpn); break;
  ------------------
  |  Branch (1862:6): [True: 0, False: 0]
  ------------------
 1863|      0|	    case 2: dsort(xsub, osub, thisgrpn); break;
  ------------------
  |  Branch (1863:6): [True: 0, False: 0]
  ------------------
 1864|      0|	    case 3: csort(xsub, osub, thisgrpn); break;
  ------------------
  |  Branch (1864:6): [True: 0, False: 0]
  ------------------
 1865|      0|	    case 4: cgroup(xsub, osub, thisgrpn); break;
  ------------------
  |  Branch (1865:6): [True: 0, False: 0]
  ------------------
 1866|      0|	    }
 1867|      0|	    if (newo[0] != -1) {
  ------------------
  |  Branch (1867:10): [True: 0, False: 0]
  ------------------
 1868|      0|		if (nalast != 0)
  ------------------
  |  Branch (1868:7): [True: 0, False: 0]
  ------------------
 1869|      0|		    for (int j = 0; j < thisgrpn; j++)
  ------------------
  |  Branch (1869:23): [True: 0, False: 0]
  ------------------
 1870|       |			// reuse xsub to reorder osub
 1871|      0|			((int *) xsub)[j] = osub[newo[j] - 1];
 1872|      0|		else
 1873|      0|		    for (int j = 0; j < thisgrpn; j++)
  ------------------
  |  Branch (1873:23): [True: 0, False: 0]
  ------------------
 1874|       |			// final nalast case to handle!
 1875|      0|			((int *) xsub)[j] = (newo[j] == 0) ? 0 :
  ------------------
  |  Branch (1875:24): [True: 0, False: 0]
  ------------------
 1876|      0|			    osub[newo[j] - 1];
 1877|      0|		memcpy(osub, xsub, thisgrpn * sizeof(int));
 1878|      0|	    }
 1879|      0|	}
 1880|      0|    }
 1881|       |
 1882|      2|    if (!sortStr && ustr_n != 0)
  ------------------
  |  Branch (1882:9): [True: 0, False: 2]
  |  Branch (1882:21): [True: 0, False: 0]
  ------------------
 1883|      0|        Error("Internal error: at the end of do_radixsort sortStr == FALSE but ustr_n !=0 [%d]",
  ------------------
  |  |  126|      0|#define Error(...) do {savetl_end(); error(__VA_ARGS__);} while(0)
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (126:65): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1884|      2|              ustr_n);
 1885|      2|    for(int i = 0; i < ustr_n; i++)
  ------------------
  |  Branch (1885:20): [True: 0, False: 2]
  ------------------
 1886|      0|        SET_TRLEN(ustr[i], 0);
  ------------------
  |  |   34|      2|#define SET_TRLEN(x, v) SET_TRUELENGTH(x, ((int) (v)))
  ------------------
 1887|      2|    maxlen = 1;  // reset global. Minimum needed to count "" and NA
 1888|      2|    ustr_n = 0;
 1889|      2|    savetl_end();
 1890|      2|    free(ustr);
 1891|      2|    ustr = NULL;
 1892|      2|    ustr_alloc = 0;
 1893|       |
 1894|      2|    if (retGrp) {
  ------------------
  |  Branch (1894:9): [True: 0, False: 2]
  ------------------
 1895|      0|        int maxgrpn = NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
 1896|      0|        ngrp = gsngrp[flip];
 1897|      0|        SEXP s_ends = install("ends");
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 1898|      0|        setAttrib(ans, s_ends, x = allocVector(INTSXP, ngrp));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
                      setAttrib(ans, s_ends, x = allocVector(INTSXP, ngrp));
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
                      setAttrib(ans, s_ends, x = allocVector(INTSXP, ngrp));
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
 1899|      0|        if (ngrp > 0) {
  ------------------
  |  Branch (1899:13): [True: 0, False: 0]
  ------------------
 1900|      0|            INTEGER(x)[0] = gs[flip][0];
 1901|      0|            for (int i = 1; i < ngrp; i++)
  ------------------
  |  Branch (1901:29): [True: 0, False: 0]
  ------------------
 1902|      0|                INTEGER(x)[i] = INTEGER(x)[i - 1] + gs[flip][i];
 1903|      0|            maxgrpn = gsmax[flip];
 1904|      0|        }
 1905|      0|        SEXP s_maxgrpn = install("maxgrpn");
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 1906|      0|        setAttrib(ans, s_maxgrpn, ScalarInteger(maxgrpn));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
                      setAttrib(ans, s_maxgrpn, ScalarInteger(maxgrpn));
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
 1907|      0|        SEXP nms;
 1908|      0|        PROTECT(nms = allocVector(STRSXP, 2));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1909|      0|        SET_STRING_ELT(nms, 0, mkChar("grouping"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 1910|      0|        SET_STRING_ELT(nms, 1, mkChar("integer"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 1911|      0|        setAttrib(ans, R_ClassSymbol, nms);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 1912|      0|        UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1913|      0|    }
 1914|       |
 1915|      2|    bool dropZeros = !retGrp && !isSorted && nalast == 0;
  ------------------
  |  Branch (1915:22): [True: 2, False: 0]
  |  Branch (1915:33): [True: 0, False: 2]
  |  Branch (1915:46): [True: 0, False: 0]
  ------------------
 1916|      2|    if (dropZeros) {
  ------------------
  |  Branch (1916:9): [True: 0, False: 2]
  ------------------
 1917|      0|        int zeros = 0;
 1918|      0|        for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (1918:25): [True: 0, False: 0]
  ------------------
 1919|      0|            if (o[i] == 0)
  ------------------
  |  Branch (1919:17): [True: 0, False: 0]
  ------------------
 1920|      0|                zeros++;
 1921|      0|        }
 1922|      0|        if (zeros > 0) {
  ------------------
  |  Branch (1922:13): [True: 0, False: 0]
  ------------------
 1923|      0|            PROTECT(ans = allocVector(INTSXP, n - zeros));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1924|      0|            int *o2 = INTEGER(ans);
 1925|      0|            for (int i = 0, i2 = 0; i < n; i++) {
  ------------------
  |  Branch (1925:37): [True: 0, False: 0]
  ------------------
 1926|      0|                if (o[i] > 0)
  ------------------
  |  Branch (1926:21): [True: 0, False: 0]
  ------------------
 1927|      0|                    o2[i2++] = o[i];
 1928|      0|            }
 1929|      0|            UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1930|      0|        }
 1931|      0|    }
 1932|       |    
 1933|      2|    gsfree();
 1934|      2|    free(radix_xsub);          radix_xsub=NULL;    radix_xsuballoc=0;
 1935|      2|    free(xsub); free(newo);    xsub=newo=NULL;
 1936|      2|    free(xtmp);                xtmp=NULL;          xtmp_alloc=0;
 1937|      2|    free(otmp);                otmp=NULL;          otmp_alloc=0;
 1938|      2|    free(csort_otmp);          csort_otmp=NULL;    csort_otmp_alloc=0;
 1939|       |
 1940|      2|    free(cradix_counts);       cradix_counts=NULL; cradix_counts_alloc=0;
 1941|      2|    free(cradix_xtmp);         cradix_xtmp=NULL;   cradix_xtmp_alloc=0;
 1942|       |    // TO DO: use xtmp already got
 1943|       |
 1944|      2|    UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1945|      2|    return ans;
 1946|      2|}
radixsort.c:setNumericRounding:
  625|      2|{
  626|      2|    dmask1 = dround ? 1 << (8 * dround - 1) : 0;
  ------------------
  |  Branch (626:14): [True: 0, False: 2]
  ------------------
  627|      2|    dmask2 = 0xffffffffffffffff << dround * 8;
  628|      2|}
radixsort.c:savetl_init:
   70|      2|{
   71|      2|    if (nsaved || nalloc || saveds || savedtl)
  ------------------
  |  Branch (71:9): [True: 0, False: 2]
  |  Branch (71:19): [True: 0, False: 2]
  |  Branch (71:29): [True: 0, False: 2]
  |  Branch (71:39): [True: 0, False: 2]
  ------------------
   72|      0|	error("Internal error: savetl_init checks failed (%d %d %p %p).",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
   73|      0|	      nsaved, nalloc, (void *)saveds, (void *)savedtl);
   74|      2|    nsaved = 0;
   75|      2|    nalloc = 100;
   76|      2|    saveds = (SEXP *) malloc(nalloc * sizeof(SEXP));
   77|      2|    if (saveds == NULL)
  ------------------
  |  Branch (77:9): [True: 0, False: 2]
  ------------------
   78|      0|	error("Could not allocate saveds in savetl_init");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
   79|      2|    savedtl = (R_len_t *) malloc(nalloc * sizeof(R_len_t));
   80|      2|    if (savedtl == NULL) {
  ------------------
  |  Branch (80:9): [True: 0, False: 2]
  ------------------
   81|      0|	free(saveds);
   82|      0|	error("Could not allocate saveds in savetl_init");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
   83|      0|    }
   84|      2|}
radixsort.c:isorted:
 1281|      2|{
 1282|      2|    int i = 1, j = 0;
 1283|       |    // when nalast = NA,
 1284|       |    // all NAs ? return special value to replace all o's values with '0'
 1285|       |    // any NAs ? return 0 = unsorted and leave it
 1286|       |    //   to sort routines to replace o's with 0's
 1287|       |    // no NAs ? continue to check rest of isorted - the same routine as usual
 1288|      2|    if (nalast == 0) {
  ------------------
  |  Branch (1288:9): [True: 0, False: 2]
  ------------------
 1289|      0|	for (int k = 0; k < n; k++)
  ------------------
  |  Branch (1289:18): [True: 0, False: 0]
  ------------------
 1290|      0|	    if (x[k] != NA_INTEGER)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1290:10): [True: 0, False: 0]
  ------------------
 1291|      0|		j++;
 1292|      0|	if (j == 0) {
  ------------------
  |  Branch (1292:6): [True: 0, False: 0]
  ------------------
 1293|      0|	    push(n);
 1294|      0|	    return (-2);
 1295|      0|	}
 1296|      0|	if (j != n)
  ------------------
  |  Branch (1296:6): [True: 0, False: 0]
  ------------------
 1297|      0|	    return (0);
 1298|      0|    }
 1299|      2|    if (n <= 1) {
  ------------------
  |  Branch (1299:9): [True: 0, False: 2]
  ------------------
 1300|      0|	push(n);
 1301|      0|	return (1);
 1302|      0|    }
 1303|      2|    if (icheck(x[1]) < icheck(x[0])) {
  ------------------
  |  Branch (1303:9): [True: 0, False: 2]
  ------------------
 1304|      0|	i = 2;
 1305|      0|	while (i < n && icheck(x[i]) < icheck(x[i - 1]))
  ------------------
  |  Branch (1305:9): [True: 0, False: 0]
  |  Branch (1305:18): [True: 0, False: 0]
  ------------------
 1306|      0|	    i++;
 1307|       |	// strictly opposite to expected 'order', no ties;
 1308|      0|	if (i == n) {
  ------------------
  |  Branch (1308:6): [True: 0, False: 0]
  ------------------
 1309|      0|	    mpush(1, n);
 1310|      0|	    return (-1);
 1311|      0|	}
 1312|       |	// e.g. no more than one NA at the beginning/end (for order=-1/1)
 1313|      0|	else return (0);
 1314|      0|    }
 1315|      2|    int old = gsngrp[flip];
 1316|      2|    int tt = 1;
 1317|     12|    for (int i = 1; i < n; i++) {
  ------------------
  |  Branch (1317:21): [True: 10, False: 2]
  ------------------
 1318|     10|	if (icheck(x[i]) < icheck(x[i - 1])) {
  ------------------
  |  Branch (1318:6): [True: 0, False: 10]
  ------------------
 1319|      0|	    gsngrp[flip] = old;
 1320|      0|	    return (0);
 1321|      0|	}
 1322|     10|	if (x[i] == x[i - 1])
  ------------------
  |  Branch (1322:6): [True: 10, False: 0]
  ------------------
 1323|     10|	    tt++;
 1324|      0|	else {
 1325|      0|	    push(tt); tt = 1;
 1326|      0|	}
 1327|     10|    }
 1328|      2|    push(tt);
 1329|       |    // same as 'order', NAs at the beginning for order=1, at end for
 1330|       |    // order=-1, possibly with ties
 1331|      2|    return(1);
 1332|      2|}
radixsort.c:icheck:
  245|     24|{
  246|       |    // if nalast == 1, NAs must go last.
  247|     24|    return ((nalast != 1) ? ((x != NA_INTEGER) ? x*order : x) :
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (247:13): [True: 0, False: 24]
  |  Branch (247:30): [True: 0, False: 0]
  ------------------
  248|     24|	    ((x != NA_INTEGER) ? (x*order) - 1 : INT_MAX));
  ------------------
  |  |   56|     24|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (248:7): [True: 24, False: 0]
  ------------------
  249|     24|}
radixsort.c:savetl_end:
   87|      2|{
   88|       |    // Can get called if nothing has been saved yet (nsaved == 0), or
   89|       |    // even if _init() has not been called yet (pointers NULL). Such as
   90|       |    // to clear up before error. Also, it might be that nothing needed
   91|       |    // to be saved anyway.
   92|      2|    for (int i = 0; i < nsaved; i++)
  ------------------
  |  Branch (92:21): [True: 0, False: 2]
  ------------------
   93|      0|	SET_TRLEN(saveds[i], savedtl[i]);
  ------------------
  |  |   34|      0|#define SET_TRLEN(x, v) SET_TRUELENGTH(x, ((int) (v)))
  ------------------
   94|      2|    free(saveds);  // does nothing on NULL input
   95|      2|    free(savedtl);
   96|      2|    nsaved = nalloc = 0;
   97|      2|    saveds = NULL;
   98|       |    savedtl = NULL;
   99|      2|}
radixsort.c:push:
  147|      2|{
  148|      2|    if (!stackgrps || x == 0)
  ------------------
  |  Branch (148:9): [True: 2, False: 0]
  |  Branch (148:23): [True: 0, False: 0]
  ------------------
  149|      2|	return;
  150|      0|    if (gsalloc[flip] == gsngrp[flip])
  ------------------
  |  Branch (150:9): [True: 0, False: 0]
  ------------------
  151|      0|	growstack((uint64_t)(gsngrp[flip]) * 2);
  152|      0|    gs[flip][gsngrp[flip]++] = x;
  153|      0|    if (x > gsmax[flip])
  ------------------
  |  Branch (153:9): [True: 0, False: 0]
  ------------------
  154|      0|	gsmax[flip] = x;
  155|      0|}
radixsort.c:gsfree:
  179|      2|{
  180|      2|    free(gs[0]);
  181|      2|    free(gs[1]);
  182|      2|    gs[0] = NULL;
  183|       |    gs[1] = NULL;
  184|      2|    flip = 0;
  185|      2|    gsalloc[0] = gsalloc[1] = 0;
  186|      2|    gsngrp[0] = gsngrp[1] = 0;
  187|      2|    gsmax[0] = gsmax[1] = 0;
  188|      2|    gsmaxalloc = 0;
  189|      2|}

do_charToRaw:
   31|     43|{
   32|     43|    SEXP ans, x = CAR(args);
   33|     43|    int nc;
   34|       |
   35|     43|    checkArity(op, args);
  ------------------
  |  | 1788|     43|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
   36|     43|    if (!isString(x) || LENGTH(x) == 0)
  ------------------
  |  |  966|     43|#define isString		Rf_isString
  ------------------
  |  Branch (36:9): [True: 0, False: 43]
  |  Branch (36:25): [True: 0, False: 43]
  ------------------
   37|      0|	error(_("argument must be a character vector of length 1"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("argument must be a character vector of length 1"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   38|     43|    if (LENGTH(x) > 1)
  ------------------
  |  Branch (38:9): [True: 0, False: 43]
  ------------------
   39|      0|	warning(_("argument should be a character vector of length 1\nall but the first element will be ignored"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("argument should be a character vector of length 1\nall but the first element will be ignored"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   40|     43|    nc = LENGTH(STRING_ELT(x, 0));
   41|     43|    ans = allocVector(RAWSXP, nc);
  ------------------
  |  |  875|     43|#define allocVector		Rf_allocVector
  ------------------
                  ans = allocVector(RAWSXP, nc);
  ------------------
  |  |  136|     43|#define RAWSXP      24    /* raw bytes */
  ------------------
   42|     43|    if (nc) memcpy(RAW(ans), CHAR(STRING_ELT(x, 0)), nc);
  ------------------
  |  |  203|     43|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (42:9): [True: 43, False: 0]
  ------------------
   43|     43|    return ans;
   44|     43|}

R_init_base:
   94|      2|{
   95|      2|    R_registerRoutines(dll, NULL, callMethods, fortranMethods, NULL);
   96|      2|    R_useDynamicSymbols(dll, FALSE);
   97|      2|    R_forceSymbols(dll, TRUE);
   98|      2|}

do_relop:
   52|     60|{
   53|     60|    SEXP ans, arg1, arg2;
   54|     60|    int argc;
   55|       |
   56|     60|    if (args != R_NilValue &&
  ------------------
  |  Branch (56:9): [True: 60, False: 0]
  ------------------
   57|     60|	CDR(args) != R_NilValue &&
  ------------------
  |  Branch (57:2): [True: 60, False: 0]
  ------------------
   58|     60|	CDDR(args) == R_NilValue)
  ------------------
  |  Branch (58:2): [True: 60, False: 0]
  ------------------
   59|     60|	argc = 2;
   60|      0|    else
   61|      0|	argc = length(args);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
   62|     60|    arg1 = CAR(args);
   63|     60|    arg2 = CADR(args);
   64|       |
   65|     60|    if (ATTRIB(arg1) != R_NilValue || ATTRIB(arg2) != R_NilValue) {
  ------------------
  |  Branch (65:9): [True: 0, False: 60]
  |  Branch (65:39): [True: 0, False: 60]
  ------------------
   66|      0|	if (DispatchGroup("Ops", call, op, args, env, &ans))
  ------------------
  |  | 1886|      0|# define DispatchGroup		Rf_DispatchGroup
  ------------------
  |  Branch (66:6): [True: 0, False: 0]
  ------------------
   67|      0|	    return ans;
   68|      0|    }
   69|       |
   70|     60|    if (argc != 2)
  ------------------
  |  Branch (70:9): [True: 0, False: 60]
  ------------------
   71|      0|	error("operator needs two arguments");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
   72|       |
   73|     60|    return do_relop_dflt(call, op, arg1, arg2);
   74|     60|}
do_relop_dflt:
  200|   773k|{
  201|       |    /* handle the REALSXP/INTSXP simple scalar case quickly */
  202|   773k|    if (IS_SIMPLE_SCALAR(x, INTSXP)) {
  ------------------
  |  |  218|   773k|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (218:6): [True: 44, False: 773k]
  |  |  |  Branch (218:28): [True: 42, False: 2]
  |  |  ------------------
  ------------------
  203|     42|	int ix = SCALAR_IVAL(x);
  204|     42|	if (IS_SIMPLE_SCALAR(y, INTSXP)) {
  ------------------
  |  |  218|     42|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (218:6): [True: 38, False: 4]
  |  |  |  Branch (218:28): [True: 38, False: 0]
  |  |  ------------------
  ------------------
  205|     38|	    int iy = SCALAR_IVAL(y);
  206|     38|	    if (ix == NA_INTEGER || iy == NA_INTEGER)
  ------------------
  |  |   56|     76|#define NA_INTEGER	R_NaInt
  ------------------
              	    if (ix == NA_INTEGER || iy == NA_INTEGER)
  ------------------
  |  |   56|     38|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (206:10): [True: 0, False: 38]
  |  Branch (206:30): [True: 0, False: 38]
  ------------------
  207|      0|		return ScalarLogical(NA_LOGICAL);
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
              		return ScalarLogical(NA_LOGICAL);
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  208|     38|	    DO_SCALAR_RELOP(PRIMVAL(op), ix, iy);
  ------------------
  |  |   40|     38|#define DO_SCALAR_RELOP(oper, x, y) do {		\
  |  |   41|     38|	switch (oper) {					\
  |  |  ------------------
  |  |  |  Branch (41:10): [True: 38, False: 0]
  |  |  ------------------
  |  |   42|      0|	case EQOP: return ScalarLogical((x) == (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (42:2): [True: 0, False: 38]
  |  |  ------------------
  |  |   43|      0|	case NEOP: return ScalarLogical((x) != (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (43:2): [True: 0, False: 38]
  |  |  ------------------
  |  |   44|     26|	case LTOP: return ScalarLogical((x) < (y));	\
  |  |  ------------------
  |  |  |  | 1023|     26|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (44:2): [True: 26, False: 12]
  |  |  ------------------
  |  |   45|     12|	case GTOP: return ScalarLogical((x) > (y));	\
  |  |  ------------------
  |  |  |  | 1023|     12|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (45:2): [True: 12, False: 26]
  |  |  ------------------
  |  |   46|      0|	case LEOP: return ScalarLogical((x) <= (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (46:2): [True: 0, False: 38]
  |  |  ------------------
  |  |   47|      0|	case GEOP: return ScalarLogical((x) >= (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (47:2): [True: 0, False: 38]
  |  |  ------------------
  |  |   48|     38|	}						\
  |  |   49|     38|    } while (0)
  |  |  ------------------
  |  |  |  Branch (49:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  209|     38|	}
  210|      4|	else if (IS_SIMPLE_SCALAR(y, REALSXP)) {
  ------------------
  |  |  218|      4|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (218:6): [True: 4, False: 0]
  |  |  |  Branch (218:28): [True: 4, False: 0]
  |  |  ------------------
  ------------------
  211|      4|	    double dy = SCALAR_DVAL(y);
  212|      4|	    if (ix == NA_INTEGER || ISNAN(dy))
  ------------------
  |  |   56|      8|#define NA_INTEGER	R_NaInt
  ------------------
              	    if (ix == NA_INTEGER || ISNAN(dy))
  ------------------
  |  |   76|      4|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 4]
  |  |  ------------------
  ------------------
  |  Branch (212:10): [True: 0, False: 4]
  ------------------
  213|      0|		return ScalarLogical(NA_LOGICAL);
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
              		return ScalarLogical(NA_LOGICAL);
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  214|      4|	    DO_SCALAR_RELOP(PRIMVAL(op), ix, dy);
  ------------------
  |  |   40|      4|#define DO_SCALAR_RELOP(oper, x, y) do {		\
  |  |   41|      4|	switch (oper) {					\
  |  |  ------------------
  |  |  |  Branch (41:10): [True: 4, False: 0]
  |  |  ------------------
  |  |   42|      2|	case EQOP: return ScalarLogical((x) == (y));	\
  |  |  ------------------
  |  |  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (42:2): [True: 2, False: 2]
  |  |  ------------------
  |  |   43|      0|	case NEOP: return ScalarLogical((x) != (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (43:2): [True: 0, False: 4]
  |  |  ------------------
  |  |   44|      0|	case LTOP: return ScalarLogical((x) < (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (44:2): [True: 0, False: 4]
  |  |  ------------------
  |  |   45|      0|	case GTOP: return ScalarLogical((x) > (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (45:2): [True: 0, False: 4]
  |  |  ------------------
  |  |   46|      2|	case LEOP: return ScalarLogical((x) <= (y));	\
  |  |  ------------------
  |  |  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (46:2): [True: 2, False: 2]
  |  |  ------------------
  |  |   47|      0|	case GEOP: return ScalarLogical((x) >= (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (47:2): [True: 0, False: 4]
  |  |  ------------------
  |  |   48|      4|	}						\
  |  |   49|      4|    } while (0)
  |  |  ------------------
  |  |  |  Branch (49:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  215|      4|	}
  216|     42|    }
  217|   773k|    else if (IS_SIMPLE_SCALAR(x, REALSXP)) {
  ------------------
  |  |  218|   773k|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (218:6): [True: 0, False: 773k]
  |  |  |  Branch (218:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  218|      0|	double dx = SCALAR_DVAL(x);
  219|      0|	if (IS_SIMPLE_SCALAR(y, INTSXP)) {
  ------------------
  |  |  218|      0|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (218:6): [True: 0, False: 0]
  |  |  |  Branch (218:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  220|      0|	    int iy = SCALAR_IVAL(y);
  221|      0|	    if (ISNAN(dx) || iy == NA_INTEGER)
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	    if (ISNAN(dx) || iy == NA_INTEGER)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (221:23): [True: 0, False: 0]
  ------------------
  222|      0|		return ScalarLogical(NA_LOGICAL);
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
              		return ScalarLogical(NA_LOGICAL);
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  223|      0|	    DO_SCALAR_RELOP(PRIMVAL(op), dx, iy);
  ------------------
  |  |   40|      0|#define DO_SCALAR_RELOP(oper, x, y) do {		\
  |  |   41|      0|	switch (oper) {					\
  |  |  ------------------
  |  |  |  Branch (41:10): [True: 0, False: 0]
  |  |  ------------------
  |  |   42|      0|	case EQOP: return ScalarLogical((x) == (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (42:2): [True: 0, False: 0]
  |  |  ------------------
  |  |   43|      0|	case NEOP: return ScalarLogical((x) != (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (43:2): [True: 0, False: 0]
  |  |  ------------------
  |  |   44|      0|	case LTOP: return ScalarLogical((x) < (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (44:2): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|	case GTOP: return ScalarLogical((x) > (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (45:2): [True: 0, False: 0]
  |  |  ------------------
  |  |   46|      0|	case LEOP: return ScalarLogical((x) <= (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (46:2): [True: 0, False: 0]
  |  |  ------------------
  |  |   47|      0|	case GEOP: return ScalarLogical((x) >= (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (47:2): [True: 0, False: 0]
  |  |  ------------------
  |  |   48|      0|	}						\
  |  |   49|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (49:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  224|      0|	}
  225|      0|	else if (IS_SIMPLE_SCALAR(y, REALSXP)) {
  ------------------
  |  |  218|      0|    (IS_SCALAR(x, type) && ATTRIB(x) == R_NilValue)
  |  |  ------------------
  |  |  |  Branch (218:6): [True: 0, False: 0]
  |  |  |  Branch (218:28): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  226|      0|	    double dy = SCALAR_DVAL(y);
  227|      0|	    if (ISNAN(dx) || ISNAN(dy))
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	    if (ISNAN(dx) || ISNAN(dy))
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  228|      0|		return ScalarLogical(NA_LOGICAL);
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
              		return ScalarLogical(NA_LOGICAL);
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  229|      0|	    DO_SCALAR_RELOP(PRIMVAL(op), dx, dy);
  ------------------
  |  |   40|      0|#define DO_SCALAR_RELOP(oper, x, y) do {		\
  |  |   41|      0|	switch (oper) {					\
  |  |  ------------------
  |  |  |  Branch (41:10): [True: 0, False: 0]
  |  |  ------------------
  |  |   42|      0|	case EQOP: return ScalarLogical((x) == (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (42:2): [True: 0, False: 0]
  |  |  ------------------
  |  |   43|      0|	case NEOP: return ScalarLogical((x) != (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (43:2): [True: 0, False: 0]
  |  |  ------------------
  |  |   44|      0|	case LTOP: return ScalarLogical((x) < (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (44:2): [True: 0, False: 0]
  |  |  ------------------
  |  |   45|      0|	case GTOP: return ScalarLogical((x) > (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (45:2): [True: 0, False: 0]
  |  |  ------------------
  |  |   46|      0|	case LEOP: return ScalarLogical((x) <= (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (46:2): [True: 0, False: 0]
  |  |  ------------------
  |  |   47|      0|	case GEOP: return ScalarLogical((x) >= (y));	\
  |  |  ------------------
  |  |  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  |  |  ------------------
  |  |  |  Branch (47:2): [True: 0, False: 0]
  |  |  ------------------
  |  |   48|      0|	}						\
  |  |   49|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (49:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  230|      0|	}
  231|      0|    }
  232|       |
  233|   773k|    R_xlen_t
  234|   773k|	nx = xlength(x),
  ------------------
  |  | 1049|   773k|#define xlength(x)		Rf_xlength(x)
  ------------------
  235|   773k|	ny = xlength(y);
  ------------------
  |  | 1049|   773k|#define xlength(x)		Rf_xlength(x)
  ------------------
  236|   773k|    SEXPTYPE
  237|   773k|	typex = TYPEOF(x),
  238|   773k|	typey = TYPEOF(y);
  239|       |
  240|       |    /* handle the REALSXP/INTSXP simple vector/scalar case quickly. */
  241|   773k|    if (ATTRIB(x) == R_NilValue && ATTRIB(y) == R_NilValue &&
  ------------------
  |  Branch (241:9): [True: 773k, False: 30]
  |  Branch (241:36): [True: 773k, False: 0]
  ------------------
  242|   773k|	(typex == REALSXP || typex == INTSXP) &&
  ------------------
  |  |  124|  1.54M|#define REALSXP	    14	  /* real variables */
  ------------------
              	(typex == REALSXP || typex == INTSXP) &&
  ------------------
  |  |  123|   773k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (242:3): [True: 0, False: 773k]
  |  Branch (242:23): [True: 316, False: 773k]
  ------------------
  243|    316|	(typey == REALSXP || typey == INTSXP) &&
  ------------------
  |  |  124|    632|#define REALSXP	    14	  /* real variables */
  ------------------
              	(typey == REALSXP || typey == INTSXP) &&
  ------------------
  |  |  123|    316|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (243:3): [True: 0, False: 316]
  |  Branch (243:23): [True: 316, False: 0]
  ------------------
  244|    316|	nx > 0 && ny > 0 && (nx == 1 || ny == 1)) {
  ------------------
  |  Branch (244:2): [True: 274, False: 42]
  |  Branch (244:12): [True: 274, False: 0]
  |  Branch (244:23): [True: 0, False: 274]
  |  Branch (244:34): [True: 274, False: 0]
  ------------------
  245|       |
  246|    274|	PROTECT(x);
  ------------------
  |  |  357|    274|#define PROTECT(s)	Rf_protect(s)
  ------------------
  247|    274|	PROTECT(y);
  ------------------
  |  |  357|    274|#define PROTECT(s)	Rf_protect(s)
  ------------------
  248|    274|	SEXP ans;
  249|    274|	ans = numeric_relop(PRIMVAL(op), x, y);
  ------------------
  |  | 1347|    274|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  250|    274|	UNPROTECT(2);
  ------------------
  |  |  358|    274|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  251|    274|	return ans;
  252|    274|    }
  253|       |
  254|       |    /* handle the general case */
  255|   773k|    PROTECT_INDEX xpi, ypi;
  256|   773k|    PROTECT_WITH_INDEX(x, &xpi);
  ------------------
  |  |  366|   773k|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
  257|   773k|    PROTECT_WITH_INDEX(y, &ypi);
  ------------------
  |  |  366|   773k|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
  258|       |
  259|   773k|    if (isSymbol(x) || TYPEOF(x) == LANGSXP ||
  ------------------
  |  |  953|   773k|#define isSymbol		Rf_isSymbol
  ------------------
                  if (isSymbol(x) || TYPEOF(x) == LANGSXP ||
  ------------------
  |  |  117|  1.54M|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (259:9): [True: 0, False: 773k]
  |  Branch (259:24): [True: 0, False: 773k]
  ------------------
  260|   773k|	isSymbol(y) || TYPEOF(y) == LANGSXP) {
  ------------------
  |  |  953|   773k|#define isSymbol		Rf_isSymbol
  ------------------
              	isSymbol(y) || TYPEOF(y) == LANGSXP) {
  ------------------
  |  |  117|   773k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (260:2): [True: 0, False: 773k]
  |  Branch (260:17): [True: 0, False: 773k]
  ------------------
  261|      0|	SEXP ans = compute_language_relop(call, op, x, y);
  262|      0|	if (ans != NULL) {
  ------------------
  |  Branch (262:6): [True: 0, False: 0]
  ------------------
  263|      0|	    UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  264|      0|	    return ans;
  265|      0|	}
  266|      0|    }
  267|       |
  268|   773k|    bool iS;
  269|       |    /* That symbols and calls were allowed was undocumented prior to
  270|       |       R 2.5.0.  We deparse them as deparse() would, minus attributes */
  271|   773k|    if ((iS = isSymbol(x)) || TYPEOF(x) == LANGSXP) {
  ------------------
  |  |  953|   773k|#define isSymbol		Rf_isSymbol
  ------------------
                  if ((iS = isSymbol(x)) || TYPEOF(x) == LANGSXP) {
  ------------------
  |  |  117|   773k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (271:9): [True: 0, False: 773k]
  |  Branch (271:31): [True: 0, False: 773k]
  ------------------
  272|      0|	SEXP tmp = allocVector(STRSXP, 1);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	SEXP tmp = allocVector(STRSXP, 1);
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  273|      0|	PROTECT(tmp);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  274|      0|	SET_STRING_ELT(tmp, 0, (iS) ? PRINTNAME(x) :
  ------------------
  |  Branch (274:25): [True: 0, False: 0]
  ------------------
  275|      0|		       STRING_ELT(deparse1line_ex(x, false,
  276|      0|						  DEFAULTDEPARSE | DIGITS17),
  ------------------
  |  | 2081|      0|#define DEFAULTDEPARSE		1089 /* KEEPINTEGER | KEEPNA | NICE_NAMES, used for calls */
  ------------------
              						  DEFAULTDEPARSE | DIGITS17),
  ------------------
  |  | 2077|      0|#define DIGITS17		512
  ------------------
  277|      0|				  0));
  278|      0|	REPROTECT(x = tmp, xpi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  279|      0|	nx = xlength(x);
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
  280|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  281|      0|    }
  282|   773k|    if ((iS = isSymbol(y)) || TYPEOF(y) == LANGSXP) {
  ------------------
  |  |  953|   773k|#define isSymbol		Rf_isSymbol
  ------------------
                  if ((iS = isSymbol(y)) || TYPEOF(y) == LANGSXP) {
  ------------------
  |  |  117|   773k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (282:9): [True: 0, False: 773k]
  |  Branch (282:31): [True: 0, False: 773k]
  ------------------
  283|      0|	SEXP tmp = allocVector(STRSXP, 1);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	SEXP tmp = allocVector(STRSXP, 1);
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  284|      0|	PROTECT(tmp);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  285|      0|	SET_STRING_ELT(tmp, 0, (iS) ? PRINTNAME(y) :
  ------------------
  |  Branch (285:25): [True: 0, False: 0]
  ------------------
  286|      0|		       STRING_ELT(deparse1line_ex(y, false,
  287|      0|						  DEFAULTDEPARSE | DIGITS17),
  ------------------
  |  | 2081|      0|#define DEFAULTDEPARSE		1089 /* KEEPINTEGER | KEEPNA | NICE_NAMES, used for calls */
  ------------------
              						  DEFAULTDEPARSE | DIGITS17),
  ------------------
  |  | 2077|      0|#define DIGITS17		512
  ------------------
  288|      0|				  0));
  289|      0|	REPROTECT(y = tmp, ypi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  290|      0|	ny = xlength(y);
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
  291|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  292|      0|    }
  293|       |
  294|   773k|    if (isNull(x)) REPROTECT(x = allocVector(INTSXP,0), xpi);
  ------------------
  |  |  956|   773k|#define isNull			Rf_isNull
  ------------------
                  if (isNull(x)) REPROTECT(x = allocVector(INTSXP,0), xpi);
  ------------------
  |  |  367|     42|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  |  Branch (294:9): [True: 42, False: 773k]
  ------------------
  295|   773k|    if (isNull(y)) REPROTECT(y = allocVector(INTSXP,0), ypi);
  ------------------
  |  |  956|   773k|#define isNull			Rf_isNull
  ------------------
                  if (isNull(y)) REPROTECT(y = allocVector(INTSXP,0), ypi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  |  Branch (295:9): [True: 0, False: 773k]
  ------------------
  296|   773k|    if (!isVector(x) || !isVector(y))
  ------------------
  |  |  974|   773k|#define isVector		Rf_isVector
  ------------------
                  if (!isVector(x) || !isVector(y))
  ------------------
  |  |  974|   773k|#define isVector		Rf_isVector
  ------------------
  |  Branch (296:9): [True: 0, False: 773k]
  |  Branch (296:25): [True: 0, False: 773k]
  ------------------
  297|      0|	errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  298|      0|		  _("comparison (%s) is possible only for atomic and list types"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  299|      0|		  PRIMNAME(op));
  ------------------
  |  | 1346|      0|#define PRIMNAME(x)	(R_FunTab[PRIMOFFSET(x)].name)
  ------------------
  300|       |
  301|       |#ifdef previous_R_versions
  302|       |    if (TYPEOF(x) == EXPRSXP || TYPEOF(y) == EXPRSXP)
  303|       |	errorcall(call, _("comparison is not allowed for expressions"));
  304|       |#endif
  305|       |
  306|       |    /* ELSE :  x and y are both atomic or list */
  307|       |
  308|   773k|    bool
  309|   773k|	xarray = isArray(x),
  ------------------
  |  |  940|   773k|#define isArray			Rf_isArray
  ------------------
  310|   773k|	yarray = isArray(y),
  ------------------
  |  |  940|   773k|#define isArray			Rf_isArray
  ------------------
  311|   773k|	xts = isTs(x),
  ------------------
  |  |  967|   773k|#define isTs			Rf_isTs
  ------------------
  312|   773k|	yts = isTs(y);
  ------------------
  |  |  967|   773k|#define isTs			Rf_isTs
  ------------------
  313|   773k|    SEXP dims, xnames, ynames;
  314|   773k|    if (xarray || yarray) {
  ------------------
  |  Branch (314:9): [True: 0, False: 773k]
  |  Branch (314:19): [True: 0, False: 773k]
  ------------------
  315|      0|	if (xarray && yarray) {
  ------------------
  |  Branch (315:6): [True: 0, False: 0]
  |  Branch (315:16): [True: 0, False: 0]
  ------------------
  316|      0|	    if (!conformable(x, y))
  ------------------
  |  |  896|      0|#define conformable		Rf_conformable
  ------------------
  |  Branch (316:10): [True: 0, False: 0]
  ------------------
  317|      0|		errorcall(call, _("non-conformable arrays"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		errorcall(call, _("non-conformable arrays"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  318|      0|	    PROTECT(dims = getAttrib(x, R_DimSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  319|      0|	}
  320|      0|	else if (xarray && (ny != 0 || nx == 0)) {
  ------------------
  |  Branch (320:11): [True: 0, False: 0]
  |  Branch (320:22): [True: 0, False: 0]
  |  Branch (320:33): [True: 0, False: 0]
  ------------------
  321|      0|	    PROTECT(dims = getAttrib(x, R_DimSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  322|      0|	}
  323|      0|	else if (yarray && (nx != 0 || ny == 0)) {
  ------------------
  |  Branch (323:11): [True: 0, False: 0]
  |  Branch (323:22): [True: 0, False: 0]
  |  Branch (323:33): [True: 0, False: 0]
  ------------------
  324|      0|	    PROTECT(dims = getAttrib(y, R_DimSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  325|      0|	} else
  326|      0|	    PROTECT(dims = R_NilValue);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  327|       |
  328|      0|	PROTECT(xnames = getAttrib(x, R_DimNamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  329|      0|	PROTECT(ynames = getAttrib(y, R_DimNamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  330|      0|    }
  331|   773k|    else {
  332|   773k|	PROTECT(dims = R_NilValue);
  ------------------
  |  |  357|   773k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  333|   773k|	PROTECT(xnames = getAttrib(x, R_NamesSymbol));
  ------------------
  |  |  357|   773k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  334|   773k|	PROTECT(ynames = getAttrib(y, R_NamesSymbol));
  ------------------
  |  |  357|   773k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  335|   773k|    }
  336|       |
  337|   773k|    SEXP klass = NULL, tsp = NULL; // -Wall
  338|   773k|    if (xts || yts) {
  ------------------
  |  Branch (338:9): [True: 0, False: 773k]
  |  Branch (338:16): [True: 0, False: 773k]
  ------------------
  339|      0|	if (xts && yts) {
  ------------------
  |  Branch (339:6): [True: 0, False: 0]
  |  Branch (339:13): [True: 0, False: 0]
  ------------------
  340|       |	    /* could check ts conformance here */
  341|      0|	    PROTECT(tsp = getAttrib(x, R_TspSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  342|      0|	    PROTECT(klass = getAttrib(x, R_ClassSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  343|      0|	}
  344|      0|	else if (xts) {
  ------------------
  |  Branch (344:11): [True: 0, False: 0]
  ------------------
  345|      0|	    if (xlength(x) < xlength(y))
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
              	    if (xlength(x) < xlength(y))
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (345:10): [True: 0, False: 0]
  ------------------
  346|      0|		ErrorMessage(call, ERROR_TSVEC_MISMATCH);
  ------------------
  |  | 1897|      0|# define ErrorMessage		Rf_ErrorMessage
  ------------------
  347|      0|	    PROTECT(tsp = getAttrib(x, R_TspSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  348|      0|	    PROTECT(klass = getAttrib(x, R_ClassSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  349|      0|	}
  350|      0|	else /*(yts)*/ {
  351|      0|	    if (xlength(y) < xlength(x))
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
              	    if (xlength(y) < xlength(x))
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (351:10): [True: 0, False: 0]
  ------------------
  352|      0|		ErrorMessage(call, ERROR_TSVEC_MISMATCH);
  ------------------
  |  | 1897|      0|# define ErrorMessage		Rf_ErrorMessage
  ------------------
  353|      0|	    PROTECT(tsp = getAttrib(y, R_TspSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  354|      0|	    PROTECT(klass = getAttrib(y, R_ClassSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  355|      0|	}
  356|      0|    }
  357|       |
  358|   773k|  if (nx > 0 && ny > 0) {
  ------------------
  |  Branch (358:7): [True: 773k, False: 98]
  |  Branch (358:17): [True: 773k, False: 0]
  ------------------
  359|   773k|	if(((nx > ny) ? nx % ny : ny % nx) != 0) // mismatch
  ------------------
  |  Branch (359:5): [True: 0, False: 773k]
  |  Branch (359:6): [True: 385k, False: 387k]
  ------------------
  360|      0|            warningcall(call, _(
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
                          warningcall(call, _(
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  361|      0|		"longer object length is not a multiple of shorter object length"));
  362|       |
  363|   773k|    if (isString(x) || isString(y)) {
  ------------------
  |  |  966|   773k|#define isString		Rf_isString
  ------------------
                  if (isString(x) || isString(y)) {
  ------------------
  |  |  966|     20|#define isString		Rf_isString
  ------------------
  |  Branch (363:9): [True: 773k, False: 20]
  |  Branch (363:24): [True: 0, False: 20]
  ------------------
  364|   773k|	REPROTECT(x = coerceVector(x, STRSXP), xpi);
  ------------------
  |  |  367|   773k|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  365|   773k|	REPROTECT(y = coerceVector(y, STRSXP), ypi);
  ------------------
  |  |  367|   773k|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  366|   773k|	x = string_relop((RELOP_TYPE) PRIMVAL(op), x, y);
  ------------------
  |  | 1347|   773k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  367|   773k|    }
  368|     20|    else if (isComplex(x) || isComplex(y)) {
  ------------------
  |  |  942|     20|#define isComplex		Rf_isComplex
  ------------------
                  else if (isComplex(x) || isComplex(y)) {
  ------------------
  |  |  942|     20|#define isComplex		Rf_isComplex
  ------------------
  |  Branch (368:14): [True: 0, False: 20]
  |  Branch (368:30): [True: 0, False: 20]
  ------------------
  369|      0|	REPROTECT(x = coerceVector(x, CPLXSXP), xpi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  370|      0|	REPROTECT(y = coerceVector(y, CPLXSXP), ypi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  371|      0|	x = complex_relop((RELOP_TYPE) PRIMVAL(op), x, y, call);
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  372|      0|    }
  373|     20|    else if ((isNumeric(x) || isLogical(x)) && (isNumeric(y) || isLogical(y))) {
  ------------------
  |  |  957|     20|#define isNumeric		Rf_isNumeric
  ------------------
                  else if ((isNumeric(x) || isLogical(x)) && (isNumeric(y) || isLogical(y))) {
  ------------------
  |  |  952|      0|#define isLogical		Rf_isLogical
  ------------------
                  else if ((isNumeric(x) || isLogical(x)) && (isNumeric(y) || isLogical(y))) {
  ------------------
  |  |  957|     20|#define isNumeric		Rf_isNumeric
  ------------------
                  else if ((isNumeric(x) || isLogical(x)) && (isNumeric(y) || isLogical(y))) {
  ------------------
  |  |  952|      0|#define isLogical		Rf_isLogical
  ------------------
  |  Branch (373:15): [True: 20, False: 0]
  |  Branch (373:31): [True: 0, False: 0]
  |  Branch (373:49): [True: 20, False: 0]
  |  Branch (373:65): [True: 0, False: 0]
  ------------------
  374|     20|        x = numeric_relop((RELOP_TYPE) PRIMVAL(op), x, y);
  ------------------
  |  | 1347|     20|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  375|     20|    } // rest of cases only apply when 'x' or 'y' is raw
  376|      0|    else if (isReal(x) || isReal(y)) {
  ------------------
  |  |  963|      0|#define isReal			Rf_isReal
  ------------------
                  else if (isReal(x) || isReal(y)) {
  ------------------
  |  |  963|      0|#define isReal			Rf_isReal
  ------------------
  |  Branch (376:14): [True: 0, False: 0]
  |  Branch (376:27): [True: 0, False: 0]
  ------------------
  377|      0|	REPROTECT(x = coerceVector(x, REALSXP), xpi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  378|      0|	REPROTECT(y = coerceVector(y, REALSXP), ypi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  379|      0|	x = numeric_relop((RELOP_TYPE) PRIMVAL(op), x, y);
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  380|      0|    }
  381|      0|    else if (isInteger(x) || isInteger(y)) {
  ------------------
  |  |  949|      0|#define isInteger		Rf_isInteger
  ------------------
                  else if (isInteger(x) || isInteger(y)) {
  ------------------
  |  |  949|      0|#define isInteger		Rf_isInteger
  ------------------
  |  Branch (381:14): [True: 0, False: 0]
  |  Branch (381:30): [True: 0, False: 0]
  ------------------
  382|      0|	REPROTECT(x = coerceVector(x, INTSXP), xpi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  383|      0|	REPROTECT(y = coerceVector(y, INTSXP), ypi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  384|      0|	x = numeric_relop((RELOP_TYPE) PRIMVAL(op), x, y);
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  385|      0|    }
  386|      0|    else if (isLogical(x) || isLogical(y)) {
  ------------------
  |  |  952|      0|#define isLogical		Rf_isLogical
  ------------------
                  else if (isLogical(x) || isLogical(y)) {
  ------------------
  |  |  952|      0|#define isLogical		Rf_isLogical
  ------------------
  |  Branch (386:14): [True: 0, False: 0]
  |  Branch (386:30): [True: 0, False: 0]
  ------------------
  387|      0|	REPROTECT(x = coerceVector(x, LGLSXP), xpi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  388|      0|	REPROTECT(y = coerceVector(y, LGLSXP), ypi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  389|      0|	x = numeric_relop((RELOP_TYPE) PRIMVAL(op), x, y);
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  390|      0|    }
  391|      0|    else if (TYPEOF(x) == RAWSXP || TYPEOF(y) == RAWSXP) {
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
                  else if (TYPEOF(x) == RAWSXP || TYPEOF(y) == RAWSXP) {
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (391:14): [True: 0, False: 0]
  |  Branch (391:37): [True: 0, False: 0]
  ------------------
  392|      0|	REPROTECT(x = coerceVector(x, RAWSXP), xpi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  393|      0|	REPROTECT(y = coerceVector(y, RAWSXP), ypi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
  394|      0|	x = raw_relop((RELOP_TYPE) PRIMVAL(op), x, y);
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  395|      0|    } else errorcall(call, _("comparison of these types is not implemented"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
                  } else errorcall(call, _("comparison of these types is not implemented"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  396|   773k|  } else { // nx == 0 || ny == 0
  397|     98|	x = allocVector(LGLSXP, 0);
  ------------------
  |  |  875|     98|#define allocVector		Rf_allocVector
  ------------------
              	x = allocVector(LGLSXP, 0);
  ------------------
  |  |  121|     98|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  398|     98|  }
  399|       |
  400|   773k|    PROTECT(x);
  ------------------
  |  |  357|   773k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  401|   773k|    if (dims != R_NilValue) {
  ------------------
  |  Branch (401:9): [True: 0, False: 773k]
  ------------------
  402|      0|	setAttrib(x, R_DimSymbol, dims);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  403|      0|	if (xnames != R_NilValue)
  ------------------
  |  Branch (403:6): [True: 0, False: 0]
  ------------------
  404|      0|	    setAttrib(x, R_DimNamesSymbol, xnames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  405|      0|	else if (ynames != R_NilValue)
  ------------------
  |  Branch (405:11): [True: 0, False: 0]
  ------------------
  406|      0|	    setAttrib(x, R_DimNamesSymbol, ynames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  407|      0|    }
  408|   773k|    else {
  409|   773k|	if (xnames != R_NilValue && xlength(x) == xlength(xnames))
  ------------------
  |  | 1049|     30|#define xlength(x)		Rf_xlength(x)
  ------------------
              	if (xnames != R_NilValue && xlength(x) == xlength(xnames))
  ------------------
  |  | 1049|     30|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (409:6): [True: 30, False: 773k]
  |  Branch (409:30): [True: 30, False: 0]
  ------------------
  410|     30|	    setAttrib(x, R_NamesSymbol, xnames);
  ------------------
  |  | 1027|     30|#define setAttrib		Rf_setAttrib
  ------------------
  411|   773k|	else if (ynames != R_NilValue && xlength(x) == xlength(ynames))
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
              	else if (ynames != R_NilValue && xlength(x) == xlength(ynames))
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (411:11): [True: 0, False: 773k]
  |  Branch (411:35): [True: 0, False: 0]
  ------------------
  412|      0|	    setAttrib(x, R_NamesSymbol, ynames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  413|   773k|    }
  414|   773k|    if (xts || yts) {
  ------------------
  |  Branch (414:9): [True: 0, False: 773k]
  |  Branch (414:16): [True: 0, False: 773k]
  ------------------
  415|      0|	setAttrib(x, R_TspSymbol, tsp);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  416|      0|	setAttrib(x, R_ClassSymbol, klass);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  417|      0|	UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  418|      0|    }
  419|       |
  420|   773k|    UNPROTECT(6);
  ------------------
  |  |  358|   773k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  421|   773k|    return x;
  422|   773k|}
relop.c:numeric_relop:
  464|    294|{
  465|    294|    R_xlen_t i, i1, i2, n, n1, n2;
  466|    294|    SEXP ans;
  467|       |
  468|    294|    n1 = XLENGTH(s1);
  469|    294|    n2 = XLENGTH(s2);
  470|    294|    n = (n1 > n2) ? n1 : n2;
  ------------------
  |  Branch (470:9): [True: 292, False: 2]
  ------------------
  471|    294|    PROTECT(s1);
  ------------------
  |  |  357|    294|#define PROTECT(s)	Rf_protect(s)
  ------------------
  472|    294|    PROTECT(s2);
  ------------------
  |  |  357|    294|#define PROTECT(s)	Rf_protect(s)
  ------------------
  473|    294|    ans = allocVector(LGLSXP, n);
  ------------------
  |  |  875|    294|#define allocVector		Rf_allocVector
  ------------------
                  ans = allocVector(LGLSXP, n);
  ------------------
  |  |  121|    294|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  474|       |
  475|    294|    if (isInteger(s1) || isLogical(s1)) {
  ------------------
  |  |  949|    294|#define isInteger		Rf_isInteger
  ------------------
                  if (isInteger(s1) || isLogical(s1)) {
  ------------------
  |  |  952|      0|#define isLogical		Rf_isLogical
  ------------------
  |  Branch (475:9): [True: 294, False: 0]
  |  Branch (475:26): [True: 0, False: 0]
  ------------------
  476|    294|        if (isInteger(s2) || isLogical(s2)) {
  ------------------
  |  |  949|    294|#define isInteger		Rf_isInteger
  ------------------
                      if (isInteger(s2) || isLogical(s2)) {
  ------------------
  |  |  952|      0|#define isLogical		Rf_isLogical
  ------------------
  |  Branch (476:13): [True: 294, False: 0]
  |  Branch (476:30): [True: 0, False: 0]
  ------------------
  477|    294|            NUMERIC_RELOP(int, INTEGER, ISNA_INT, int, INTEGER, ISNA_INT);
  ------------------
  |  |  440|    294|#define NUMERIC_RELOP(type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  441|    294|    switch (code) {                                                     \
  |  |  ------------------
  |  |  |  Branch (441:13): [True: 294, False: 0]
  |  |  ------------------
  |  |  442|    137|    case EQOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (442:5): [True: 137, False: 157]
  |  |  ------------------
  |  |  443|    137|	NR_HELPER(==, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|    137|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|    137|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|    137|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|    137|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|    137|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|    137|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|    137|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|    137|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|    137|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|  1.96k|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 1.83k, False: 137]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|  1.83k|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 137, False: 1.69k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|  1.83k|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 1.83k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|  1.83k|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|  7.32k|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 1.83k]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 1.83k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|  1.83k|		}							\
  |  |  |  |  |  |  |  |   85|    137|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 137]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|    137|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 137]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|    137|	    x1 = px1[i1];						\
  |  |  |  |  432|    137|	    x2 = px2[i2];						\
  |  |  |  |  433|    137|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|    137|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|    137|            else                                                        \
  |  |  |  |  436|    137|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|    137|        });                                                             \
  |  |  |  |  438|    137|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 137]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  444|    137|        break;                                                          \
  |  |  445|     20|    case NEOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (445:5): [True: 20, False: 274]
  |  |  ------------------
  |  |  446|     20|	NR_HELPER(!=, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|     20|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|     20|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|     20|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|     20|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|     20|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|     20|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|     20|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|     20|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|     20|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|  3.09k|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 3.07k, False: 20]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|  3.07k|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 20, False: 3.05k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|  3.07k|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 3.07k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|  3.07k|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|  12.2k|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 3.07k]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 3.07k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|  3.07k|		}							\
  |  |  |  |  |  |  |  |   85|     20|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 20]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|     20|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 20]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|     20|	    x1 = px1[i1];						\
  |  |  |  |  432|     20|	    x2 = px2[i2];						\
  |  |  |  |  433|     20|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|     20|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|     20|            else                                                        \
  |  |  |  |  436|     20|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|     20|        });                                                             \
  |  |  |  |  438|     20|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 20]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  447|     20|        break;                                                          \
  |  |  448|      0|    case LTOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (448:5): [True: 0, False: 294]
  |  |  ------------------
  |  |  449|      0|	NR_HELPER(<, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  450|      0|        break;                                                          \
  |  |  451|    129|    case GTOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (451:5): [True: 129, False: 165]
  |  |  ------------------
  |  |  452|    129|	NR_HELPER(>, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|    129|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|    129|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|    129|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|    129|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|    129|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|    129|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|    129|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|    129|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|    129|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|  36.8k|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 36.6k, False: 129]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|  36.6k|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 129, False: 36.5k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|  36.6k|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 36.6k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|  36.6k|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|   146k|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 36.6k]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 36.6k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|  36.6k|		}							\
  |  |  |  |  |  |  |  |   85|    129|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 129]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|    129|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 129]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|    129|	    x1 = px1[i1];						\
  |  |  |  |  432|    129|	    x2 = px2[i2];						\
  |  |  |  |  433|    129|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|    129|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|    129|            else                                                        \
  |  |  |  |  436|    129|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|    129|        });                                                             \
  |  |  |  |  438|    129|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 129]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  453|    129|        break;                                                          \
  |  |  454|      8|    case LEOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (454:5): [True: 8, False: 286]
  |  |  ------------------
  |  |  455|      8|	NR_HELPER(<=, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      8|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      8|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      8|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      8|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      8|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      8|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      8|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      8|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      8|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|     24|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 16, False: 8]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|     16|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 8, False: 8]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|     16|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 16, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|     16|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|     64|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 16]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 16]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|     16|		}							\
  |  |  |  |  |  |  |  |   85|      8|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 8]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      8|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 8]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      8|	    x1 = px1[i1];						\
  |  |  |  |  432|      8|	    x2 = px2[i2];						\
  |  |  |  |  433|      8|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      8|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      8|            else                                                        \
  |  |  |  |  436|      8|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      8|        });                                                             \
  |  |  |  |  438|      8|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 8]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  456|      8|        break;                                                          \
  |  |  457|      0|    case GEOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (457:5): [True: 0, False: 294]
  |  |  ------------------
  |  |  458|      0|	NR_HELPER(>=, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  459|      0|        break;                                                          \
  |  |  460|    294|    }                                                                   \
  |  |  461|    294|} while(0)
  |  |  ------------------
  |  |  |  Branch (461:9): [Folded, False: 294]
  |  |  ------------------
  ------------------
  478|    294|        } else {
  479|      0|            NUMERIC_RELOP(int, INTEGER, ISNA_INT, double, REAL, ISNAN);
  ------------------
  |  |  440|      0|#define NUMERIC_RELOP(type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  441|      0|    switch (code) {                                                     \
  |  |  ------------------
  |  |  |  Branch (441:13): [True: 0, False: 0]
  |  |  ------------------
  |  |  442|      0|    case EQOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (442:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  443|      0|	NR_HELPER(==, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  444|      0|        break;                                                          \
  |  |  445|      0|    case NEOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (445:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  446|      0|	NR_HELPER(!=, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  447|      0|        break;                                                          \
  |  |  448|      0|    case LTOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (448:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  449|      0|	NR_HELPER(<, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  450|      0|        break;                                                          \
  |  |  451|      0|    case GTOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (451:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  452|      0|	NR_HELPER(>, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  453|      0|        break;                                                          \
  |  |  454|      0|    case LEOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (454:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  455|      0|	NR_HELPER(<=, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  456|      0|        break;                                                          \
  |  |  457|      0|    case GEOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (457:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  458|      0|	NR_HELPER(>=, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  459|      0|        break;                                                          \
  |  |  460|      0|    }                                                                   \
  |  |  461|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (461:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
  480|      0|        }
  481|    294|    } else if (isInteger(s2) || isLogical(s2)) {
  ------------------
  |  |  949|      0|#define isInteger		Rf_isInteger
  ------------------
                  } else if (isInteger(s2) || isLogical(s2)) {
  ------------------
  |  |  952|      0|#define isLogical		Rf_isLogical
  ------------------
  |  Branch (481:16): [True: 0, False: 0]
  |  Branch (481:33): [True: 0, False: 0]
  ------------------
  482|      0|        NUMERIC_RELOP(double, REAL, ISNAN, int, INTEGER, ISNA_INT);
  ------------------
  |  |  440|      0|#define NUMERIC_RELOP(type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  441|      0|    switch (code) {                                                     \
  |  |  ------------------
  |  |  |  Branch (441:13): [True: 0, False: 0]
  |  |  ------------------
  |  |  442|      0|    case EQOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (442:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  443|      0|	NR_HELPER(==, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  444|      0|        break;                                                          \
  |  |  445|      0|    case NEOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (445:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  446|      0|	NR_HELPER(!=, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  447|      0|        break;                                                          \
  |  |  448|      0|    case LTOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (448:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  449|      0|	NR_HELPER(<, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  450|      0|        break;                                                          \
  |  |  451|      0|    case GTOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (451:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  452|      0|	NR_HELPER(>, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  453|      0|        break;                                                          \
  |  |  454|      0|    case LEOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (454:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  455|      0|	NR_HELPER(<=, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  456|      0|        break;                                                          \
  |  |  457|      0|    case GEOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (457:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  458|      0|	NR_HELPER(>=, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  459|      0|        break;                                                          \
  |  |  460|      0|    }                                                                   \
  |  |  461|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (461:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
  483|      0|    } else {
  484|      0|        NUMERIC_RELOP(double, REAL, ISNAN, double, REAL, ISNAN);
  ------------------
  |  |  440|      0|#define NUMERIC_RELOP(type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  441|      0|    switch (code) {                                                     \
  |  |  ------------------
  |  |  |  Branch (441:13): [True: 0, False: 0]
  |  |  ------------------
  |  |  442|      0|    case EQOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (442:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  443|      0|	NR_HELPER(==, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  444|      0|        break;                                                          \
  |  |  445|      0|    case NEOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (445:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  446|      0|	NR_HELPER(!=, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  447|      0|        break;                                                          \
  |  |  448|      0|    case LTOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (448:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  449|      0|	NR_HELPER(<, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  450|      0|        break;                                                          \
  |  |  451|      0|    case GTOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (451:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  452|      0|	NR_HELPER(>, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  453|      0|        break;                                                          \
  |  |  454|      0|    case LEOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (454:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  455|      0|	NR_HELPER(<=, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  456|      0|        break;                                                          \
  |  |  457|      0|    case GEOP:                                                          \
  |  |  ------------------
  |  |  |  Branch (457:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  458|      0|	NR_HELPER(>=, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2); \
  |  |  ------------------
  |  |  |  |  426|      0|#define NR_HELPER(OP, type1, ACCESSOR1, ISNA1, type2, ACCESSOR2, ISNA2) do { \
  |  |  |  |  427|      0|	type1 x1, *px1 = ACCESSOR1(s1);					\
  |  |  |  |  428|      0|	type2 x2, *px2 = ACCESSOR2(s2);					\
  |  |  |  |  429|      0|	int *pa = LOGICAL(ans);						\
  |  |  |  |  430|      0|        MOD_ITERATE2(n, n1, n2, i, i1, i2, {                            \
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |  |  |  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   90|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  431|      0|	    x1 = px1[i1];						\
  |  |  |  |  432|      0|	    x2 = px2[i2];						\
  |  |  |  |  433|      0|            if (ISNA1(x1) || ISNA2(x2))                                 \
  |  |  |  |  434|      0|                pa[i] = NA_LOGICAL;					\
  |  |  |  |  435|      0|            else                                                        \
  |  |  |  |  436|      0|                pa[i] = (x1 OP x2);					\
  |  |  |  |  437|      0|        });                                                             \
  |  |  |  |  438|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (438:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  459|      0|        break;                                                          \
  |  |  460|      0|    }                                                                   \
  |  |  461|      0|} while(0)
  |  |  ------------------
  |  |  |  Branch (461:9): [Folded, False: 0]
  |  |  ------------------
  ------------------
  485|      0|    }
  486|       |
  487|    294|    UNPROTECT(2);
  ------------------
  |  |  358|    294|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  488|    294|    return ans;
  489|    294|}
relop.c:string_relop:
  549|   773k|{
  550|   773k|    R_xlen_t i, n, n1, n2, res, i1, i2;
  551|   773k|    SEXP ans, c1, c2;
  552|   773k|    const void *vmax = vmaxget(); // for Scollate
  553|       |
  554|   773k|    n1 = XLENGTH(s1);
  555|   773k|    n2 = XLENGTH(s2);
  556|   773k|    n = (n1 > n2) ? n1 : n2;
  ------------------
  |  Branch (556:9): [True: 385k, False: 387k]
  ------------------
  557|   773k|    PROTECT(s1);
  ------------------
  |  |  357|   773k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  558|   773k|    PROTECT(s2);
  ------------------
  |  |  357|   773k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  559|   773k|    PROTECT(ans = allocVector(LGLSXP, n));
  ------------------
  |  |  357|   773k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  560|   773k|    int *pa = LOGICAL(ans);
  561|       |
  562|   773k|    switch (code) {
  ------------------
  |  Branch (562:13): [True: 773k, False: 0]
  ------------------
  563|   773k|    case EQOP:
  ------------------
  |  Branch (563:5): [True: 773k, False: 108]
  ------------------
  564|   773k|	MOD_ITERATE2(n, n1, n2, i, i1, i2, {
  ------------------
  |  |   87|   773k|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   88|   773k|	i = i1 = i2 = 0;					\
  |  |   89|   773k|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  ------------------
  |  |  |  |   78|   773k|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |   79|  2.31M|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (79:9): [True: 1.54M, False: 773k]
  |  |  |  |  ------------------
  |  |  |  |   80|  1.54M|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:12): [True: 773k, False: 770k]
  |  |  |  |  ------------------
  |  |  |  |   81|  1.54M|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (81:9): [True: 1.54M, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   82|  1.54M|		 ++i) {							\
  |  |  |  |   83|  9.26M|	    loop_body							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (83:6): [True: 0, False: 1.54M]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 1.54M]
  |  |  |  |  |  Branch (83:6): [True: 1.70k, False: 1.54M]
  |  |  |  |  ------------------
  |  |  |  |   84|  1.54M|		}							\
  |  |  |  |   85|   773k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:14): [Folded, False: 773k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|   773k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (90:14): [Folded, False: 773k]
  |  |  ------------------
  ------------------
  565|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  566|   773k|	    c1 = STRING_ELT(s1, i1);
  567|   773k|	    c2 = STRING_ELT(s2, i2);
  568|   773k|	    if (c1 == NA_STRING || c2 == NA_STRING)
  569|   773k|		pa[i] = NA_LOGICAL;
  570|   773k|	    else
  571|   773k|		pa[i] = Seql(c1, c2) ? 1 : 0;
  572|   773k|	});
  573|   773k|	break;
  574|    108|    case NEOP:
  ------------------
  |  Branch (574:5): [True: 108, False: 773k]
  ------------------
  575|    108|	MOD_ITERATE2(n, n1, n2, i, i1, i2, {
  ------------------
  |  |   87|    108|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   88|    108|	i = i1 = i2 = 0;					\
  |  |   89|    108|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  ------------------
  |  |  |  |   78|    108|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |   79|  6.14k|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (79:9): [True: 6.03k, False: 108]
  |  |  |  |  ------------------
  |  |  |  |   80|  6.03k|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:12): [True: 108, False: 5.92k]
  |  |  |  |  ------------------
  |  |  |  |   81|  6.03k|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (81:9): [True: 6.02k, False: 10]
  |  |  |  |  ------------------
  |  |  |  |   82|  6.03k|		 ++i) {							\
  |  |  |  |   83|  36.1k|	    loop_body							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (83:6): [True: 0, False: 6.03k]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 6.03k]
  |  |  |  |  |  Branch (83:6): [True: 59, False: 5.97k]
  |  |  |  |  ------------------
  |  |  |  |   84|  6.03k|		}							\
  |  |  |  |   85|    108|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:14): [Folded, False: 108]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|    108|    } while (0)
  |  |  ------------------
  |  |  |  Branch (90:14): [Folded, False: 108]
  |  |  ------------------
  ------------------
  576|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  577|    108|	    c1 = STRING_ELT(s1, i1);
  578|    108|	    c2 = STRING_ELT(s2, i2);
  579|    108|	    if (c1 == NA_STRING || c2 == NA_STRING)
  580|    108|		pa[i] = NA_LOGICAL;
  581|    108|	    else
  582|    108|		pa[i] = Seql(c1, c2) ? 0 : 1;
  583|    108|	});
  584|    108|	break;
  585|      0|    case LTOP:
  ------------------
  |  Branch (585:5): [True: 0, False: 773k]
  ------------------
  586|      0|	MOD_ITERATE2(n, n1, n2, i, i1, i2, {
  ------------------
  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  ------------------
  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   84|      0|		}							\
  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  587|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  588|      0|	    c1 = STRING_ELT(s1, i1);
  589|      0|	    c2 = STRING_ELT(s2, i2);
  590|      0|	    if (c1 == NA_STRING || c2 == NA_STRING)
  591|      0|		pa[i] = NA_LOGICAL;
  592|      0|	    else if (c1 == c2)
  593|      0|		pa[i] = 0;
  594|      0|	    else {
  595|      0|		errno = 0;
  596|      0|		res = Scollate(c1, c2);
  597|      0|		if(errno)
  598|      0|		    pa[i] = NA_LOGICAL;
  599|      0|		else
  600|      0|		    pa[i] = (res < 0) ? 1 : 0;
  601|      0|	    }
  602|      0|	});
  603|      0|	break;
  604|      0|    case GTOP:
  ------------------
  |  Branch (604:5): [True: 0, False: 773k]
  ------------------
  605|      0|	MOD_ITERATE2(n, n1, n2, i ,i1, i2, {
  ------------------
  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  ------------------
  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   84|      0|		}							\
  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  606|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  607|      0|	    c1 = STRING_ELT(s1, i1);
  608|      0|	    c2 = STRING_ELT(s2, i2);
  609|      0|	    if (c1 == NA_STRING || c2 == NA_STRING)
  610|      0|		pa[i] = NA_LOGICAL;
  611|      0|	    else if (c1 == c2)
  612|      0|		pa[i] = 0;
  613|      0|	    else {
  614|      0|		errno = 0;
  615|      0|		res = Scollate(c1, c2);
  616|      0|		if(errno)
  617|      0|		    pa[i] = NA_LOGICAL;
  618|      0|		else
  619|      0|		    pa[i] = (res > 0) ? 1 : 0;
  620|      0|	    }
  621|      0|	});
  622|      0|	break;
  623|      0|    case LEOP:
  ------------------
  |  Branch (623:5): [True: 0, False: 773k]
  ------------------
  624|      0|	MOD_ITERATE2(n, n1, n2, i, i1, i2, {
  ------------------
  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  ------------------
  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   84|      0|		}							\
  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  625|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  626|      0|	    c1 = STRING_ELT(s1, i1);
  627|      0|	    c2 = STRING_ELT(s2, i2);
  628|      0|	    if (c1 == NA_STRING || c2 == NA_STRING)
  629|      0|		pa[i] = NA_LOGICAL;
  630|      0|	    else if (c1 == c2)
  631|      0|		pa[i] = 1;
  632|      0|	    else {
  633|      0|		errno = 0;
  634|      0|		res = Scollate(c1, c2);
  635|      0|		if(errno)
  636|      0|		    pa[i] = NA_LOGICAL;
  637|      0|		else
  638|      0|		    pa[i] = (res <= 0) ? 1 : 0;
  639|      0|	    }
  640|      0|	});
  641|      0|	break;
  642|      0|    case GEOP:
  ------------------
  |  Branch (642:5): [True: 0, False: 773k]
  ------------------
  643|      0|	MOD_ITERATE2(n, n1, n2, i, i1, i2, {
  ------------------
  |  |   87|      0|#define MOD_ITERATE2(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |   88|      0|	i = i1 = i2 = 0;					\
  |  |   89|      0|	MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body);	\
  |  |  ------------------
  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   84|      0|		}							\
  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (90:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  644|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  645|      0|	    c1 = STRING_ELT(s1, i1);
  646|      0|	    c2 = STRING_ELT(s2, i2);
  647|      0|	    if (c1 == NA_STRING || c2 == NA_STRING)
  648|      0|		pa[i] = NA_LOGICAL;
  649|      0|	    else if (c1 == c2)
  650|      0|		pa[i] = 1;
  651|      0|	    else {
  652|      0|		errno = 0;
  653|      0|		res = Scollate(c1, c2);
  654|      0|		if(errno)
  655|      0|		    pa[i] = NA_LOGICAL;
  656|      0|		else
  657|      0|		    pa[i] = (res >= 0) ? 1 : 0;
  658|      0|	    }
  659|      0|	});
  660|      0|	break;
  661|   773k|    }
  662|   773k|    UNPROTECT(3);
  ------------------
  |  |  358|   773k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  663|   773k|    vmaxset(vmax);
  664|   773k|    return ans;
  665|   773k|}

R_XDRDecodeInteger:
 2368|  2.10M|{
 2369|  2.10M|    XDR xdrs;
 2370|  2.10M|    int i, success;
 2371|       |
 2372|  2.10M|    xdrmem_create(&xdrs, (char *) buf, R_XDR_INTEGER_SIZE, XDR_DECODE);
  ------------------
  |  |  709|  2.10M|#define R_XDR_INTEGER_SIZE 4
  ------------------
 2373|  2.10M|    success = xdr_int(&xdrs, &i);
 2374|  2.10M|    xdr_destroy(&xdrs);
  ------------------
  |  Branch (2374:5): [True: 2.10M, False: 0]
  |  Branch (2374:5): [Folded, False: 2.10M]
  ------------------
 2375|  2.10M|    if (! success)
  ------------------
  |  Branch (2375:9): [True: 0, False: 2.10M]
  ------------------
 2376|      0|	error(_("XDR read failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("XDR read failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2377|  2.10M|    return i;
 2378|  2.10M|}

do_scan:
  865|     12|{
  866|     12|    SEXP ans, file, sep, what, stripwhite, dec, quotes, comstr;
  867|     12|    int c, flush, fill, blskip, multiline, escapes, skipNul;
  868|     12|    R_xlen_t nmax, nlines, nskip;
  869|     12|    const char *p, *encoding;
  870|     12|    RCNTXT cntxt;
  871|     12|    LocalData data = {NULL, 0, 0, '.', NULL, NO_COMCHAR, 0, NULL, false,
  ------------------
  |  |   57|     12|#define NO_COMCHAR 100000 /* won't occur even in Unicode */
  ------------------
  872|     12|		      false, 0, false, false, false, false, false, {false}};
  873|     12|    data.NAstrings = R_NilValue;
  874|       |
  875|     12|    checkArity(op, args);
  ------------------
  |  | 1788|     12|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  876|       |
  877|     12|    file = CAR(args);		   args = CDR(args);
  878|     12|    what = CAR(args);		   args = CDR(args);
  879|     12|    nmax = asXLength(CAR(args));   args = CDR(args);
  ------------------
  |  | 1863|     12|# define asXLength		Rf_asXLength
  ------------------
  880|     12|    sep = CAR(args);		   args = CDR(args);
  881|     12|    dec = CAR(args);		   args = CDR(args);
  882|     12|    quotes = CAR(args);		   args = CDR(args);
  883|     12|    nskip = asXLength(CAR(args));  args = CDR(args);
  ------------------
  |  | 1863|     12|# define asXLength		Rf_asXLength
  ------------------
  884|     12|    nlines = asXLength(CAR(args)); args = CDR(args);
  ------------------
  |  | 1863|     12|# define asXLength		Rf_asXLength
  ------------------
  885|     12|    data.NAstrings = CAR(args);	   args = CDR(args);
  886|     12|    flush = asLogical(CAR(args));  args = CDR(args);
  ------------------
  |  |  886|     12|#define asLogical		Rf_asLogical
  ------------------
  887|     12|    fill  = asLogical(CAR(args));  args = CDR(args);
  ------------------
  |  |  886|     12|#define asLogical		Rf_asLogical
  ------------------
  888|     12|    stripwhite = CAR(args);	   args = CDR(args);
  889|     12|    data.quiet = asLogical(CAR(args));  args = CDR(args);
  ------------------
  |  |  886|     12|#define asLogical		Rf_asLogical
  ------------------
  890|     12|    blskip = asLogical(CAR(args)); args = CDR(args);
  ------------------
  |  |  886|     12|#define asLogical		Rf_asLogical
  ------------------
  891|     12|    multiline = asLogical(CAR(args)); args = CDR(args);
  ------------------
  |  |  886|     12|#define asLogical		Rf_asLogical
  ------------------
  892|     12|    comstr = CAR(args);            args = CDR(args);
  893|     12|    escapes = asLogical(CAR(args));args = CDR(args);
  ------------------
  |  |  886|     12|#define asLogical		Rf_asLogical
  ------------------
  894|     12|    if(!isString(CAR(args)) || LENGTH(CAR(args)) != 1)
  ------------------
  |  |  966|     12|#define isString		Rf_isString
  ------------------
  |  Branch (894:8): [True: 0, False: 12]
  |  Branch (894:32): [True: 0, False: 12]
  ------------------
  895|      0|	error(_("invalid '%s' argument"), "encoding");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "encoding");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  896|     12|    encoding = CHAR(STRING_ELT(CAR(args), 0)); args = CDR(args); /* ASCII */
  ------------------
  |  |  203|     12|#define CHAR(x) R_CHAR(x)
  ------------------
  897|     12|    if(streql(encoding, "latin1")) data.isLatin1 = true;
  ------------------
  |  | 1498|     12|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 12]
  |  |  ------------------
  ------------------
  898|     12|    if(streql(encoding, "UTF-8"))  data.isUTF8 = true;
  ------------------
  |  | 1498|     12|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 12]
  |  |  ------------------
  ------------------
  899|     12|    skipNul = asLogical(CAR(args));
  ------------------
  |  |  886|     12|#define asLogical		Rf_asLogical
  ------------------
  900|       |
  901|     12|    if (data.quiet == NA_LOGICAL)		data.quiet = 0;
  ------------------
  |  |   55|     12|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (901:9): [True: 0, False: 12]
  ------------------
  902|     12|    if (blskip == NA_LOGICAL)			blskip = 1;
  ------------------
  |  |   55|     12|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (902:9): [True: 0, False: 12]
  ------------------
  903|     12|    if (multiline == NA_LOGICAL)		multiline = 1;
  ------------------
  |  |   55|     12|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (903:9): [True: 0, False: 12]
  ------------------
  904|     12|    if (nskip < 0)				nskip = 0;
  ------------------
  |  Branch (904:9): [True: 0, False: 12]
  ------------------
  905|     12|    if (nlines < 0)				nlines = 0;
  ------------------
  |  Branch (905:9): [True: 0, False: 12]
  ------------------
  906|     12|    if (nmax < 0)				nmax = 0;
  ------------------
  |  Branch (906:9): [True: 12, False: 0]
  ------------------
  907|       |
  908|     12|    if (TYPEOF(stripwhite) != LGLSXP)
  ------------------
  |  |  121|     12|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (908:9): [True: 0, False: 12]
  ------------------
  909|      0|	error(_("invalid '%s' argument"), "strip.white");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "strip.white");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  910|     12|    if (xlength(stripwhite) != 1 && xlength(stripwhite) != xlength(what))
  ------------------
  |  | 1049|     12|#define xlength(x)		Rf_xlength(x)
  ------------------
                  if (xlength(stripwhite) != 1 && xlength(stripwhite) != xlength(what))
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
                  if (xlength(stripwhite) != 1 && xlength(stripwhite) != xlength(what))
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (910:9): [True: 0, False: 12]
  |  Branch (910:37): [True: 0, False: 0]
  ------------------
  911|      0|	error(_("invalid 'strip.white' length"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid 'strip.white' length"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  912|     12|    if (TYPEOF(data.NAstrings) != STRSXP)
  ------------------
  |  |  126|     12|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (912:9): [True: 0, False: 12]
  ------------------
  913|      0|	error(_("invalid '%s' argument"), "na.strings");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "na.strings");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  914|     12|    if (TYPEOF(comstr) != STRSXP || length(comstr) != 1)
  ------------------
  |  |  126|     24|#define STRSXP	    16	  /* string vectors */
  ------------------
                  if (TYPEOF(comstr) != STRSXP || length(comstr) != 1)
  ------------------
  |  |  987|     12|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (914:9): [True: 0, False: 12]
  |  Branch (914:37): [True: 0, False: 12]
  ------------------
  915|      0|	error(_("invalid '%s' argument"), "comment.char");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "comment.char");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  916|       |
  917|     12|    if (isString(sep) || isNull(sep)) {
  ------------------
  |  |  966|     12|#define isString		Rf_isString
  ------------------
                  if (isString(sep) || isNull(sep)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (917:9): [True: 12, False: 0]
  |  Branch (917:26): [True: 0, False: 0]
  ------------------
  918|     12|	if (length(sep) == 0) data.sepchar = 0;
  ------------------
  |  |  987|     12|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (918:6): [True: 0, False: 12]
  ------------------
  919|     12|	else {
  920|     12|	    const char *sc = translateChar(STRING_ELT(sep, 0));
  ------------------
  |  | 1037|     12|#define translateChar		Rf_translateChar
  ------------------
  921|     12|	    if(strlen(sc) > 1)
  ------------------
  |  Branch (921:9): [True: 0, False: 12]
  ------------------
  922|      0|		error(_("invalid 'sep' value: must be one byte"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("invalid 'sep' value: must be one byte"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  923|     12|	    data.sepchar = (unsigned char) sc[0];
  924|     12|	}
  925|       |	/* gets compared to chars: bug prior to 1.7.0 */
  926|     12|    } else error(_("invalid '%s' argument"), "sep");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  } else error(_("invalid '%s' argument"), "sep");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  927|       |
  928|     12|    if (isString(dec) || isNull(dec)) {
  ------------------
  |  |  966|     12|#define isString		Rf_isString
  ------------------
                  if (isString(dec) || isNull(dec)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (928:9): [True: 12, False: 0]
  |  Branch (928:26): [True: 0, False: 0]
  ------------------
  929|     12|	if (length(dec) == 0)
  ------------------
  |  |  987|     12|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (929:6): [True: 0, False: 12]
  ------------------
  930|      0|	    data.decchar = '.';
  931|     12|	else {
  932|     12|	    const char *dc = translateChar(STRING_ELT(dec, 0));
  ------------------
  |  | 1037|     12|#define translateChar		Rf_translateChar
  ------------------
  933|     12|	    if(strlen(dc) != 1)
  ------------------
  |  Branch (933:9): [True: 0, False: 12]
  ------------------
  934|      0|		error(_("invalid decimal separator: must be one byte"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("invalid decimal separator: must be one byte"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  935|     12|	    data.decchar = dc[0];
  936|     12|	}
  937|     12|    }
  938|      0|    else
  939|      0|	error(_("invalid decimal separator"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid decimal separator"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  940|       |
  941|       |    /* set up a context which will close the connection if there is
  942|       |       an error or user interrupt */
  943|     12|    begincontext(&cntxt, CTXT_CCODE, R_GlobalContext->call, R_BaseEnv,
  ------------------
  |  | 1864|     12|# define begincontext		Rf_begincontext
  ------------------
  944|     12|		 R_BaseEnv, R_NilValue, R_NilValue);
  945|     12|    cntxt.cend = &scan_cleanup;
  946|     12|    cntxt.cenddata = &data;
  947|       |
  948|     12|    if (isString(quotes)) {
  ------------------
  |  |  966|     12|#define isString		Rf_isString
  ------------------
  |  Branch (948:9): [True: 12, False: 0]
  ------------------
  949|     12|	const char *sc = translateChar(STRING_ELT(quotes, 0));
  ------------------
  |  | 1037|     12|#define translateChar		Rf_translateChar
  ------------------
  950|     12|	if (strlen(sc)) data.quoteset = Rstrdup(sc);
  ------------------
  |  Branch (950:6): [True: 12, False: 0]
  ------------------
  951|      0|	else data.quoteset = "";
  952|     12|    } else if (isNull(quotes))
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (952:16): [True: 0, False: 0]
  ------------------
  953|      0|	data.quoteset = "";
  954|      0|    else
  955|      0|	error(_("invalid quote symbol set"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid quote symbol set"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  956|       |
  957|     12|    p = translateChar(STRING_ELT(comstr, 0));
  ------------------
  |  | 1037|     12|#define translateChar		Rf_translateChar
  ------------------
  958|     12|    data.comchar = NO_COMCHAR; /*  here for -Wall */
  ------------------
  |  |   57|     12|#define NO_COMCHAR 100000 /* won't occur even in Unicode */
  ------------------
  959|     12|    if (strlen(p) > 1)
  ------------------
  |  Branch (959:9): [True: 0, False: 12]
  ------------------
  960|      0|	error(_("invalid '%s' argument"), "comment.char");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "comment.char");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  961|     12|    else if (strlen(p) == 1) data.comchar = (unsigned char)*p;
  ------------------
  |  Branch (961:14): [True: 12, False: 0]
  ------------------
  962|     12|    if(escapes == NA_LOGICAL)
  ------------------
  |  |   55|     12|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (962:8): [True: 0, False: 12]
  ------------------
  963|      0|	error(_("invalid '%s' argument"), "allowEscapes");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "allowEscapes");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  964|     12|    data.escapes = escapes != 0;
  965|     12|    if(skipNul == NA_LOGICAL)
  ------------------
  |  |   55|     12|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (965:8): [True: 0, False: 12]
  ------------------
  966|      0|	error(_("invalid '%s' argument"), "skipNul");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "skipNul");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  967|     12|    data.skipNul = skipNul != 0;
  968|       |
  969|     12|    int ii = asInteger(file);
  ------------------
  |  |  885|     12|#define asInteger		Rf_asInteger
  ------------------
  970|     12|    data.con = getConnection(ii);
  971|     12|    if(ii == 0) {
  ------------------
  |  Branch (971:8): [True: 0, False: 12]
  ------------------
  972|      0|	data.atStart = false;
  973|      0|	data.ttyflag = 1;
  974|     12|    } else {
  975|     12|	data.atStart = (nskip == 0);
  976|     12|	data.ttyflag = 0;
  977|     12|	data.wasopen = data.con->isopen;
  978|     12|	if(!data.wasopen) {
  ------------------
  |  Branch (978:5): [True: 0, False: 12]
  ------------------
  979|      0|	    data.con->UTF8out = true;  /* a request */
  980|      0|	    strcpy(data.con->mode, "r");
  981|      0|	    if(!data.con->open(data.con))
  ------------------
  |  Branch (981:9): [True: 0, False: 0]
  ------------------
  982|      0|		error(_("cannot open the connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("cannot open the connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  983|      0|	    if(!data.con->canread) {
  ------------------
  |  Branch (983:9): [True: 0, False: 0]
  ------------------
  984|      0|		data.con->close(data.con);
  985|      0|		error(_("cannot read from this connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("cannot read from this connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  986|      0|	    }
  987|     12|	} else {
  988|     12|	    if(!data.con->canread)
  ------------------
  |  Branch (988:9): [True: 0, False: 12]
  ------------------
  989|      0|		error(_("cannot read from this connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("cannot read from this connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  990|     12|	}
  991|     12|	for(R_xlen_t i = 0, j = 10000; i < nskip; i++) { /* MBCS-safe */
  ------------------
  |  Branch (991:33): [True: 0, False: 12]
  ------------------
  992|      0|	    for(;;) {
  993|      0|		c = scanchar(false, &data);
  994|      0|		if (!j--) {
  ------------------
  |  Branch (994:7): [True: 0, False: 0]
  ------------------
  995|      0|		    R_CheckUserInterrupt();
  996|      0|		    j = 10000;
  997|      0|		}
  998|      0|		if (c == '\n' || c == R_EOF)
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (998:7): [True: 0, False: 0]
  |  Branch (998:20): [True: 0, False: 0]
  ------------------
  999|      0|		    break;
 1000|      0|	    }
 1001|      0|	}
 1002|     12|    }
 1003|       |
 1004|     12|    ans = R_NilValue;		/* -Wall */
 1005|     12|    data.save = 0;
 1006|       |
 1007|     12|    switch (TYPEOF(what)) {
 1008|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1008:5): [True: 0, False: 12]
  ------------------
 1009|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1009:5): [True: 0, False: 12]
  ------------------
 1010|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1010:5): [True: 0, False: 12]
  ------------------
 1011|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1011:5): [True: 0, False: 12]
  ------------------
 1012|     10|    case STRSXP:
  ------------------
  |  |  126|     10|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1012:5): [True: 10, False: 2]
  ------------------
 1013|     10|    case RAWSXP:
  ------------------
  |  |  136|     10|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1013:5): [True: 0, False: 12]
  ------------------
 1014|     10|	ans = scanVector(TYPEOF(what), nmax, nlines, flush, stripwhite,
 1015|     10|			 blskip, &data);
 1016|     10|	break;
 1017|       |
 1018|      2|    case VECSXP:
  ------------------
  |  |  131|      2|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1018:5): [True: 2, False: 10]
  ------------------
 1019|      2|	ans = scanFrame(what, nmax, nlines, flush, fill, stripwhite,
 1020|      2|			blskip, multiline, &data);
 1021|      2|	break;
 1022|      0|    default:
  ------------------
  |  Branch (1022:5): [True: 0, False: 12]
  ------------------
 1023|      0|	error(_("invalid '%s' argument"), "what");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "what");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1024|     12|    }
 1025|     12|    PROTECT(ans);
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1026|     12|    endcontext(&cntxt);
  ------------------
  |  | 1895|     12|# define endcontext		Rf_endcontext
  ------------------
 1027|       |
 1028|       |    /* we might have a character that was unscanchar-ed.
 1029|       |       So pushback if possible */
 1030|     12|    if (data.save && !data.ttyflag && data.wasopen) {
  ------------------
  |  Branch (1030:9): [True: 0, False: 12]
  |  Branch (1030:22): [True: 0, False: 0]
  |  Branch (1030:39): [True: 0, False: 0]
  ------------------
 1031|      0|	char line[2] = " ";
 1032|      0|	line[0] = (char) data.save;
 1033|      0|	con_pushback(data.con, false, line);
  ------------------
  |  |   71|      0|#define con_pushback	Rf_con_pushback
  ------------------
 1034|      0|    }
 1035|     12|    if (!data.ttyflag && !data.wasopen)
  ------------------
  |  Branch (1035:9): [True: 12, False: 0]
  |  Branch (1035:26): [True: 0, False: 12]
  ------------------
 1036|      0|	data.con->close(data.con);
 1037|     12|    if (data.quoteset[0]) free(data.quoteset);
  ------------------
  |  Branch (1037:9): [True: 12, False: 0]
  ------------------
 1038|     12|    if (!skipNul && data.embedWarn)
  ------------------
  |  Branch (1038:9): [True: 12, False: 0]
  |  Branch (1038:21): [True: 0, False: 12]
  ------------------
 1039|      0|	warning(_("embedded nul(s) found in input"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("embedded nul(s) found in input"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1040|       |
 1041|     12|    UNPROTECT(1); /* ans */
  ------------------
  |  |  358|     12|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1042|     12|    return ans;
 1043|     12|}
scan.c:scanchar:
  255|  1.59k|{
  256|  1.59k|    int next;
  257|  1.59k|    if (d->save) {
  ------------------
  |  Branch (257:9): [True: 0, False: 1.59k]
  ------------------
  258|      0|	next = d->save;
  259|      0|	d->save = 0;
  260|      0|    } else
  261|  1.59k|	next = scanchar_raw(d);
  262|  1.59k|    if(next == d->comchar && !inQuote) {
  ------------------
  |  Branch (262:8): [True: 2, False: 1.59k]
  |  Branch (262:30): [True: 2, False: 0]
  ------------------
  263|      2|	do
  264|    140|	    next = scanchar_raw(d);
  265|    140|	while (next != '\n' && next != R_EOF);
  ------------------
  |  | 1531|    138|#define R_EOF	-1
  ------------------
  |  Branch (265:9): [True: 138, False: 2]
  |  Branch (265:25): [True: 138, False: 0]
  ------------------
  266|      2|    }
  267|  1.59k|    if(next == '\\' && d->escapes) {
  ------------------
  |  Branch (267:8): [True: 0, False: 1.59k]
  |  Branch (267:24): [True: 0, False: 0]
  ------------------
  268|      0|	next = scanchar_raw(d);
  269|      0|	if ('0' <= next && next <= '8') {
  ------------------
  |  Branch (269:6): [True: 0, False: 0]
  |  Branch (269:21): [True: 0, False: 0]
  ------------------
  270|      0|	    int octal = next - '0';
  271|      0|	    if ('0' <= (next = scanchar_raw(d)) && next <= '8') {
  ------------------
  |  Branch (271:10): [True: 0, False: 0]
  |  Branch (271:45): [True: 0, False: 0]
  ------------------
  272|      0|		octal = 8 * octal + next - '0';
  273|      0|		if ('0' <= (next = scanchar_raw(d)) && next <= '8') {
  ------------------
  |  Branch (273:7): [True: 0, False: 0]
  |  Branch (273:42): [True: 0, False: 0]
  ------------------
  274|      0|		    octal = 8 * octal + next - '0';
  275|      0|		} else unscanchar(next, d);
  276|      0|	    } else unscanchar(next, d);
  277|      0|	    next = octal;
  278|      0|	} else
  279|      0|	    switch(next) {
  280|      0|	    case 'a': next = '\a'; break;
  ------------------
  |  Branch (280:6): [True: 0, False: 0]
  ------------------
  281|      0|	    case 'b': next = '\b'; break;
  ------------------
  |  Branch (281:6): [True: 0, False: 0]
  ------------------
  282|      0|	    case 'f': next = '\f'; break;
  ------------------
  |  Branch (282:6): [True: 0, False: 0]
  ------------------
  283|      0|	    case 'n': next = '\n'; break;
  ------------------
  |  Branch (283:6): [True: 0, False: 0]
  ------------------
  284|      0|	    case 'r': next = '\r'; break;
  ------------------
  |  Branch (284:6): [True: 0, False: 0]
  ------------------
  285|      0|	    case 't': next = '\t'; break;
  ------------------
  |  Branch (285:6): [True: 0, False: 0]
  ------------------
  286|      0|	    case 'v': next = '\v'; break;
  ------------------
  |  Branch (286:6): [True: 0, False: 0]
  ------------------
  287|      0|	    case 'x': {
  ------------------
  |  Branch (287:6): [True: 0, False: 0]
  ------------------
  288|      0|		int val = 0; int i, ext;
  289|      0|		for(i = 0; i < 2; i++) {
  ------------------
  |  Branch (289:14): [True: 0, False: 0]
  ------------------
  290|      0|		    next = scanchar_raw(d);
  291|      0|		    if(next >= '0' && next <= '9') ext = next - '0';
  ------------------
  |  Branch (291:10): [True: 0, False: 0]
  |  Branch (291:25): [True: 0, False: 0]
  ------------------
  292|      0|		    else if (next >= 'A' && next <= 'F') ext = next - 'A' + 10;
  ------------------
  |  Branch (292:16): [True: 0, False: 0]
  |  Branch (292:31): [True: 0, False: 0]
  ------------------
  293|      0|		    else if (next >= 'a' && next <= 'f') ext = next - 'a' + 10;
  ------------------
  |  Branch (293:16): [True: 0, False: 0]
  |  Branch (293:31): [True: 0, False: 0]
  ------------------
  294|      0|		    else {unscanchar(next, d); break;}
  295|      0|		    val = 16*val + ext;
  296|      0|		}
  297|      0|		next = val;
  298|      0|	    }
  299|      0|		break;
  300|      0|	    default:
  ------------------
  |  Branch (300:6): [True: 0, False: 0]
  ------------------
  301|       |		/* Any other char and even EOF escapes to itself, but we
  302|       |		   need to preserve \" etc inside quotes.
  303|       |		 */
  304|      0|		if(inQuote && strchr(d->quoteset, next)) {
  ------------------
  |  Branch (304:6): [True: 0, False: 0]
  |  Branch (304:17): [True: 0, False: 0]
  ------------------
  305|      0|		    unscanchar(next, d);
  306|      0|		    next = '\\';
  307|      0|		}
  308|      0|		break;
  309|      0|	    }
  310|      0|    }
  311|  1.59k|    return next;
  312|  1.59k|}
scan.c:scanchar_raw:
  221|  1.73k|{
  222|  1.73k|    int c = (d->ttyflag) ? ConsoleGetcharWithPushBack(d->con) :
  ------------------
  |  Branch (222:13): [True: 0, False: 1.73k]
  ------------------
  223|  1.73k|	Rconn_fgetc(d->con);
  224|  1.73k|    if(c == 0) {
  ------------------
  |  Branch (224:8): [True: 0, False: 1.73k]
  ------------------
  225|      0|	if(d->skipNul) {
  ------------------
  |  Branch (225:5): [True: 0, False: 0]
  ------------------
  226|      0|	    do {
  227|      0|		c = (d->ttyflag) ? ConsoleGetcharWithPushBack(d->con) :
  ------------------
  |  Branch (227:7): [True: 0, False: 0]
  ------------------
  228|      0|		    Rconn_fgetc(d->con);
  229|      0|	    } while(c == 0);
  ------------------
  |  Branch (229:14): [True: 0, False: 0]
  ------------------
  230|      0|	} else d->embedWarn = true;
  231|      0|    }
  232|  1.73k|    return c;
  233|  1.73k|}
scan.c:scanVector:
  568|     10|{
  569|     10|    SEXP ans, bns;
  570|     10|    int c, strip, bch, ic;
  571|     10|    R_xlen_t i, blocksize, linesread, n, nprev;
  572|     10|    char *buffer;
  573|     10|    R_StringBuffer strBuf = {NULL, 0, MAXELTSIZE};
  ------------------
  |  |   85|     10|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
  574|       |
  575|     10|    if (maxitems > 0) blocksize = maxitems;
  ------------------
  |  Branch (575:9): [True: 0, False: 10]
  ------------------
  576|     10|    else blocksize = SCAN_BLOCKSIZE;
  ------------------
  |  |   52|     10|#define SCAN_BLOCKSIZE		1000
  ------------------
  577|       |
  578|     10|    R_AllocStringBuffer(0, &strBuf);
  579|     10|    d->sbuf = &strBuf;
  580|     10|    PROTECT(ans = allocVector(type, blocksize));
  ------------------
  |  |  357|     10|#define PROTECT(s)	Rf_protect(s)
  ------------------
  581|       |
  582|     10|    nprev = 0; n = 0; linesread = 0; bch = 1;
  583|       |
  584|     10|    if (d->ttyflag)
  ------------------
  |  Branch (584:9): [True: 0, False: 10]
  ------------------
  585|      0|	snprintf(ConsolePrompt, CONSOLE_PROMPT_SIZE, "1: ");
  ------------------
  |  |   55|      0|#define CONSOLE_PROMPT_SIZE	256
  ------------------
  586|       |
  587|     10|    strip = asLogical(stripwhite);
  ------------------
  |  |  886|     10|#define asLogical		Rf_asLogical
  ------------------
  588|       |
  589|     10|    ic = 9999;
  590|     78|    for (;;) {
  591|     78|	if(!ic) {
  ------------------
  |  Branch (591:5): [True: 0, False: 78]
  ------------------
  592|      0|	    R_CheckUserInterrupt();
  593|      0|	    ic = 9999;
  594|      0|	}
  595|     78|	if (bch == R_EOF) {
  ------------------
  |  | 1531|     78|#define R_EOF	-1
  ------------------
  |  Branch (595:6): [True: 0, False: 78]
  ------------------
  596|      0|	    if (d->ttyflag) R_ClearerrConsole();
  ------------------
  |  Branch (596:10): [True: 0, False: 0]
  ------------------
  597|      0|	    break;
  598|      0|	}
  599|     78|	else if (bch == '\n') {
  ------------------
  |  Branch (599:11): [True: 10, False: 68]
  ------------------
  600|     10|	    linesread++;
  601|     10|	    if (linesread == maxlines)
  ------------------
  |  Branch (601:10): [True: 10, False: 0]
  ------------------
  602|     10|		break;
  603|      0|	    if (d->ttyflag)
  ------------------
  |  Branch (603:10): [True: 0, False: 0]
  ------------------
  604|      0|		snprintf(ConsolePrompt, CONSOLE_PROMPT_SIZE,
  ------------------
  |  |   55|      0|#define CONSOLE_PROMPT_SIZE	256
  ------------------
  605|      0|		         "%lld: ", (long long) (n + 1));
  606|      0|	    nprev = n;
  607|      0|	}
  608|     68|	if (n == blocksize) {
  ------------------
  |  Branch (608:6): [True: 0, False: 68]
  ------------------
  609|       |	    /* enlarge the vector*/
  610|      0|	    bns = ans;
  611|      0|	    if(blocksize > R_XLEN_T_MAX/2) error(_("too many items"));
  ------------------
  |  |   76|      0|# define R_XLEN_T_MAX 4503599627370496
  ------------------
              	    if(blocksize > R_XLEN_T_MAX/2) error(_("too many items"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    if(blocksize > R_XLEN_T_MAX/2) error(_("too many items"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (611:9): [True: 0, False: 0]
  ------------------
  612|      0|	    blocksize = 2 * blocksize;
  613|      0|	    ans = allocVector(type, blocksize);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
  614|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  615|      0|	    PROTECT(ans);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  616|      0|	    copyVector(ans, bns);
  ------------------
  |  |  902|      0|#define copyVector		Rf_copyVector
  ------------------
  617|      0|	}
  618|     68|	buffer = fillBuffer(type, strip, &bch, d, &strBuf);
  619|     68|	if (nprev == n && strlen(buffer)==0 &&
  ------------------
  |  Branch (619:6): [True: 10, False: 58]
  |  Branch (619:20): [True: 0, False: 10]
  ------------------
  620|      0|	    ((blskip && bch =='\n') || bch == R_EOF)) {
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (620:8): [True: 0, False: 0]
  |  Branch (620:18): [True: 0, False: 0]
  |  Branch (620:33): [True: 0, False: 0]
  ------------------
  621|      0|	    if (d->ttyflag || bch == R_EOF)
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (621:10): [True: 0, False: 0]
  |  Branch (621:24): [True: 0, False: 0]
  ------------------
  622|      0|		break;
  623|      0|	}
  624|     68|	else {
  625|     68|	    extractItem(buffer, ans, n, d);
  626|     68|	    ic--;
  627|     68|	    if (++n == maxitems) {
  ------------------
  |  Branch (627:10): [True: 0, False: 68]
  ------------------
  628|      0|		if (d->ttyflag && bch != '\n') { /* MBCS-safe */
  ------------------
  |  Branch (628:7): [True: 0, False: 0]
  |  Branch (628:21): [True: 0, False: 0]
  ------------------
  629|      0|		    while ((c = scanchar(false, d)) != '\n')
  ------------------
  |  Branch (629:14): [True: 0, False: 0]
  ------------------
  630|      0|			;
  631|      0|		}
  632|      0|		break;
  633|      0|	    }
  634|     68|	}
  635|     68|	if (flush && (bch != '\n') && (bch != R_EOF)) { /* MBCS-safe */
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (635:6): [True: 0, False: 68]
  |  Branch (635:15): [True: 0, False: 0]
  |  Branch (635:32): [True: 0, False: 0]
  ------------------
  636|      0|	    while ((c = scanchar(false, d)) != '\n' && (c != R_EOF));
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (636:13): [True: 0, False: 0]
  |  Branch (636:49): [True: 0, False: 0]
  ------------------
  637|      0|	    bch = c;
  638|      0|	}
  639|     68|    }
  640|     10|    if (!d->quiet)
  ------------------
  |  Branch (640:9): [True: 0, False: 10]
  ------------------
  641|      0|	REprintf("Read %lld item%s\n", (long long) n, (n == 1) ? "" : "s");
  ------------------
  |  Branch (641:48): [True: 0, False: 0]
  ------------------
  642|     10|    if (d->ttyflag) ConsolePrompt[0] = '\0';
  ------------------
  |  Branch (642:9): [True: 0, False: 10]
  ------------------
  643|       |
  644|     10|    if (n == 0) {
  ------------------
  |  Branch (644:9): [True: 0, False: 10]
  ------------------
  645|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  646|      0|	R_FreeStringBuffer(&strBuf);
  647|      0|	d->sbuf = NULL;
  648|      0|	return allocVector(type,0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
  649|      0|    }
  650|     10|    if (n == maxitems) {
  ------------------
  |  Branch (650:9): [True: 0, False: 10]
  ------------------
  651|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  652|      0|	R_FreeStringBuffer(&strBuf);
  653|      0|	d->sbuf = NULL;
  654|      0|	return ans;
  655|      0|    }
  656|       |
  657|     10|    bns = allocVector(type, n);
  ------------------
  |  |  875|     10|#define allocVector		Rf_allocVector
  ------------------
  658|     10|    switch (type) {
  659|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (659:5): [True: 0, False: 10]
  ------------------
  660|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (660:5): [True: 0, False: 10]
  ------------------
  661|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (661:14): [True: 0, False: 0]
  ------------------
  662|      0|	    INTEGER(bns)[i] = INTEGER(ans)[i];
  663|      0|	break;
  664|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (664:5): [True: 0, False: 10]
  ------------------
  665|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (665:14): [True: 0, False: 0]
  ------------------
  666|      0|	    REAL(bns)[i] = REAL(ans)[i];
  667|      0|	break;
  668|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (668:5): [True: 0, False: 10]
  ------------------
  669|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (669:14): [True: 0, False: 0]
  ------------------
  670|      0|	    COMPLEX(bns)[i] = COMPLEX(ans)[i];
  671|      0|	break;
  672|     10|    case STRSXP:
  ------------------
  |  |  126|     10|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (672:5): [True: 10, False: 0]
  ------------------
  673|     78|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (673:14): [True: 68, False: 10]
  ------------------
  674|     68|	    SET_STRING_ELT(bns, i, STRING_ELT(ans, i));
  675|     10|	break;
  676|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (676:5): [True: 0, False: 10]
  ------------------
  677|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (677:14): [True: 0, False: 0]
  ------------------
  678|      0|	    RAW(bns)[i] = RAW(ans)[i];
  679|      0|	break;
  680|      0|    default:
  ------------------
  |  Branch (680:5): [True: 0, False: 10]
  ------------------
  681|      0|	UNIMPLEMENTED_TYPEt("scanVector", type);
  682|     10|    }
  683|     10|    UNPROTECT(1);
  ------------------
  |  |  358|     10|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  684|     10|    R_FreeStringBuffer(&strBuf);
  685|       |    d->sbuf = NULL;
  686|     10|    return bns;
  687|     10|}
scan.c:fillBuffer:
  342|    170|{
  343|       |/* The basic reader function, called from scanVector() and scanFrame().
  344|       |   Reads into _buffer_	which later will be read out by extractItem().
  345|       |
  346|       |   bch is used to distinguish \r, \n and EOF from more input available.
  347|       |*/
  348|    170|    char *bufp;
  349|    170|    int c, quote, filled, nbuf = MAXELTSIZE, m, mm = 0;
  ------------------
  |  |   85|    170|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
  350|    170|    bool dbcslocale = (R_MB_CUR_MAX == 2) && !d->isUTF8 && !d->isLatin1;
  ------------------
  |  Branch (350:23): [True: 0, False: 170]
  |  Branch (350:46): [True: 0, False: 0]
  |  Branch (350:60): [True: 0, False: 0]
  ------------------
  351|       |
  352|    170|    m = 0;
  353|    170|    filled = 1;
  354|    170|    if (d->sepchar == 0) {
  ------------------
  |  Branch (354:9): [True: 0, False: 170]
  ------------------
  355|       |	/* skip all space or tabs: only look at lead bytes here */
  356|      0|	strip = 0; /* documented to be ignored in this case */
  357|      0|	while ((c = scanchar(false, d)) == ' ' || c == '\t') ;
  ------------------
  |  Branch (357:9): [True: 0, False: 0]
  |  Branch (357:44): [True: 0, False: 0]
  ------------------
  358|      0|	if (c == '\n' || c == '\r' || c == R_EOF) {
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (358:6): [True: 0, False: 0]
  |  Branch (358:19): [True: 0, False: 0]
  |  Branch (358:32): [True: 0, False: 0]
  ------------------
  359|      0|	    filled = c;
  360|      0|	    goto donefill;
  361|      0|	}
  362|      0|	if ((type == STRSXP || type == NILSXP) && strchr(d->quoteset, c)) {
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
              	if ((type == STRSXP || type == NILSXP) && strchr(d->quoteset, c)) {
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (362:7): [True: 0, False: 0]
  |  Branch (362:25): [True: 0, False: 0]
  |  Branch (362:44): [True: 0, False: 0]
  ------------------
  363|      0|	    quote = c;
  364|      0|	    while ((c = scanchar(true, d)) != R_EOF && c != quote) {
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (364:13): [True: 0, False: 0]
  |  Branch (364:49): [True: 0, False: 0]
  ------------------
  365|      0|		if (m >= nbuf - 3) {
  ------------------
  |  Branch (365:7): [True: 0, False: 0]
  ------------------
  366|      0|		    nbuf *= 2;
  367|      0|		    R_AllocStringBuffer(nbuf, buffer);
  368|      0|		}
  369|      0|		if (c == '\\') {
  ------------------
  |  Branch (369:7): [True: 0, False: 0]
  ------------------
  370|       |		    /* If this is an embedded quote, unquote it, but
  371|       |		       otherwise keep backslashes */
  372|      0|		    c = scanchar(true, d);
  373|      0|		    if (c == R_EOF) break;
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (373:11): [True: 0, False: 0]
  ------------------
  374|      0|		    if(c != quote) buffer->data[m++] = '\\';
  ------------------
  |  Branch (374:10): [True: 0, False: 0]
  ------------------
  375|      0|		}
  376|      0|		buffer->data[m++] = (char) c;
  377|      0|		if(dbcslocale && btowc(c) == WEOF)
  ------------------
  |  Branch (377:6): [True: 0, False: 0]
  |  Branch (377:20): [True: 0, False: 0]
  ------------------
  378|      0|		    buffer->data[m++] = (char) scanchar2(d);
  379|      0|	    }
  380|      0|	    if (c == R_EOF)
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (380:10): [True: 0, False: 0]
  ------------------
  381|      0|		warning(_("EOF within quoted string"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		warning(_("EOF within quoted string"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  382|      0|	    c = scanchar(false, d);
  383|      0|	    mm = m;
  384|      0|	}
  385|      0|	else { /* not a quoted char string */
  386|      0|	    do {
  387|      0|		if (m >= nbuf - 3) {
  ------------------
  |  Branch (387:7): [True: 0, False: 0]
  ------------------
  388|      0|		    nbuf *= 2;
  389|      0|		    R_AllocStringBuffer(nbuf, buffer);
  390|      0|		}
  391|      0|		buffer->data[m++] = (char) c;
  392|      0|		if(dbcslocale && btowc(c) == WEOF)
  ------------------
  |  Branch (392:6): [True: 0, False: 0]
  |  Branch (392:20): [True: 0, False: 0]
  ------------------
  393|      0|		    buffer->data[m++] = (char) scanchar2(d);
  394|      0|		c = scanchar(false, d);
  395|      0|	    } while (!Rspace(c) && c != R_EOF);
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (395:15): [True: 0, False: 0]
  |  Branch (395:29): [True: 0, False: 0]
  ------------------
  396|      0|	}
  397|       |	/* skip all space or tabs: only look at lead bytes here */
  398|      0|	while (c == ' ' || c == '\t') c = scanchar(false, d);
  ------------------
  |  Branch (398:9): [True: 0, False: 0]
  |  Branch (398:21): [True: 0, False: 0]
  ------------------
  399|      0|	if (c == '\n' || c == '\r' || c == R_EOF)
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (399:6): [True: 0, False: 0]
  |  Branch (399:19): [True: 0, False: 0]
  |  Branch (399:32): [True: 0, False: 0]
  ------------------
  400|      0|	    filled = c;
  401|      0|	else
  402|      0|	    unscanchar(c, d);
  403|      0|    }
  404|    170|    else { /* have separator */
  405|  1.39k|	while ((c = scanchar(false, d)) != d->sepchar &&
  ------------------
  |  Branch (405:9): [True: 1.26k, False: 130]
  ------------------
  406|  1.26k|	       c != '\n' && c != '\r' && c != R_EOF)
  ------------------
  |  | 1531|  1.24k|#define R_EOF	-1
  ------------------
  |  Branch (406:9): [True: 1.24k, False: 26]
  |  Branch (406:22): [True: 1.24k, False: 0]
  |  Branch (406:35): [True: 1.23k, False: 2]
  ------------------
  407|  1.23k|	    {
  408|       |		/* eat white space */
  409|  1.23k|		if (type != STRSXP)
  ------------------
  |  |  126|  1.23k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (409:7): [True: 246, False: 992]
  ------------------
  410|    246|		    while (c == ' ' || c == '\t')
  ------------------
  |  Branch (410:14): [True: 0, False: 246]
  |  Branch (410:26): [True: 0, False: 246]
  ------------------
  411|      0|			if ((c = scanchar(false, d)) == d->sepchar
  ------------------
  |  Branch (411:8): [True: 0, False: 0]
  ------------------
  412|      0|			    || c == '\n' || c == '\r' || c == R_EOF) {
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (412:11): [True: 0, False: 0]
  |  Branch (412:24): [True: 0, False: 0]
  |  Branch (412:37): [True: 0, False: 0]
  ------------------
  413|      0|			    filled = c;
  414|      0|			    goto donefill;
  415|      0|			}
  416|       |		/* CSV style quoted string handling */
  417|  1.23k|		if ((type == STRSXP || type == NILSXP)
  ------------------
  |  |  126|  2.47k|#define STRSXP	    16	  /* string vectors */
  ------------------
              		if ((type == STRSXP || type == NILSXP)
  ------------------
  |  |  111|    246|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (417:8): [True: 992, False: 246]
  |  Branch (417:26): [True: 0, False: 246]
  ------------------
  418|    992|		    && c != 0 && strchr(d->quoteset, c)) {
  ------------------
  |  Branch (418:10): [True: 992, False: 0]
  |  Branch (418:20): [True: 12, False: 980]
  ------------------
  419|     12|		    quote = c;
  420|     12|		inquote:
  421|    184|		    while ((c = scanchar(true, d)) != R_EOF && c != quote) {
  ------------------
  |  | 1531|    368|#define R_EOF	-1
  ------------------
  |  Branch (421:14): [True: 184, False: 0]
  |  Branch (421:50): [True: 172, False: 12]
  ------------------
  422|    172|			if (m >= nbuf - 3) {
  ------------------
  |  Branch (422:8): [True: 0, False: 172]
  ------------------
  423|      0|			    nbuf *= 2;
  424|      0|			    R_AllocStringBuffer(nbuf, buffer);
  425|      0|			}
  426|    172|			buffer->data[m++] = (char) c;
  427|    172|			if(dbcslocale && btowc(c) == WEOF)
  ------------------
  |  Branch (427:7): [True: 0, False: 172]
  |  Branch (427:21): [True: 0, False: 0]
  ------------------
  428|      0|			    buffer->data[m++] = (char) scanchar2(d);
  429|    172|		    }
  430|     12|		    if (c == R_EOF)
  ------------------
  |  | 1531|     12|#define R_EOF	-1
  ------------------
  |  Branch (430:11): [True: 0, False: 12]
  ------------------
  431|      0|			warning(_("EOF within quoted string"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              			warning(_("EOF within quoted string"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  432|     12|		    c = scanchar(true, d); /* only peek at lead byte
  433|       |					      unless ASCII */
  434|     12|		    if (c == quote) {
  ------------------
  |  Branch (434:11): [True: 0, False: 12]
  ------------------
  435|      0|			if (m >= nbuf - 3) {
  ------------------
  |  Branch (435:8): [True: 0, False: 0]
  ------------------
  436|      0|			    nbuf *= 2;
  437|      0|			    R_AllocStringBuffer(nbuf, buffer);
  438|      0|			}
  439|      0|			buffer->data[m++] = (char) quote;
  440|      0|			goto inquote; /* FIXME: Ick! Clean up logic */
  441|      0|		    }
  442|     12|		    mm = m;
  443|     12|		    if (c == d->sepchar || c == '\n' || c == '\r' || c == R_EOF){
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (443:11): [True: 12, False: 0]
  |  Branch (443:30): [True: 0, False: 0]
  |  Branch (443:43): [True: 0, False: 0]
  |  Branch (443:56): [True: 0, False: 0]
  ------------------
  444|     12|			filled = c;
  445|     12|			goto donefill;
  446|     12|		    }
  447|      0|		    else {
  448|      0|			unscanchar(c, d);
  449|      0|			continue;
  450|      0|		    }
  451|     12|		} /* end of CSV-style quote handling */
  452|  1.22k|		if (!strip || m > 0 || !Rspace(c)) { /* only lead byte */
  ------------------
  |  Branch (452:7): [True: 1.13k, False: 90]
  |  Branch (452:17): [True: 78, False: 12]
  |  Branch (452:26): [True: 12, False: 0]
  ------------------
  453|  1.22k|		    if (m >= nbuf - 3) {
  ------------------
  |  Branch (453:11): [True: 0, False: 1.22k]
  ------------------
  454|      0|			nbuf *= 2;
  455|      0|			R_AllocStringBuffer(nbuf, buffer);
  456|      0|		    }
  457|  1.22k|		    buffer->data[m++] = (char) c;
  458|  1.22k|		    if(dbcslocale && btowc(c) == WEOF)
  ------------------
  |  Branch (458:10): [True: 0, False: 1.22k]
  |  Branch (458:24): [True: 0, False: 0]
  ------------------
  459|      0|			buffer->data[m++] = (char) scanchar2(d);
  460|  1.22k|		}
  461|  1.22k|	    }
  462|    158|	filled = c; /* last lead byte in a DBCS */
  463|    158|    }
  464|    170| donefill:
  465|       |    /* strip trailing white space, if desired and if item is non-null */
  466|    170|    bufp = &buffer->data[m];
  467|    170|    if (strip && m > mm) {
  ------------------
  |  Branch (467:9): [True: 12, False: 158]
  |  Branch (467:18): [True: 12, False: 0]
  ------------------
  468|     12|	do {c = (int)*--bufp;} while(m-- > mm && Rspace(c));
  ------------------
  |  Branch (468:31): [True: 12, False: 0]
  |  Branch (468:43): [True: 0, False: 12]
  ------------------
  469|     12|	bufp++;
  470|     12|    }
  471|    170|    *bufp = '\0';
  472|       |    /* Remove UTF-8 BOM */
  473|    170|    if(d->atStart && utf8locale &&
  ------------------
  |  Branch (473:8): [True: 12, False: 158]
  |  Branch (473:22): [True: 0, False: 12]
  ------------------
  474|      0|       !strncmp(buffer->data, "\xef\xbb\xbf", 3))
  ------------------
  |  Branch (474:8): [True: 0, False: 0]
  ------------------
  475|      0|	memmove(buffer->data, buffer->data+3, strlen(buffer->data+3) + 1);
  476|    170|    d->atStart = false;
  477|    170|    *bch = filled;
  478|    170|    return buffer->data;
  479|    170|}
scan.c:Rspace:
  100|     24|{
  101|     24|    if (c == ' ' || c == '\t' || c == '\n' || c == '\r') return true;
  ------------------
  |  Branch (101:9): [True: 0, False: 24]
  |  Branch (101:21): [True: 0, False: 24]
  |  Branch (101:34): [True: 0, False: 24]
  |  Branch (101:47): [True: 0, False: 24]
  ------------------
  102|       |#ifdef Win32
  103|       |    /* 0xa0 is NBSP in all 8-bit Windows locales */
  104|       |    if(!mbcslocale && c == 0xa0) return true;
  105|       |#else
  106|       |     /* 0xa0 is NBSP in Latin-1 */
  107|     24|    if(known_to_be_latin1 && c == 0xa0) return true;
  ------------------
  |  Branch (107:8): [True: 0, False: 24]
  |  Branch (107:30): [True: 0, False: 0]
  ------------------
  108|     24|#endif
  109|     24|    return false;
  110|     24|}
scan.c:extractItem:
  505|    166|{
  506|    166|    char *endp;
  507|    166|    switch(TYPEOF(ans)) {
  508|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (508:5): [True: 0, False: 166]
  ------------------
  509|      0|	break;
  510|     56|    case LGLSXP:
  ------------------
  |  |  121|     56|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (510:5): [True: 56, False: 110]
  ------------------
  511|     56|	if (isNAstring(buffer, 0, d))
  ------------------
  |  Branch (511:6): [True: 0, False: 56]
  ------------------
  512|      0|	    LOGICAL(ans)[i] = NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  513|     56|	else {
  514|     56|	    int tr = StringTrue(buffer), fa = StringFalse(buffer);
  ------------------
  |  |   52|     56|#define StringTrue    Rf_StringTrue
  ------------------
              	    int tr = StringTrue(buffer), fa = StringFalse(buffer);
  ------------------
  |  |   51|     56|#define StringFalse   Rf_StringFalse
  ------------------
  515|     56|	    if(tr || fa) LOGICAL(ans)[i] = tr;
  ------------------
  |  Branch (515:9): [True: 34, False: 22]
  |  Branch (515:15): [True: 22, False: 0]
  ------------------
  516|      0|	    else expected("a logical", buffer, d);
  517|     56|	}
  518|     56|	break;
  519|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (519:5): [True: 0, False: 166]
  ------------------
  520|      0|	if (isNAstring(buffer, 0, d))
  ------------------
  |  Branch (520:6): [True: 0, False: 0]
  ------------------
  521|      0|	    INTEGER(ans)[i] = NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  522|      0|	else {
  523|      0|	    INTEGER(ans)[i] = Strtoi(buffer, 10);
  524|      0|	    if (INTEGER(ans)[i] == NA_INTEGER)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (524:10): [True: 0, False: 0]
  ------------------
  525|      0|		expected("an integer", buffer, d);
  526|      0|	}
  527|      0|	break;
  528|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (528:5): [True: 0, False: 166]
  ------------------
  529|      0|	if (isNAstring(buffer, 0, d))
  ------------------
  |  Branch (529:6): [True: 0, False: 0]
  ------------------
  530|      0|	    REAL(ans)[i] = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  531|      0|	else {
  532|      0|	    REAL(ans)[i] = Strtod(buffer, &endp, false, d);
  533|      0|	    if (!isBlankString(endp))
  ------------------
  |  |   53|      0|#define isBlankString Rf_isBlankString
  ------------------
  |  Branch (533:10): [True: 0, False: 0]
  ------------------
  534|      0|		expected("a real", buffer, d);
  535|      0|	}
  536|      0|	break;
  537|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (537:5): [True: 0, False: 166]
  ------------------
  538|      0|	if (isNAstring(buffer, 0, d))
  ------------------
  |  Branch (538:6): [True: 0, False: 0]
  ------------------
  539|      0|	    COMPLEX(ans)[i].r = COMPLEX(ans)[i].i = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  540|      0|	else {
  541|      0|	    COMPLEX(ans)[i] = strtoc(buffer, &endp, false, d);
  542|      0|	    if (!isBlankString(endp))
  ------------------
  |  |   53|      0|#define isBlankString Rf_isBlankString
  ------------------
  |  Branch (542:10): [True: 0, False: 0]
  ------------------
  543|      0|		expected("a complex", buffer, d);
  544|      0|	}
  545|      0|	break;
  546|    110|    case STRSXP:
  ------------------
  |  |  126|    110|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (546:5): [True: 110, False: 56]
  ------------------
  547|    110|	if (isNAstring(buffer, 1, d))
  ------------------
  |  Branch (547:6): [True: 0, False: 110]
  ------------------
  548|      0|	    SET_STRING_ELT(ans, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  549|    110|	else
  550|    110|	    SET_STRING_ELT(ans, i, insertString(buffer, d));
  551|    110|	break;
  552|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (552:5): [True: 0, False: 166]
  ------------------
  553|      0|	if (isNAstring(buffer, 0, d))
  ------------------
  |  Branch (553:6): [True: 0, False: 0]
  ------------------
  554|      0|	    RAW(ans)[i] = 0;
  555|      0|	else {
  556|      0|	    RAW(ans)[i] = strtoraw(buffer, &endp);
  557|      0|	    if (!isBlankString(endp))
  ------------------
  |  |   53|      0|#define isBlankString Rf_isBlankString
  ------------------
  |  Branch (557:10): [True: 0, False: 0]
  ------------------
  558|      0|		expected("a raw", buffer, d);
  559|      0|	}
  560|      0|	break;
  561|      0|    default:
  ------------------
  |  Branch (561:5): [True: 0, False: 166]
  ------------------
  562|      0|	UNIMPLEMENTED_TYPE("extractItem", ans);
  563|    166|    }
  564|    166|}
scan.c:isNAstring:
  485|    166|{
  486|    166|    int i;
  487|       |
  488|    166|    if(!mode && strlen(buf) == 0) return 1;
  ------------------
  |  Branch (488:8): [True: 56, False: 110]
  |  Branch (488:17): [True: 0, False: 56]
  ------------------
  489|    320|    for (i = 0; i < length(d->NAstrings); i++)
  ------------------
  |  |  987|    320|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (489:17): [True: 154, False: 166]
  ------------------
  490|    154|	if (!strcmp(CHAR(STRING_ELT(d->NAstrings, i)), buf)) return 1;
  ------------------
  |  |  203|    154|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (490:6): [True: 0, False: 154]
  ------------------
  491|    166|    return 0;
  492|    166|}
scan.c:insertString:
   92|    110|{
   93|    110|    cetype_t enc = CE_NATIVE;
   94|    110|    if (l->con->UTF8out || l->isUTF8) enc = CE_UTF8;
  ------------------
  |  Branch (94:9): [True: 0, False: 110]
  |  Branch (94:28): [True: 0, False: 110]
  ------------------
   95|    110|    else if (l->isLatin1) enc = CE_LATIN1;
  ------------------
  |  Branch (95:14): [True: 0, False: 110]
  ------------------
   96|    110|    return mkCharCE(str, enc);
  ------------------
  |  |  999|    110|#define mkCharCE		Rf_mkCharCE
  ------------------
   97|    110|}
scan.c:scanFrame:
  693|      2|{
  694|      2|    SEXP ans, new, old, w;
  695|      2|    char *buffer = NULL;
  696|      2|    int c, strip, bch, ic;
  697|      2|    R_xlen_t blksize, i, ii, j, n, nc, linesread, colsread;
  698|      2|    R_xlen_t badline;
  699|      2|    R_StringBuffer buf = {NULL, 0, MAXELTSIZE};
  ------------------
  |  |   85|      2|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
  700|       |
  701|      2|    nc = xlength(what);
  ------------------
  |  | 1049|      2|#define xlength(x)		Rf_xlength(x)
  ------------------
  702|      2|    if (!nc) {
  ------------------
  |  Branch (702:9): [True: 0, False: 2]
  ------------------
  703|      0|	    error(_("empty 'what' specified"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("empty 'what' specified"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  704|      0|    }
  705|       |
  706|      2|    if (maxitems > 0) blksize = maxitems;
  ------------------
  |  Branch (706:9): [True: 0, False: 2]
  ------------------
  707|      2|    else if (maxlines > 0) blksize = maxlines;
  ------------------
  |  Branch (707:14): [True: 0, False: 2]
  ------------------
  708|      2|    else blksize = SCAN_BLOCKSIZE;
  ------------------
  |  |   52|      2|#define SCAN_BLOCKSIZE		1000
  ------------------
  709|       |
  710|      2|    R_AllocStringBuffer(0, &buf);
  711|      2|    d->sbuf = &buf;
  712|      2|    PROTECT(ans = allocVector(VECSXP, nc));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
  713|     16|    for (i = 0; i < nc; i++) {
  ------------------
  |  Branch (713:17): [True: 14, False: 2]
  ------------------
  714|     14|	w = VECTOR_ELT(what, i);
  715|     14|	if (!isNull(w)) {
  ------------------
  |  |  956|     14|#define isNull			Rf_isNull
  ------------------
  |  Branch (715:6): [True: 14, False: 0]
  ------------------
  716|     14|	    if (!isVector(w)) {
  ------------------
  |  |  974|     14|#define isVector		Rf_isVector
  ------------------
  |  Branch (716:10): [True: 0, False: 14]
  ------------------
  717|      0|		error(_("invalid '%s' argument"), "what");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("invalid '%s' argument"), "what");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  718|      0|	    }
  719|     14|	    SET_VECTOR_ELT(ans, i, allocVector(TYPEOF(w), blksize));
  ------------------
  |  |  875|     14|#define allocVector		Rf_allocVector
  ------------------
  720|     14|	}
  721|     14|    }
  722|      2|    setAttrib(ans, R_NamesSymbol, getAttrib(what, R_NamesSymbol));
  ------------------
  |  | 1027|      2|#define setAttrib		Rf_setAttrib
  ------------------
                  setAttrib(ans, R_NamesSymbol, getAttrib(what, R_NamesSymbol));
  ------------------
  |  |  924|      2|#define getAttrib		Rf_getAttrib
  ------------------
  723|       |
  724|      2|    n = 0; linesread = 0; colsread = 0; ii = 0;
  725|      2|    badline = 0;
  726|      2|    bch = 1;
  727|      2|    c = 0;			/* -Wall */
  728|       |
  729|      2|    if (d->ttyflag)
  ------------------
  |  Branch (729:9): [True: 0, False: 2]
  ------------------
  730|      0|	snprintf(ConsolePrompt, CONSOLE_PROMPT_SIZE, "1: ");
  ------------------
  |  |   55|      0|#define CONSOLE_PROMPT_SIZE	256
  ------------------
  731|       |
  732|       |    // we checked its type in do_scan
  733|      2|    int *lstrip = LOGICAL(stripwhite);
  734|      2|    bool vec_strip = (xlength(stripwhite) == xlength(what));
  ------------------
  |  | 1049|      2|#define xlength(x)		Rf_xlength(x)
  ------------------
                  bool vec_strip = (xlength(stripwhite) == xlength(what));
  ------------------
  |  | 1049|      2|#define xlength(x)		Rf_xlength(x)
  ------------------
  735|      2|    strip = lstrip[0];
  736|       |
  737|      2|    ic = 999;
  738|    102|    for (;;) {
  739|    102|	if(!ic) {
  ------------------
  |  Branch (739:5): [True: 0, False: 102]
  ------------------
  740|      0|	    R_CheckUserInterrupt();
  741|      0|	    ic = 999;
  742|      0|	}
  743|       |
  744|    102|	if (bch == R_EOF) {
  ------------------
  |  | 1531|    102|#define R_EOF	-1
  ------------------
  |  Branch (744:6): [True: 0, False: 102]
  ------------------
  745|      0|	    if (d->ttyflag) R_ClearerrConsole();
  ------------------
  |  Branch (745:10): [True: 0, False: 0]
  ------------------
  746|      0|	    goto done;
  747|      0|	}
  748|    102|	else if (bch == '\n') {
  ------------------
  |  Branch (748:11): [True: 16, False: 86]
  ------------------
  749|     16|	    ic--;
  750|     16|	    linesread++;
  751|     16|	    if (colsread != 0) {
  ------------------
  |  Branch (751:10): [True: 0, False: 16]
  ------------------
  752|      0|		if (fill) {
  ------------------
  |  Branch (752:7): [True: 0, False: 0]
  ------------------
  753|      0|		    buffer[0] = '\0';
  754|      0|		    for (ii = colsread; ii < nc; ii++) {
  ------------------
  |  Branch (754:27): [True: 0, False: 0]
  ------------------
  755|      0|			extractItem(buffer, VECTOR_ELT(ans, ii), n, d);
  756|      0|		    }
  757|      0|		    n++;
  758|      0|		    ii = 0;
  759|      0|		    colsread = 0;
  760|      0|		} else if (!badline && !multiline)
  ------------------
  |  Branch (760:14): [True: 0, False: 0]
  |  Branch (760:26): [True: 0, False: 0]
  ------------------
  761|      0|		    badline = linesread;
  762|      0|		if(badline && !multiline)
  ------------------
  |  Branch (762:6): [True: 0, False: 0]
  |  Branch (762:17): [True: 0, False: 0]
  ------------------
  763|      0|		error(_("line %lld did not have %lld elements"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("line %lld did not have %lld elements"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  764|      0|		    (long long) badline, (long long) nc);
  765|      0|	    }
  766|     16|	    if (maxitems > 0 && n >= maxitems)
  ------------------
  |  Branch (766:10): [True: 0, False: 16]
  |  Branch (766:26): [True: 0, False: 0]
  ------------------
  767|      0|		goto done;
  768|     16|	    if (maxlines > 0 && linesread == maxlines)
  ------------------
  |  Branch (768:10): [True: 0, False: 16]
  |  Branch (768:26): [True: 0, False: 0]
  ------------------
  769|      0|		goto done;
  770|     16|	    if (d->ttyflag)
  ------------------
  |  Branch (770:10): [True: 0, False: 16]
  ------------------
  771|      0|		snprintf(ConsolePrompt, CONSOLE_PROMPT_SIZE,
  ------------------
  |  |   55|      0|#define CONSOLE_PROMPT_SIZE	256
  ------------------
  772|      0|		         "%lld: ", (long long) (n + 1));
  773|     16|	}
  774|    102|	if (n == blksize && colsread == 0) {
  ------------------
  |  Branch (774:6): [True: 0, False: 102]
  |  Branch (774:22): [True: 0, False: 0]
  ------------------
  775|      0|	    if(blksize > R_XLEN_T_MAX/2) error(_("too many items"));
  ------------------
  |  |   76|      0|# define R_XLEN_T_MAX 4503599627370496
  ------------------
              	    if(blksize > R_XLEN_T_MAX/2) error(_("too many items"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    if(blksize > R_XLEN_T_MAX/2) error(_("too many items"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (775:9): [True: 0, False: 0]
  ------------------
  776|      0|	    blksize = 2 * blksize;
  777|      0|	    for (i = 0; i < nc; i++) {
  ------------------
  |  Branch (777:18): [True: 0, False: 0]
  ------------------
  778|      0|		old = VECTOR_ELT(ans, i);
  779|      0|		if(!isNull(old)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (779:6): [True: 0, False: 0]
  ------------------
  780|      0|		    new = allocVector(TYPEOF(old), blksize);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
  781|      0|		    copyVector(new, old);
  ------------------
  |  |  902|      0|#define copyVector		Rf_copyVector
  ------------------
  782|      0|		    SET_VECTOR_ELT(ans, i, new);
  783|      0|		}
  784|      0|	    }
  785|      0|	}
  786|       |
  787|    102|	if (vec_strip) strip = lstrip[colsread];
  ------------------
  |  Branch (787:6): [True: 0, False: 102]
  ------------------
  788|    102|	buffer = fillBuffer(TYPEOF(VECTOR_ELT(ans, ii)), strip, &bch, d, &buf);
  789|    102|	if (colsread == 0 &&
  ------------------
  |  Branch (789:6): [True: 18, False: 84]
  ------------------
  790|     18|	    strlen(buffer) == 0 &&
  ------------------
  |  Branch (790:6): [True: 4, False: 14]
  ------------------
  791|      4|	    ((blskip && bch =='\n') || bch == R_EOF)) {
  ------------------
  |  | 1531|      2|#define R_EOF	-1
  ------------------
  |  Branch (791:8): [True: 4, False: 0]
  |  Branch (791:18): [True: 2, False: 2]
  |  Branch (791:33): [True: 2, False: 0]
  ------------------
  792|      4|	    if (d->ttyflag || bch == R_EOF)
  ------------------
  |  | 1531|      4|#define R_EOF	-1
  ------------------
  |  Branch (792:10): [True: 0, False: 4]
  |  Branch (792:24): [True: 2, False: 2]
  ------------------
  793|      2|		break;
  794|      4|	}
  795|     98|	else {
  796|     98|	    extractItem(buffer, VECTOR_ELT(ans, ii), n, d);
  797|     98|	    ii++;
  798|     98|	    colsread++;
  799|       |	    /* increment n and reset i after filling a row */
  800|     98|	    if (colsread == nc) {
  ------------------
  |  Branch (800:10): [True: 14, False: 84]
  ------------------
  801|     14|		n++;
  802|     14|		ii = 0;
  803|     14|		colsread = 0;
  804|     14|		if (flush && (bch != '\n') && (bch != R_EOF)) { /* MBCS-safe */
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (804:7): [True: 0, False: 14]
  |  Branch (804:16): [True: 0, False: 0]
  |  Branch (804:33): [True: 0, False: 0]
  ------------------
  805|      0|		    while ((c = scanchar(false, d)) != '\n' && c != R_EOF);
  ------------------
  |  | 1531|      0|#define R_EOF	-1
  ------------------
  |  Branch (805:14): [True: 0, False: 0]
  |  Branch (805:50): [True: 0, False: 0]
  ------------------
  806|      0|		    bch = c;
  807|      0|		}
  808|     14|	    }
  809|     98|	}
  810|    102|    }
  811|       |
  812|      2| done:
  813|      2|    if (colsread != 0) {
  ------------------
  |  Branch (813:9): [True: 0, False: 2]
  ------------------
  814|      0|	if (!fill)
  ------------------
  |  Branch (814:6): [True: 0, False: 0]
  ------------------
  815|      0|	    warning(_("number of items read is not a multiple of the number of columns"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("number of items read is not a multiple of the number of columns"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  816|      0|	buffer[0] = '\0';	/* this is an NA */
  817|      0|	for (ii = colsread; ii < nc; ii++) {
  ------------------
  |  Branch (817:22): [True: 0, False: 0]
  ------------------
  818|      0|	    extractItem(buffer, VECTOR_ELT(ans, ii), n, d);
  819|      0|	}
  820|      0|	n++;
  821|      0|    }
  822|      2|    if (!d->quiet)
  ------------------
  |  Branch (822:9): [True: 0, False: 2]
  ------------------
  823|      0|	REprintf("Read %lld record%s\n", (long long) n, (n == 1) ? "" : "s");
  ------------------
  |  Branch (823:50): [True: 0, False: 0]
  ------------------
  824|      2|    if (d->ttyflag) ConsolePrompt[0] = '\0';
  ------------------
  |  Branch (824:9): [True: 0, False: 2]
  ------------------
  825|       |
  826|     16|    for (i = 0; i < nc; i++) {
  ------------------
  |  Branch (826:17): [True: 14, False: 2]
  ------------------
  827|     14|	old = VECTOR_ELT(ans, i);
  828|     14|	new = allocVector(TYPEOF(old), n);
  ------------------
  |  |  875|     14|#define allocVector		Rf_allocVector
  ------------------
  829|     14|	switch (TYPEOF(old)) {
  830|      8|	case LGLSXP:
  ------------------
  |  |  121|      8|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (830:2): [True: 8, False: 6]
  ------------------
  831|      8|	case INTSXP:
  ------------------
  |  |  123|      8|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (831:2): [True: 0, False: 14]
  ------------------
  832|     64|	    for (j = 0; j < n; j++)
  ------------------
  |  Branch (832:18): [True: 56, False: 8]
  ------------------
  833|     56|		INTEGER(new)[j] = INTEGER(old)[j];
  834|      8|	    break;
  835|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (835:2): [True: 0, False: 14]
  ------------------
  836|      0|	    for (j = 0; j < n; j++)
  ------------------
  |  Branch (836:18): [True: 0, False: 0]
  ------------------
  837|      0|		REAL(new)[j] = REAL(old)[j];
  838|      0|	    break;
  839|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (839:2): [True: 0, False: 14]
  ------------------
  840|      0|	    for (j = 0; j < n; j++)
  ------------------
  |  Branch (840:18): [True: 0, False: 0]
  ------------------
  841|      0|		COMPLEX(new)[j] = COMPLEX(old)[j];
  842|      0|	    break;
  843|      6|	case STRSXP:
  ------------------
  |  |  126|      6|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (843:2): [True: 6, False: 8]
  ------------------
  844|     48|	    for (j = 0; j < n; j++)
  ------------------
  |  Branch (844:18): [True: 42, False: 6]
  ------------------
  845|     42|		SET_STRING_ELT(new, j, STRING_ELT(old, j));
  846|      6|	    break;
  847|      0|	case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (847:2): [True: 0, False: 14]
  ------------------
  848|      0|	    for (j = 0; j < n; j++)
  ------------------
  |  Branch (848:18): [True: 0, False: 0]
  ------------------
  849|      0|		RAW(new)[j] = RAW(old)[j];
  850|      0|	    break;
  851|      0|	case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (851:2): [True: 0, False: 14]
  ------------------
  852|      0|	    break;
  853|      0|	default:
  ------------------
  |  Branch (853:2): [True: 0, False: 14]
  ------------------
  854|      0|	    UNIMPLEMENTED_TYPE("scanFrame", old);
  855|     14|	}
  856|     14|	SET_VECTOR_ELT(ans, i, new);
  857|     14|    }
  858|      2|    UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  859|      2|    R_FreeStringBuffer(&buf);
  860|       |    d->sbuf = NULL;
  861|      2|    return ans;
  862|      2|}

do_colon:
  143|      2|{
  144|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  145|      2|    SEXP s1 = CAR(args),
  146|      2|	s2 = CADR(args);
  147|      2|    if (inherits(s1, "factor") && inherits(s2, "factor"))
  ------------------
  |  |  933|      2|#define inherits		Rf_inherits
  ------------------
                  if (inherits(s1, "factor") && inherits(s2, "factor"))
  ------------------
  |  |  933|      0|#define inherits		Rf_inherits
  ------------------
  |  Branch (147:9): [True: 0, False: 2]
  |  Branch (147:35): [True: 0, False: 0]
  ------------------
  148|      0|	return(cross_colon(call, s1, s2));
  149|      2|    double
  150|      2|	n1 = length(s1),
  ------------------
  |  |  987|      2|#define length(x)		Rf_length(x)
  ------------------
  151|      2|	n2 = length(s2);
  ------------------
  |  |  987|      2|#define length(x)		Rf_length(x)
  ------------------
  152|      2|    if (n1 != 1 || n2 != 1) {
  ------------------
  |  Branch (152:9): [True: 0, False: 2]
  |  Branch (152:20): [True: 0, False: 2]
  ------------------
  153|      0|	if (n1 == 0 || n2 == 0)
  ------------------
  |  Branch (153:6): [True: 0, False: 0]
  |  Branch (153:17): [True: 0, False: 0]
  ------------------
  154|      0|	    errorcall(call, _("argument of length 0"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("argument of length 0"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  155|      0|	char *check = getenv("_R_CHECK_LENGTH_COLON_");
  156|      0|	if (check ? StringTrue(check) : false) // warn by default
  ------------------
  |  |   52|      0|#define StringTrue    Rf_StringTrue
  ------------------
  |  Branch (156:6): [True: 0, False: 0]
  |  Branch (156:6): [True: 0, False: 0]
  ------------------
  157|      0|	    errorcall(call, _("numerical expression has length > 1"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("numerical expression has length > 1"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  158|      0|	else
  159|      0|	    warningcall(call, _("numerical expression has %d elements: only the first used"),
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              	    warningcall(call, _("numerical expression has %d elements: only the first used"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  160|      0|			(n1 > 1) ? (int) n1 : (int) n2);
  ------------------
  |  Branch (160:4): [True: 0, False: 0]
  ------------------
  161|      0|    }
  162|       |
  163|      2|    n1 = asReal(s1);
  ------------------
  |  |  889|      2|#define asReal			Rf_asReal
  ------------------
  164|      2|    n2 = asReal(s2);
  ------------------
  |  |  889|      2|#define asReal			Rf_asReal
  ------------------
  165|      2|    if (ISNAN(n1) || ISNAN(n2))
  ------------------
  |  |   76|      4|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 2]
  |  |  ------------------
  ------------------
                  if (ISNAN(n1) || ISNAN(n2))
  ------------------
  |  |   76|      2|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  166|      0|	errorcall(call, _("NA/NaN argument"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("NA/NaN argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  167|      2|    return seq_colon(n1, n2, call);
  168|      2|}
do_rep_int:
  340|     50|{
  341|     50|    checkArity(op, args);
  ------------------
  |  | 1788|     50|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  342|     50|    SEXP s = CAR(args), ncopy = CADR(args);
  343|     50|    R_xlen_t nc;
  344|     50|    SEXP a;
  345|       |
  346|       |    /* DispatchOrEval internal generic: rep.int */
  347|     50|    if (DispatchOrEval(call, op, "rep.int", args, rho, &a, 0, 0))
  ------------------
  |  | 1887|     50|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (347:9): [True: 0, False: 50]
  ------------------
  348|      0|      return(a);
  349|       |
  350|     50|    if (!inherits(s, "factor"))
  ------------------
  |  |  933|     50|#define inherits		Rf_inherits
  ------------------
  |  Branch (350:9): [True: 50, False: 0]
  ------------------
  351|     50|    if (DispatchOrEval(call, op, "rep", args, rho, &a, 0, 0))
  ------------------
  |  | 1887|     50|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (351:9): [True: 0, False: 50]
  ------------------
  352|      0|      return(a);
  353|       |
  354|     50|    if (!isVector(ncopy))
  ------------------
  |  |  974|     50|#define isVector		Rf_isVector
  ------------------
  |  Branch (354:9): [True: 0, False: 50]
  ------------------
  355|      0|	error(_("invalid type (%s) for '%s' (must be a vector)"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid type (%s) for '%s' (must be a vector)"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  356|      0|	      R_typeToChar(ncopy), "times");
  357|       |
  358|     50|    if (!isVector(s) && s != R_NilValue)
  ------------------
  |  |  974|     50|#define isVector		Rf_isVector
  ------------------
  |  Branch (358:9): [True: 0, False: 50]
  |  Branch (358:25): [True: 0, False: 0]
  ------------------
  359|      0|	error(_("attempt to replicate an object of type '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt to replicate an object of type '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  360|      0|	      R_typeToChar(s));
  361|       |
  362|     50|    nc = xlength(ncopy); // might be 0
  ------------------
  |  | 1049|     50|#define xlength(x)		Rf_xlength(x)
  ------------------
  363|     50|    if (nc == xlength(s))
  ------------------
  |  | 1049|     50|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (363:9): [True: 50, False: 0]
  ------------------
  364|     50|	PROTECT(a = rep2(s, ncopy));
  ------------------
  |  |  357|     50|#define PROTECT(s)	Rf_protect(s)
  ------------------
  365|      0|    else {
  366|      0|	if (nc != 1) error(_("invalid '%s' value"), "times");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if (nc != 1) error(_("invalid '%s' value"), "times");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (366:6): [True: 0, False: 0]
  ------------------
  367|       |
  368|      0|	R_xlen_t ns = xlength(s);
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
  369|      0|	if (TYPEOF(ncopy) != INTSXP) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (369:6): [True: 0, False: 0]
  ------------------
  370|      0|	    double snc = asReal(ncopy);
  ------------------
  |  |  889|      0|#define asReal			Rf_asReal
  ------------------
  371|      0|	    if (!R_FINITE(snc) || snc <= -1. ||
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (371:10): [True: 0, False: 0]
  |  Branch (371:28): [True: 0, False: 0]
  ------------------
  372|      0|		(ns > 0 && snc >= R_XLEN_T_MAX + 1.))
  ------------------
  |  |   76|      0|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (372:4): [True: 0, False: 0]
  |  Branch (372:14): [True: 0, False: 0]
  ------------------
  373|      0|		error(_("invalid '%s' value"), "times");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("invalid '%s' value"), "times");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  374|      0|	    nc = ns == 0 ? 1 : (R_xlen_t) snc;
  ------------------
  |  Branch (374:11): [True: 0, False: 0]
  ------------------
  375|      0|	} else if ((nc = asInteger(ncopy)) == NA_INTEGER || nc < 0) // nc = 0 ok
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
              	} else if ((nc = asInteger(ncopy)) == NA_INTEGER || nc < 0) // nc = 0 ok
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (375:13): [True: 0, False: 0]
  |  Branch (375:54): [True: 0, False: 0]
  ------------------
  376|      0|	    error(_("invalid '%s' value"), "times");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' value"), "times");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  377|      0|	if ((double) nc * ns > R_XLEN_T_MAX)
  ------------------
  |  |   76|      0|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (377:6): [True: 0, False: 0]
  ------------------
  378|      0|	    error(_("invalid '%s' value"), "times");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' value"), "times");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  379|      0|	PROTECT(a = rep3(s, ns, nc * ns));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  380|      0|    }
  381|       |
  382|     50|#ifdef _S4_rep_keepClass
  383|     50|    if(IS_S4_OBJECT(s)) { /* e.g. contains = "list" */
  ------------------
  |  Branch (383:8): [True: 0, False: 50]
  ------------------
  384|      0|	setAttrib(a, R_ClassSymbol, getAttrib(s, R_ClassSymbol));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              	setAttrib(a, R_ClassSymbol, getAttrib(s, R_ClassSymbol));
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  385|      0|	SET_S4_OBJECT(a);
  386|      0|    }
  387|     50|#endif
  388|       |
  389|     50|    if (inherits(s, "factor")) {
  ------------------
  |  |  933|     50|#define inherits		Rf_inherits
  ------------------
  |  Branch (389:9): [True: 0, False: 50]
  ------------------
  390|      0|	SEXP tmp;
  391|      0|	if(inherits(s, "ordered")) {
  ------------------
  |  |  933|      0|#define inherits		Rf_inherits
  ------------------
  |  Branch (391:5): [True: 0, False: 0]
  ------------------
  392|      0|	    PROTECT(tmp = allocVector(STRSXP, 2));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  393|      0|	    SET_STRING_ELT(tmp, 0, mkChar("ordered"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  394|      0|	    SET_STRING_ELT(tmp, 1, mkChar("factor"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  395|      0|	} else PROTECT(tmp = mkString("factor"));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  396|      0|	setAttrib(a, R_ClassSymbol, tmp);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  397|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  398|      0|	setAttrib(a, R_LevelsSymbol, getAttrib(s, R_LevelsSymbol));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              	setAttrib(a, R_LevelsSymbol, getAttrib(s, R_LevelsSymbol));
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  399|      0|    }
  400|     50|    UNPROTECT(1);
  ------------------
  |  |  358|     50|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  401|     50|    return a;
  402|     50|}
do_rep_len:
  405|  1.00k|{
  406|  1.00k|    R_xlen_t ns, na;
  407|  1.00k|    SEXP a, s, len;
  408|       |
  409|  1.00k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.00k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  410|       |
  411|       |    /* DispatchOrEval internal generic: rep_len */
  412|  1.00k|    if (DispatchOrEval(call, op, "rep_len", args, rho, &a, 0, 0))
  ------------------
  |  | 1887|  1.00k|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (412:9): [True: 0, False: 1.00k]
  ------------------
  413|      0|      return(a);
  414|       |
  415|  1.00k|    s = CAR(args);
  416|       |
  417|  1.00k|    if (isObject(s) && !inherits(s, "factor")) {
  ------------------
  |  |  959|  1.00k|#define isObject		Rf_isObject
  ------------------
                  if (isObject(s) && !inherits(s, "factor")) {
  ------------------
  |  |  933|      0|#define inherits		Rf_inherits
  ------------------
  |  Branch (417:9): [True: 0, False: 1.00k]
  |  Branch (417:24): [True: 0, False: 0]
  ------------------
  418|      0|	SEXP rep_call;
  419|      0|	PROTECT(rep_call = shallow_duplicate(call));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  420|      0|	SETCAR(rep_call, install("rep"));
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
  421|      0|	SET_TAG(CDDR(rep_call), install("length.out"));
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
  422|      0|	SET_TAG(CDR(args), install("length.out"));
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
  423|      0|	if (DispatchOrEval(rep_call, op, "rep", args, rho, &a, 0, 0)) {
  ------------------
  |  | 1887|      0|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (423:6): [True: 0, False: 0]
  ------------------
  424|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  425|      0|	    return(a);
  426|      0|	}
  427|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  428|      0|    }
  429|       |
  430|  1.00k|    if (!isVector(s) && s != R_NilValue)
  ------------------
  |  |  974|  1.00k|#define isVector		Rf_isVector
  ------------------
  |  Branch (430:9): [True: 0, False: 1.00k]
  |  Branch (430:25): [True: 0, False: 0]
  ------------------
  431|      0|	error(_("attempt to replicate non-vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt to replicate non-vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  432|       |
  433|  1.00k|    len = CADR(args);
  434|  1.00k|    if(length(len) != 1)
  ------------------
  |  |  987|  1.00k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (434:8): [True: 0, False: 1.00k]
  ------------------
  435|      0|	error(_("invalid '%s' value"), "length.out");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' value"), "length.out");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  436|  1.00k|    if (TYPEOF(len) != INTSXP) {
  ------------------
  |  |  123|  1.00k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (436:9): [True: 2, False: 1.00k]
  ------------------
  437|      2|	double sna = asReal(len);
  ------------------
  |  |  889|      2|#define asReal			Rf_asReal
  ------------------
  438|      2|	if (ISNAN(sna) || sna <= -1. || sna >= R_XLEN_T_MAX + 1.)
  ------------------
  |  |   76|      4|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 2]
  |  |  ------------------
  ------------------
              	if (ISNAN(sna) || sna <= -1. || sna >= R_XLEN_T_MAX + 1.)
  ------------------
  |  |   76|      2|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (438:20): [True: 0, False: 2]
  |  Branch (438:34): [True: 0, False: 2]
  ------------------
  439|      0|	    error(_("invalid '%s' value"), "length.out");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' value"), "length.out");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  440|      2|	na = (R_xlen_t) sna;
  441|      2|    } else
  442|  1.00k|	if ((na = asInteger(len)) == NA_INTEGER || na < 0) /* na = 0 ok */
  ------------------
  |  |  885|  1.00k|#define asInteger		Rf_asInteger
  ------------------
              	if ((na = asInteger(len)) == NA_INTEGER || na < 0) /* na = 0 ok */
  ------------------
  |  |   56|  2.01k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (442:6): [True: 0, False: 1.00k]
  |  Branch (442:45): [True: 0, False: 1.00k]
  ------------------
  443|      0|	    error(_("invalid '%s' value"), "length.out");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' value"), "length.out");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  444|       |
  445|  1.00k|    if (TYPEOF(s) == NILSXP && na > 0)
  ------------------
  |  |  111|  2.01k|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (445:9): [True: 0, False: 1.00k]
  |  Branch (445:32): [True: 0, False: 0]
  ------------------
  446|      0|	error(_("cannot replicate NULL to a non-zero length"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot replicate NULL to a non-zero length"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  447|  1.00k|    ns = xlength(s);
  ------------------
  |  | 1049|  1.00k|#define xlength(x)		Rf_xlength(x)
  ------------------
  448|  1.00k|    if (ns == 0) {
  ------------------
  |  Branch (448:9): [True: 96, False: 911]
  ------------------
  449|     96|	SEXP a;
  450|     96|	PROTECT(a = duplicate(s));
  ------------------
  |  |  357|     96|#define PROTECT(s)	Rf_protect(s)
  ------------------
  451|     96|	if(na > 0) a = xlengthgets(a, na);
  ------------------
  |  | 1050|     96|#define xlengthgets		Rf_xlengthgets
  ------------------
  |  Branch (451:5): [True: 96, False: 0]
  ------------------
  452|     96|	UNPROTECT(1);
  ------------------
  |  |  358|     96|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  453|     96|	return a;
  454|     96|    }
  455|    911|    PROTECT(a = rep3(s, ns, na));
  ------------------
  |  |  357|    911|#define PROTECT(s)	Rf_protect(s)
  ------------------
  456|       |
  457|    911|#ifdef _S4_rep_keepClass
  458|    911|    if(IS_S4_OBJECT(s)) { /* e.g. contains = "list" */
  ------------------
  |  Branch (458:8): [True: 0, False: 911]
  ------------------
  459|      0|	setAttrib(a, R_ClassSymbol, getAttrib(s, R_ClassSymbol));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              	setAttrib(a, R_ClassSymbol, getAttrib(s, R_ClassSymbol));
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  460|      0|	SET_S4_OBJECT(a);
  461|      0|    }
  462|    911|#endif
  463|       |
  464|    911|    if (inherits(s, "factor")) {
  ------------------
  |  |  933|    911|#define inherits		Rf_inherits
  ------------------
  |  Branch (464:9): [True: 0, False: 911]
  ------------------
  465|      0|	SEXP tmp;
  466|      0|	if(inherits(s, "ordered")) {
  ------------------
  |  |  933|      0|#define inherits		Rf_inherits
  ------------------
  |  Branch (466:5): [True: 0, False: 0]
  ------------------
  467|      0|	    PROTECT(tmp = allocVector(STRSXP, 2));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  468|      0|	    SET_STRING_ELT(tmp, 0, mkChar("ordered"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  469|      0|	    SET_STRING_ELT(tmp, 1, mkChar("factor"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  470|      0|	} else PROTECT(tmp = mkString("factor"));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  471|      0|	setAttrib(a, R_ClassSymbol, tmp);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  472|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  473|      0|	setAttrib(a, R_LevelsSymbol, getAttrib(s, R_LevelsSymbol));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              	setAttrib(a, R_LevelsSymbol, getAttrib(s, R_LevelsSymbol));
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  474|      0|    }
  475|    911|    UNPROTECT(1);
  ------------------
  |  |  358|    911|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  476|    911|    return a;
  477|  1.00k|}
do_rep:
  635|      1|{
  636|      1|    SEXP ans, x, times = R_NilValue;
  637|      1|    R_xlen_t i, lx, len = NA_INTEGER, each = 1, nt;
  ------------------
  |  |   56|      1|#define NA_INTEGER	R_NaInt
  ------------------
  638|      1|    static SEXP do_rep_formals = NULL;
  639|       |
  640|       |    /* includes factors, POSIX[cl]t, Date */
  641|       |    /* DispatchOrEval internal generic: rep */
  642|      1|    if (DispatchOrEval(call, op, "rep", args, rho, &ans, 0, 0))
  ------------------
  |  | 1887|      1|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (642:9): [True: 0, False: 1]
  ------------------
  643|      0|	return(ans);
  644|       |
  645|       |    /* This has evaluated all the non-missing arguments into ans */
  646|      1|    PROTECT(args = ans);
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
  647|       |
  648|       |    /* This is a primitive, and we have not dispatched to a method
  649|       |       so we manage the argument matching ourselves.  We pretend this is
  650|       |       rep(x, times, length.out, each, ...)
  651|       |    */
  652|      1|    if (do_rep_formals == NULL)
  ------------------
  |  Branch (652:9): [True: 1, False: 0]
  ------------------
  653|      1|	do_rep_formals = allocFormalsList5(install("x"), install("times"),
  ------------------
  |  |  868|      1|#define allocFormalsList5	Rf_allocFormalsList5
  ------------------
              	do_rep_formals = allocFormalsList5(install("x"), install("times"),
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
              	do_rep_formals = allocFormalsList5(install("x"), install("times"),
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
  654|      1|					   install("length.out"),
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
  655|      1|					   install("each"), R_DotsSymbol);
  ------------------
  |  |  934|      1|#define install			Rf_install
  ------------------
  656|      1|    PROTECT(args = matchArgs_NR(do_rep_formals, args, call));
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
  657|       |
  658|      1|    x = CAR(args);
  659|       |    /* supported in R 2.15.x */
  660|      1|    if (TYPEOF(x) == LISTSXP)
  ------------------
  |  |  113|      1|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (660:9): [True: 0, False: 1]
  ------------------
  661|      0|	errorcall(call, "replication of pairlists is defunct");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  662|       |
  663|      1|    lx = xlength(x);
  ------------------
  |  | 1049|      1|#define xlength(x)		Rf_xlength(x)
  ------------------
  664|       |
  665|      1|    if (TYPEOF(CADDR(args)) != INTSXP) {
  ------------------
  |  |  123|      1|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (665:9): [True: 1, False: 0]
  ------------------
  666|      1|	double slen = asReal(CADDR(args));
  ------------------
  |  |  889|      1|#define asReal			Rf_asReal
  ------------------
  667|      1|	if (R_FINITE(slen)) {
  ------------------
  |  |   82|      1|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (667:6): [True: 0, False: 1]
  ------------------
  668|      0|	    if (slen <= -1 || slen >= R_XLEN_T_MAX+1.0)
  ------------------
  |  |   76|      0|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (668:10): [True: 0, False: 0]
  |  Branch (668:24): [True: 0, False: 0]
  ------------------
  669|      0|		errorcall(call, _("invalid '%s' argument"), "length.out");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		errorcall(call, _("invalid '%s' argument"), "length.out");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  670|      0|	    len = (R_xlen_t) slen;
  671|      0|	} else
  672|      1|	    len = NA_INTEGER;
  ------------------
  |  |   56|      1|#define NA_INTEGER	R_NaInt
  ------------------
  673|      1|    } else {
  674|      0|	len = asInteger(CADDR(args));
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
  675|      0|	if(len != NA_INTEGER && len < 0)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (675:5): [True: 0, False: 0]
  |  Branch (675:26): [True: 0, False: 0]
  ------------------
  676|      0|	    errorcall(call, _("invalid '%s' argument"), "length.out");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("invalid '%s' argument"), "length.out");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  677|      0|    }
  678|      1|    if(length(CADDR(args)) != 1)
  ------------------
  |  |  987|      1|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (678:8): [True: 0, False: 1]
  ------------------
  679|      0|	warningcall(call, _("first element used of '%s' argument"),
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              	warningcall(call, _("first element used of '%s' argument"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  680|      0|		    "length.out");
  681|       |
  682|      1|    if (TYPEOF(CADDDR(args)) != INTSXP) {
  ------------------
  |  |  123|      1|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (682:9): [True: 1, False: 0]
  ------------------
  683|      1|	double seach = asReal(CADDDR(args));
  ------------------
  |  |  889|      1|#define asReal			Rf_asReal
  ------------------
  684|      1|	if (R_FINITE(seach)) {
  ------------------
  |  |   82|      1|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (684:6): [True: 0, False: 1]
  ------------------
  685|      0|	    if (seach <= -1. || (lx > 0 && seach >= R_XLEN_T_MAX + 1.))
  ------------------
  |  |   76|      0|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (685:10): [True: 0, False: 0]
  |  Branch (685:27): [True: 0, False: 0]
  |  Branch (685:37): [True: 0, False: 0]
  ------------------
  686|      0|		errorcall(call, _("invalid '%s' argument"), "each");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		errorcall(call, _("invalid '%s' argument"), "each");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  687|      0|	    each = lx == 0 ? NA_INTEGER : (R_xlen_t) seach;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (687:13): [True: 0, False: 0]
  ------------------
  688|      1|	} else each = NA_INTEGER;
  ------------------
  |  |   56|      1|#define NA_INTEGER	R_NaInt
  ------------------
  689|      1|    } else {
  690|      0|	each = asInteger(CADDDR(args));
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
  691|      0|	if(each != NA_INTEGER && each < 0)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (691:5): [True: 0, False: 0]
  |  Branch (691:27): [True: 0, False: 0]
  ------------------
  692|      0|	    errorcall(call, _("invalid '%s' argument"), "each");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("invalid '%s' argument"), "each");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  693|      0|    }
  694|      1|    if(length(CADDDR(args)) != 1)
  ------------------
  |  |  987|      1|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (694:8): [True: 0, False: 1]
  ------------------
  695|      0|	warningcall(call, _("first element used of '%s' argument"), "each");
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              	warningcall(call, _("first element used of '%s' argument"), "each");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  696|      1|    if(each == NA_INTEGER) each = 1;
  ------------------
  |  |   56|      1|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (696:8): [True: 1, False: 0]
  ------------------
  697|       |
  698|      1|    if(lx == 0) {
  ------------------
  |  Branch (698:8): [True: 0, False: 1]
  ------------------
  699|      0|	if(len > 0 && x == R_NilValue)
  ------------------
  |  Branch (699:5): [True: 0, False: 0]
  |  Branch (699:16): [True: 0, False: 0]
  ------------------
  700|      0|	    warningcall(call, "'x' is NULL so the result will be NULL");
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
  701|      0|	SEXP a;
  702|      0|	PROTECT(a = duplicate(x));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  703|      0|	if(len != NA_INTEGER && len > 0 && x != R_NilValue)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (703:5): [True: 0, False: 0]
  |  Branch (703:26): [True: 0, False: 0]
  |  Branch (703:37): [True: 0, False: 0]
  ------------------
  704|      0|	    a = xlengthgets(a, len);
  ------------------
  |  | 1050|      0|#define xlengthgets		Rf_xlengthgets
  ------------------
  705|      0|	UNPROTECT(3);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  706|      0|	return a;
  707|      0|    }
  708|      1|    if (!isVector(x))
  ------------------
  |  |  974|      1|#define isVector		Rf_isVector
  ------------------
  |  Branch (708:9): [True: 0, False: 1]
  ------------------
  709|      0|	errorcall(call, "attempt to replicate an object of type '%s'",
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  710|      0|		  R_typeToChar(x));
  711|       |
  712|       |    /* So now we know x is a vector of positive length.  We need to
  713|       |       replicate it, and its names if it has them. */
  714|       |
  715|      1|    int nprotect = 2;
  716|       |    /* First find the final length using 'times' and 'each' */
  717|      1|    if(len != NA_INTEGER) { /* takes precedence over times */
  ------------------
  |  |   56|      1|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (717:8): [True: 0, False: 1]
  ------------------
  718|      0|	nt = 1;
  719|      1|    } else {
  720|      1|	double sum = 0;
  721|      1|	if(CADR(args) == R_MissingArg)
  ------------------
  |  Branch (721:5): [True: 0, False: 1]
  ------------------
  722|      0|	    PROTECT(times = ScalarInteger(1));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  723|      1|#ifdef LONG_VECTOR_SUPPORT
  724|      1|	else if(TYPEOF(CADR(args)) != INTSXP)
  ------------------
  |  |  123|      1|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (724:10): [True: 1, False: 0]
  ------------------
  725|       |#else
  726|       |	else if(TYPEOF(CADR(args)) == REALSXP)
  727|       |#endif
  728|      1|	    PROTECT(times = coerceVector(CADR(args), REALSXP));
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
  729|      0|	else PROTECT(times = coerceVector(CADR(args), INTSXP));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  730|      1|	nprotect++;
  731|      1|	nt = XLENGTH(times);
  732|      1|	if(nt == 1) {
  ------------------
  |  Branch (732:5): [True: 0, False: 1]
  ------------------
  733|      0|	    R_xlen_t it;
  734|      0|	    if (TYPEOF(times) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (734:10): [True: 0, False: 0]
  ------------------
  735|      0|		double rt = REAL(times)[0];
  736|      0|		if (ISNAN(rt) || rt <= -1 || rt >= R_XLEN_T_MAX+1.0)
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              		if (ISNAN(rt) || rt <= -1 || rt >= R_XLEN_T_MAX+1.0)
  ------------------
  |  |  349|      0|#define rt		Rf_rt
  ------------------
              		if (ISNAN(rt) || rt <= -1 || rt >= R_XLEN_T_MAX+1.0)
  ------------------
  |  |  349|      0|#define rt		Rf_rt
  ------------------
              		if (ISNAN(rt) || rt <= -1 || rt >= R_XLEN_T_MAX+1.0)
  ------------------
  |  |   76|      0|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (736:20): [True: 0, False: 0]
  |  Branch (736:32): [True: 0, False: 0]
  ------------------
  737|      0|		    errorcall(call, _("invalid '%s' argument"), "times");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		    errorcall(call, _("invalid '%s' argument"), "times");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  738|      0|		it = (R_xlen_t) rt;
  ------------------
  |  |  349|      0|#define rt		Rf_rt
  ------------------
  739|      0|	    } else {
  740|      0|		it = INTEGER(times)[0];
  741|      0|		if (it == NA_INTEGER || it < 0)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (741:7): [True: 0, False: 0]
  |  Branch (741:27): [True: 0, False: 0]
  ------------------
  742|      0|		    errorcall(call, _("invalid '%s' argument"), "times");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		    errorcall(call, _("invalid '%s' argument"), "times");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  743|      0|	    }
  744|      0|	    if ((double) lx * it * each > R_XLEN_T_MAX)
  ------------------
  |  |   76|      0|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (744:10): [True: 0, False: 0]
  ------------------
  745|      0|		errorcall(call, _("length(x) * '%s' * '%s' is too large"), "times", "each");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		errorcall(call, _("length(x) * '%s' * '%s' is too large"), "times", "each");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  746|      0|	    len = lx * it * each;
  747|      1|	} else { // nt != 1
  748|      1|	    if(nt != (double) lx * each) {
  ------------------
  |  Branch (748:9): [True: 0, False: 1]
  ------------------
  749|      0|		if (each == 1)	errorcall(call, _("invalid '%s' argument"),			     "times");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		if (each == 1)	errorcall(call, _("invalid '%s' argument"),			     "times");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (749:7): [True: 0, False: 0]
  ------------------
  750|      0|		/* else */	errorcall(call, _("invalid '%s' argument, given the value of '%s'"), "times", "each");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		/* else */	errorcall(call, _("invalid '%s' argument, given the value of '%s'"), "times", "each");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  751|      0|	    }
  752|      1|	    if (TYPEOF(times) == REALSXP)
  ------------------
  |  |  124|      1|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (752:10): [True: 1, False: 0]
  ------------------
  753|      4|		for(i = 0; i < nt; i++) {
  ------------------
  |  Branch (753:14): [True: 3, False: 1]
  ------------------
  754|      3|		    double rt = REAL(times)[i];
  755|      3|		    if (ISNAN(rt) || rt <= -1 || rt >= R_XLEN_T_MAX+1.0)
  ------------------
  |  |   76|      6|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 3]
  |  |  ------------------
  ------------------
              		    if (ISNAN(rt) || rt <= -1 || rt >= R_XLEN_T_MAX+1.0)
  ------------------
  |  |  349|      3|#define rt		Rf_rt
  ------------------
              		    if (ISNAN(rt) || rt <= -1 || rt >= R_XLEN_T_MAX+1.0)
  ------------------
  |  |  349|      3|#define rt		Rf_rt
  ------------------
              		    if (ISNAN(rt) || rt <= -1 || rt >= R_XLEN_T_MAX+1.0)
  ------------------
  |  |   76|      3|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (755:24): [True: 0, False: 3]
  |  Branch (755:36): [True: 0, False: 3]
  ------------------
  756|      0|			errorcall(call, _("invalid '%s' argument"), "times");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              			errorcall(call, _("invalid '%s' argument"), "times");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  757|      3|		    sum += (R_xlen_t) rt;
  ------------------
  |  |  349|      3|#define rt		Rf_rt
  ------------------
  758|      3|		}
  759|      0|	    else
  760|      0|		for(i = 0; i < nt; i++) {
  ------------------
  |  Branch (760:14): [True: 0, False: 0]
  ------------------
  761|      0|		    int it = INTEGER(times)[i];
  762|      0|		    if (it == NA_INTEGER || it < 0)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (762:11): [True: 0, False: 0]
  |  Branch (762:31): [True: 0, False: 0]
  ------------------
  763|      0|			errorcall(call, _("invalid '%s' argument"), "times");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              			errorcall(call, _("invalid '%s' argument"), "times");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  764|      0|		    sum += it;
  765|      0|		}
  766|      1|	    if (sum > R_XLEN_T_MAX)
  ------------------
  |  |   76|      1|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (766:10): [True: 0, False: 1]
  ------------------
  767|      0|		errorcall(call, _("invalid '%s' argument"), "times");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              		errorcall(call, _("invalid '%s' argument"), "times");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  768|      1|	    len = (R_xlen_t) sum;
  769|      1|	}
  770|      1|    }
  771|       |
  772|      1|    if(len > 0 && each == 0)
  ------------------
  |  Branch (772:8): [True: 1, False: 0]
  |  Branch (772:19): [True: 0, False: 1]
  ------------------
  773|      0|	errorcall(call, _("invalid '%s' argument"), "each");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("invalid '%s' argument"), "each");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  774|       |
  775|      1|    SEXP xn = PROTECT(getAttrib(x, R_NamesSymbol));  nprotect++;
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
  776|      1|    PROTECT(ans = rep4(x, times, len, each, nt));    nprotect++;
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
  777|       |
  778|      1|    if (xlength(xn) > 0)
  ------------------
  |  | 1049|      1|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (778:9): [True: 0, False: 1]
  ------------------
  779|      0|	setAttrib(ans, R_NamesSymbol, rep4(xn, times, len, each, nt));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  780|       |
  781|      1|#ifdef _S4_rep_keepClass
  782|      1|    if(IS_S4_OBJECT(x)) { /* e.g. contains = "list" */
  ------------------
  |  Branch (782:8): [True: 0, False: 1]
  ------------------
  783|      0|	setAttrib(ans, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              	setAttrib(ans, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  784|      0|	SET_S4_OBJECT(ans);
  785|      0|    }
  786|      1|#endif
  787|      1|    UNPROTECT(nprotect);
  ------------------
  |  |  358|      1|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  788|      1|    return ans;
  789|      1|}
do_seq_along:
 1060|     78|{
 1061|     78|    SEXP ans;
 1062|     78|    R_xlen_t len;
 1063|     78|    static SEXP length_op = NULL;
 1064|       |
 1065|       |    /* Store the .Primitive for 'length' for DispatchOrEval to use. */
 1066|     78|    if (length_op == NULL) {
  ------------------
  |  Branch (1066:9): [True: 2, False: 76]
  ------------------
 1067|      2|	SEXP R_lengthSymbol = install("length");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
 1068|      2|	length_op = eval(R_lengthSymbol, R_BaseEnv);
  ------------------
  |  |  913|      2|#define eval			Rf_eval
  ------------------
 1069|      2|	if (TYPEOF(length_op) != BUILTINSXP) {
  ------------------
  |  |  119|      2|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (1069:6): [True: 0, False: 2]
  ------------------
 1070|      0|	    length_op = NULL;
 1071|      0|	    error("'length' is not a BUILTIN");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 1072|      0|	}
 1073|      2|	R_PreserveObject(length_op);
 1074|      2|    }
 1075|       |
 1076|     78|    checkArity(op, args);
  ------------------
  |  | 1788|     78|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1077|     78|    check1arg(args, call, "along.with");
  ------------------
  |  | 1867|     78|# define check1arg		Rf_check1arg
  ------------------
 1078|       |
 1079|       |    /* Try to dispatch to S3 or S4 methods for 'length'.  For cases
 1080|       |       where no methods are defined this is more efficient than an
 1081|       |       unconditional callback to R */
 1082|     78|    if (isObject(CAR(args)) &&
  ------------------
  |  |  959|     78|#define isObject		Rf_isObject
  ------------------
  |  Branch (1082:9): [True: 74, False: 4]
  ------------------
 1083|     74|	DispatchOrEval(call, length_op, "length", args, rho, &ans, 0, 1)) {
  ------------------
  |  | 1887|     74|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  |  Branch (1083:2): [True: 0, False: 74]
  ------------------
 1084|      0|	len = asInteger(ans);
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
 1085|      0|    }
 1086|     78|    else
 1087|     78|	len = xlength(CAR(args));
  ------------------
  |  | 1049|     78|#define xlength(x)		Rf_xlength(x)
  ------------------
 1088|       |
 1089|     78|    if (len == 0)
  ------------------
  |  Branch (1089:9): [True: 4, False: 74]
  ------------------
 1090|      4|	return allocVector(INTSXP, 0);
  ------------------
  |  |  875|      4|#define allocVector		Rf_allocVector
  ------------------
              	return allocVector(INTSXP, 0);
  ------------------
  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  ------------------
 1091|     74|    else
 1092|     74|	return R_compact_intrange(1, len);
 1093|     78|}
seq.c:seq_colon:
   99|      2|{
  100|      2|    double r = fabs(n2 - n1);
  101|      2|    if(r >= R_XLEN_T_MAX)
  ------------------
  |  |   76|      2|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (101:8): [True: 0, False: 2]
  ------------------
  102|      0|	errorcall(call, _("result would be too long a vector"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("result would be too long a vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  103|       |
  104|      2|    if (n1 == (R_xlen_t) n1 && n2 == (R_xlen_t) n2)
  ------------------
  |  Branch (104:9): [True: 2, False: 0]
  |  Branch (104:32): [True: 2, False: 0]
  ------------------
  105|      2|	return R_compact_intrange((R_xlen_t) n1, (R_xlen_t) n2);
  106|       |
  107|      0|    SEXP ans;
  108|      0|    R_xlen_t n = (R_xlen_t)(r + 1 + FLT_EPSILON);
  109|       |
  110|      0|    Rboolean useInt = (n1 <= INT_MAX) &&  (n1 == (int) n1);
  ------------------
  |  Branch (110:23): [True: 0, False: 0]
  |  Branch (110:43): [True: 0, False: 0]
  ------------------
  111|      0|    if(useInt) {
  ------------------
  |  Branch (111:8): [True: 0, False: 0]
  ------------------
  112|      0|	if(n1 <= INT_MIN) /* know  n1 <= INT_MAX */
  ------------------
  |  Branch (112:5): [True: 0, False: 0]
  ------------------
  113|      0|	    useInt = FALSE;
  114|      0|	else {
  115|       |	    /* r := " the effective 'to' "  of  from:to */
  116|      0|	    double dn = (double) n;
  117|      0|	    r = n1 + ((n1 <= n2) ? dn-1 : -(dn-1));
  ------------------
  |  Branch (117:16): [True: 0, False: 0]
  ------------------
  118|      0|	    if(r <= INT_MIN || r > INT_MAX) useInt = false;
  ------------------
  |  Branch (118:9): [True: 0, False: 0]
  |  Branch (118:25): [True: 0, False: 0]
  ------------------
  119|      0|	}
  120|      0|    }
  121|      0|    if (useInt) {
  ------------------
  |  Branch (121:9): [True: 0, False: 0]
  ------------------
  122|      0|	if (n1 <= n2)
  ------------------
  |  Branch (122:6): [True: 0, False: 0]
  ------------------
  123|      0|	    ans = R_compact_intrange((R_xlen_t) n1, (R_xlen_t)(n1 + n - 1));
  124|      0|	else
  125|      0|	    ans = R_compact_intrange((R_xlen_t) n1, (R_xlen_t)(n1 - n + 1));
  126|      0|    } else {
  127|      0|	ans = allocVector(REALSXP, n);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	ans = allocVector(REALSXP, n);
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  128|      0|	if (n1 <= n2)
  ------------------
  |  Branch (128:6): [True: 0, False: 0]
  ------------------
  129|      0|	    for (R_xlen_t i = 0; i < n; i++) {
  ------------------
  |  Branch (129:27): [True: 0, False: 0]
  ------------------
  130|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  131|      0|		REAL(ans)[i] = n1 + (double)i;
  132|      0|	    }
  133|      0|	else
  134|      0|	    for (R_xlen_t i = 0; i < n; i++) {
  ------------------
  |  Branch (134:27): [True: 0, False: 0]
  ------------------
  135|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  136|      0|		REAL(ans)[i] = n1 - (double)i;
  137|      0|	    }
  138|      0|    }
  139|      0|    return ans;
  140|      2|}
seq.c:rep2:
  172|     50|{
  173|     50|    R_xlen_t i, j, nc, n;
  174|     50|    SEXP a, t;
  175|       |
  176|     50|#define R2_SWITCH_LOOP(it) \
  177|     50|    switch (TYPEOF(s)) { \
  178|     50|    case LGLSXP: \
  179|     50|	for (i = 0; i < nc; i++) { \
  180|       |/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  181|     50|	    for (j = 0; j < (R_xlen_t) it[i]; j++) \
  182|     50|		LOGICAL(a)[n++] = LOGICAL(s)[i]; \
  183|     50|	} \
  184|     50|	break; \
  185|     50|    case INTSXP: \
  186|     50|	for (i = 0; i < nc; i++) { \
  187|       |/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  188|     50|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  189|     50|		INTEGER(a)[n++] = INTEGER(s)[i]; \
  190|     50|	} \
  191|     50|	break; \
  192|     50|    case REALSXP: \
  193|     50|	for (i = 0; i < nc; i++) { \
  194|       |/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  195|     50|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  196|     50|		REAL(a)[n++] = REAL(s)[i]; \
  197|     50|	} \
  198|     50|	break; \
  199|     50|    case CPLXSXP: \
  200|     50|	for (i = 0; i < nc; i++) { \
  201|       |/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  202|     50|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  203|     50|		COMPLEX(a)[n++] = COMPLEX(s)[i]; \
  204|     50|	} \
  205|     50|	break; \
  206|     50|    case STRSXP: \
  207|     50|	for (i = 0; i < nc; i++) { \
  208|       |/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  209|     50|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  210|     50|		SET_STRING_ELT(a, n++, STRING_ELT(s, i)); \
  211|     50|	} \
  212|     50|	break; \
  213|     50|    case VECSXP: \
  214|     50|    case EXPRSXP: \
  215|     50|	for (i = 0; i < nc; i++) { \
  216|       |/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  217|     50|	    SEXP elt = lazy_duplicate(VECTOR_ELT(s, i)); \
  218|     50|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  219|     50|		SET_VECTOR_ELT(a, n++, elt); \
  220|     50|	} \
  221|     50|	break; \
  222|     50|    case RAWSXP: \
  223|     50|	for (i = 0; i < nc; i++) { \
  224|       |/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  225|     50|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  226|     50|		RAW(a)[n++] = RAW(s)[i]; \
  227|     50|	} \
  228|     50|	break; \
  229|     50|    default: \
  230|     50|	UNIMPLEMENTED_TYPE("rep2", s); \
  231|     50|    }
  232|       |
  233|     50|#ifdef LONG_VECTOR_SUPPORT
  234|     50|    if (TYPEOF(ncopy) != INTSXP)
  ------------------
  |  |  123|     50|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (234:9): [True: 2, False: 48]
  ------------------
  235|       |#else
  236|       |    if (TYPEOF(ncopy) == REALSXP)
  237|       |#endif
  238|      2|	PROTECT(t = coerceVector(ncopy, REALSXP));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
  239|     48|    else
  240|     48|	PROTECT(t = coerceVector(ncopy, INTSXP));
  ------------------
  |  |  357|     48|#define PROTECT(s)	Rf_protect(s)
  ------------------
  241|       |
  242|     50|    nc = xlength(ncopy);
  ------------------
  |  | 1049|     50|#define xlength(x)		Rf_xlength(x)
  ------------------
  243|     50|    double sna = 0;
  244|     50|    if (TYPEOF(t) == REALSXP)
  ------------------
  |  |  124|     50|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (244:9): [True: 2, False: 48]
  ------------------
  245|      4|    for (i = 0; i < nc; i++) {
  ------------------
  |  Branch (245:17): [True: 2, False: 2]
  ------------------
  246|       |//	if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  247|      2|	if (ISNAN(REAL(t)[i]) || REAL(t)[i] <= -1 ||
  ------------------
  |  |   76|      4|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  |  Branch (247:27): [True: 0, False: 2]
  ------------------
  248|      2|	    REAL(t)[i] >= R_XLEN_T_MAX+1.0)
  ------------------
  |  |   76|      2|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (248:6): [True: 0, False: 2]
  ------------------
  249|      0|	    error(_("invalid '%s' value"), "times");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' value"), "times");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  250|      2|	sna += (R_xlen_t) REAL(t)[i];
  251|      2|    }
  252|     48|    else
  253|     96|    for (i = 0; i < nc; i++) {
  ------------------
  |  Branch (253:17): [True: 48, False: 48]
  ------------------
  254|       |//	if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  255|     48|	if (INTEGER(t)[i] == NA_INTEGER || INTEGER(t)[i] < 0)
  ------------------
  |  |   56|     96|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (255:6): [True: 0, False: 48]
  |  Branch (255:37): [True: 0, False: 48]
  ------------------
  256|      0|	    error(_("invalid '%s' value"), "times");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid '%s' value"), "times");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  257|     48|	sna += INTEGER(t)[i];
  258|     48|    }
  259|     50|    if (sna > R_XLEN_T_MAX)
  ------------------
  |  |   76|     50|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (259:9): [True: 0, False: 50]
  ------------------
  260|      0|	error(_("invalid '%s' value"), "times");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' value"), "times");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  261|     50|    R_xlen_t na = (R_xlen_t) sna;
  262|       |
  263|       |/*    R_xlen_t ni = NINTERRUPT, ratio;
  264|       |    if(nc > 0) {
  265|       |	ratio = na/nc; // average no of replications
  266|       |	if (ratio > 1000U) ni = 1000U;
  267|       |	} */
  268|     50|    PROTECT(a = allocVector(TYPEOF(s), na));
  ------------------
  |  |  357|     50|#define PROTECT(s)	Rf_protect(s)
  ------------------
  269|     50|    n = 0;
  270|     50|    if (TYPEOF(t) == REALSXP)
  ------------------
  |  |  124|     50|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (270:9): [True: 2, False: 48]
  ------------------
  271|      2|	R2_SWITCH_LOOP(REAL(t))
  ------------------
  |  |  177|      2|    switch (TYPEOF(s)) { \
  |  |  178|      0|    case LGLSXP: \
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (178:5): [True: 0, False: 2]
  |  |  ------------------
  |  |  179|      0|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (179:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  180|      0|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  181|      0|	    for (j = 0; j < (R_xlen_t) it[i]; j++) \
  |  |  ------------------
  |  |  |  Branch (181:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  182|      0|		LOGICAL(a)[n++] = LOGICAL(s)[i]; \
  |  |  183|      0|	} \
  |  |  184|      0|	break; \
  |  |  185|      0|    case INTSXP: \
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (185:5): [True: 0, False: 2]
  |  |  ------------------
  |  |  186|      0|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (186:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  187|      0|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  188|      0|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  |  |  ------------------
  |  |  |  Branch (188:33): [True: 0, False: 0]
  |  |  ------------------
  |  |  189|      0|		INTEGER(a)[n++] = INTEGER(s)[i]; \
  |  |  190|      0|	} \
  |  |  191|      0|	break; \
  |  |  192|      0|    case REALSXP: \
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (192:5): [True: 0, False: 2]
  |  |  ------------------
  |  |  193|      0|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (193:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  194|      0|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  195|      0|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  |  |  ------------------
  |  |  |  Branch (195:33): [True: 0, False: 0]
  |  |  ------------------
  |  |  196|      0|		REAL(a)[n++] = REAL(s)[i]; \
  |  |  197|      0|	} \
  |  |  198|      0|	break; \
  |  |  199|      0|    case CPLXSXP: \
  |  |  ------------------
  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |  |  Branch (199:5): [True: 0, False: 2]
  |  |  ------------------
  |  |  200|      0|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (200:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  201|      0|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  202|      0|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  |  |  ------------------
  |  |  |  Branch (202:33): [True: 0, False: 0]
  |  |  ------------------
  |  |  203|      0|		COMPLEX(a)[n++] = COMPLEX(s)[i]; \
  |  |  204|      0|	} \
  |  |  205|      0|	break; \
  |  |  206|      0|    case STRSXP: \
  |  |  ------------------
  |  |  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (206:5): [True: 0, False: 2]
  |  |  ------------------
  |  |  207|      0|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (207:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  208|      0|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  209|      0|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  |  |  ------------------
  |  |  |  Branch (209:33): [True: 0, False: 0]
  |  |  ------------------
  |  |  210|      0|		SET_STRING_ELT(a, n++, STRING_ELT(s, i)); \
  |  |  211|      0|	} \
  |  |  212|      0|	break; \
  |  |  213|      2|    case VECSXP: \
  |  |  ------------------
  |  |  |  |  131|      2|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (213:5): [True: 2, False: 0]
  |  |  ------------------
  |  |  214|      2|    case EXPRSXP: \
  |  |  ------------------
  |  |  |  |  132|      2|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  ------------------
  |  |  |  Branch (214:5): [True: 0, False: 2]
  |  |  ------------------
  |  |  215|      4|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (215:14): [True: 2, False: 2]
  |  |  ------------------
  |  |  216|      2|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  217|      2|	    SEXP elt = lazy_duplicate(VECTOR_ELT(s, i)); \
  |  |  ------------------
  |  |  |  |  985|      2|#define lazy_duplicate		Rf_lazy_duplicate
  |  |  ------------------
  |  |  218|     16|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  |  |  ------------------
  |  |  |  Branch (218:33): [True: 14, False: 2]
  |  |  ------------------
  |  |  219|     14|		SET_VECTOR_ELT(a, n++, elt); \
  |  |  ------------------
  |  |  |  |  911|     14|#define elt			Rf_elt
  |  |  ------------------
  |  |  220|      2|	} \
  |  |  221|      2|	break; \
  |  |  222|      2|    case RAWSXP: \
  |  |  ------------------
  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (222:5): [True: 0, False: 2]
  |  |  ------------------
  |  |  223|      0|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (223:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  224|      0|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  225|      0|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  |  |  ------------------
  |  |  |  Branch (225:33): [True: 0, False: 0]
  |  |  ------------------
  |  |  226|      0|		RAW(a)[n++] = RAW(s)[i]; \
  |  |  227|      0|	} \
  |  |  228|      0|	break; \
  |  |  229|      2|    default: \
  |  |  ------------------
  |  |  |  Branch (229:5): [True: 0, False: 2]
  |  |  ------------------
  |  |  230|      0|	UNIMPLEMENTED_TYPE("rep2", s); \
  |  |  231|      2|    }
  ------------------
  272|     48|    else
  273|     48|	R2_SWITCH_LOOP(INTEGER(t))
  ------------------
  |  |  177|     48|    switch (TYPEOF(s)) { \
  |  |  178|      2|    case LGLSXP: \
  |  |  ------------------
  |  |  |  |  121|      2|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (178:5): [True: 2, False: 46]
  |  |  ------------------
  |  |  179|      4|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (179:14): [True: 2, False: 2]
  |  |  ------------------
  |  |  180|      2|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  181|      4|	    for (j = 0; j < (R_xlen_t) it[i]; j++) \
  |  |  ------------------
  |  |  |  Branch (181:18): [True: 2, False: 2]
  |  |  ------------------
  |  |  182|      2|		LOGICAL(a)[n++] = LOGICAL(s)[i]; \
  |  |  183|      2|	} \
  |  |  184|      2|	break; \
  |  |  185|      0|    case INTSXP: \
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (185:5): [True: 0, False: 48]
  |  |  ------------------
  |  |  186|      0|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (186:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  187|      0|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  188|      0|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  |  |  ------------------
  |  |  |  Branch (188:33): [True: 0, False: 0]
  |  |  ------------------
  |  |  189|      0|		INTEGER(a)[n++] = INTEGER(s)[i]; \
  |  |  190|      0|	} \
  |  |  191|      0|	break; \
  |  |  192|      0|    case REALSXP: \
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (192:5): [True: 0, False: 48]
  |  |  ------------------
  |  |  193|      0|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (193:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  194|      0|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  195|      0|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  |  |  ------------------
  |  |  |  Branch (195:33): [True: 0, False: 0]
  |  |  ------------------
  |  |  196|      0|		REAL(a)[n++] = REAL(s)[i]; \
  |  |  197|      0|	} \
  |  |  198|      0|	break; \
  |  |  199|      0|    case CPLXSXP: \
  |  |  ------------------
  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |  |  Branch (199:5): [True: 0, False: 48]
  |  |  ------------------
  |  |  200|      0|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (200:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  201|      0|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  202|      0|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  |  |  ------------------
  |  |  |  Branch (202:33): [True: 0, False: 0]
  |  |  ------------------
  |  |  203|      0|		COMPLEX(a)[n++] = COMPLEX(s)[i]; \
  |  |  204|      0|	} \
  |  |  205|      0|	break; \
  |  |  206|      6|    case STRSXP: \
  |  |  ------------------
  |  |  |  |  126|      6|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (206:5): [True: 6, False: 42]
  |  |  ------------------
  |  |  207|     12|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (207:14): [True: 6, False: 6]
  |  |  ------------------
  |  |  208|      6|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  209|     22|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  |  |  ------------------
  |  |  |  Branch (209:33): [True: 16, False: 6]
  |  |  ------------------
  |  |  210|     16|		SET_STRING_ELT(a, n++, STRING_ELT(s, i)); \
  |  |  211|      6|	} \
  |  |  212|      6|	break; \
  |  |  213|     40|    case VECSXP: \
  |  |  ------------------
  |  |  |  |  131|     40|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (213:5): [True: 40, False: 8]
  |  |  ------------------
  |  |  214|     40|    case EXPRSXP: \
  |  |  ------------------
  |  |  |  |  132|     40|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  ------------------
  |  |  |  Branch (214:5): [True: 0, False: 48]
  |  |  ------------------
  |  |  215|     80|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (215:14): [True: 40, False: 40]
  |  |  ------------------
  |  |  216|     40|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  217|     40|	    SEXP elt = lazy_duplicate(VECTOR_ELT(s, i)); \
  |  |  ------------------
  |  |  |  |  985|     40|#define lazy_duplicate		Rf_lazy_duplicate
  |  |  ------------------
  |  |  218|     80|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  |  |  ------------------
  |  |  |  Branch (218:33): [True: 40, False: 40]
  |  |  ------------------
  |  |  219|     40|		SET_VECTOR_ELT(a, n++, elt); \
  |  |  ------------------
  |  |  |  |  911|     40|#define elt			Rf_elt
  |  |  ------------------
  |  |  220|     40|	} \
  |  |  221|     40|	break; \
  |  |  222|     40|    case RAWSXP: \
  |  |  ------------------
  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (222:5): [True: 0, False: 48]
  |  |  ------------------
  |  |  223|      0|	for (i = 0; i < nc; i++) { \
  |  |  ------------------
  |  |  |  Branch (223:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  224|      0|/*	    if ((i+1) % ni == 0) R_CheckUserInterrupt();*/ \
  |  |  225|      0|	    for (j = (R_xlen_t) it[i]; j > 0; j--) \
  |  |  ------------------
  |  |  |  Branch (225:33): [True: 0, False: 0]
  |  |  ------------------
  |  |  226|      0|		RAW(a)[n++] = RAW(s)[i]; \
  |  |  227|      0|	} \
  |  |  228|      0|	break; \
  |  |  229|     40|    default: \
  |  |  ------------------
  |  |  |  Branch (229:5): [True: 0, False: 48]
  |  |  ------------------
  |  |  230|      0|	UNIMPLEMENTED_TYPE("rep2", s); \
  |  |  231|     48|    }
  ------------------
  274|     50|    UNPROTECT(2);
  ------------------
  |  |  358|     50|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  275|     50|    return a;
  276|     50|}
seq.c:rep3:
  281|    911|{
  282|    911|    R_xlen_t i, j;
  283|    911|    SEXP a;
  284|       |
  285|    911|    PROTECT(a = allocVector(TYPEOF(s), na));
  ------------------
  |  |  357|    911|#define PROTECT(s)	Rf_protect(s)
  ------------------
  286|       |
  287|    911|    switch (TYPEOF(s)) {
  288|      4|    case LGLSXP:
  ------------------
  |  |  121|      4|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (288:5): [True: 4, False: 907]
  ------------------
  289|      4|	MOD_ITERATE1(na, ns, i, j, {
  ------------------
  |  |   67|      4|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |   68|      4|	i = i1 = 0;					\
  |  |   69|      4|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  ------------------
  |  |  |  |   59|      4|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   60|     20|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:9): [True: 16, False: 4]
  |  |  |  |  ------------------
  |  |  |  |   61|     16|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:12): [True: 16, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   62|     16|		 ++i) {							\
  |  |  |  |   63|     16|	    loop_body							\
  |  |  |  |   64|     16|		}							\
  |  |  |  |   65|      4|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:14): [Folded, False: 4]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      4|    } while (0)
  |  |  ------------------
  |  |  |  Branch (70:14): [Folded, False: 4]
  |  |  ------------------
  ------------------
  290|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  291|      4|	    LOGICAL(a)[i] = LOGICAL(s)[j];
  292|      4|	});
  293|      4|	break;
  294|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (294:5): [True: 0, False: 911]
  ------------------
  295|      0|	MOD_ITERATE1(na, ns, i, j, {
  ------------------
  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |   68|      0|	i = i1 = 0;					\
  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  ------------------
  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |   64|      0|		}							\
  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  296|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  297|      0|	    INTEGER(a)[i] = INTEGER(s)[j];
  298|      0|	});
  299|      0|	break;
  300|    907|    case REALSXP:
  ------------------
  |  |  124|    907|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (300:5): [True: 907, False: 4]
  ------------------
  301|    907|	MOD_ITERATE1(na, ns, i, j,  {
  ------------------
  |  |   67|    907|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |   68|    907|	i = i1 = 0;					\
  |  |   69|    907|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  ------------------
  |  |  |  |   59|    907|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   60|   476k|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:9): [True: 475k, False: 907]
  |  |  |  |  ------------------
  |  |  |  |   61|   475k|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:12): [True: 447, False: 475k]
  |  |  |  |  ------------------
  |  |  |  |   62|   475k|		 ++i) {							\
  |  |  |  |   63|   475k|	    loop_body							\
  |  |  |  |   64|   475k|		}							\
  |  |  |  |   65|    907|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:14): [Folded, False: 907]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|    907|    } while (0)
  |  |  ------------------
  |  |  |  Branch (70:14): [Folded, False: 907]
  |  |  ------------------
  ------------------
  302|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  303|    907|	    REAL(a)[i] = REAL(s)[j];
  304|    907|	});
  305|    907|	break;
  306|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (306:5): [True: 0, False: 911]
  ------------------
  307|      0|	MOD_ITERATE1(na, ns, i, j, {
  ------------------
  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |   68|      0|	i = i1 = 0;					\
  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  ------------------
  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |   64|      0|		}							\
  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  308|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  309|      0|	    COMPLEX(a)[i] = COMPLEX(s)[j];
  310|      0|	});
  311|      0|	break;
  312|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (312:5): [True: 0, False: 911]
  ------------------
  313|      0|	MOD_ITERATE1(na, ns, i, j, {
  ------------------
  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |   68|      0|	i = i1 = 0;					\
  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  ------------------
  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |   64|      0|		}							\
  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  314|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  315|      0|	    RAW(a)[i] = RAW(s)[j];
  316|      0|	});
  317|      0|	break;
  318|      0|    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (318:5): [True: 0, False: 911]
  ------------------
  319|      0|	MOD_ITERATE1(na, ns, i, j, {
  ------------------
  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |   68|      0|	i = i1 = 0;					\
  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  ------------------
  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |   64|      0|		}							\
  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  320|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  321|      0|	    SET_STRING_ELT(a, i, STRING_ELT(s, j));
  322|      0|	});
  323|      0|	break;
  324|      0|    case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (324:5): [True: 0, False: 911]
  ------------------
  325|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (325:5): [True: 0, False: 911]
  ------------------
  326|      0|	MOD_ITERATE1(na, ns, i, j, {
  ------------------
  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |   68|      0|	i = i1 = 0;					\
  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  ------------------
  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |   64|      0|		}							\
  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   70|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  327|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  328|      0|	    SET_VECTOR_ELT(a, i, lazy_duplicate(VECTOR_ELT(s, j)));
  329|      0|	});
  330|      0|	break;
  331|      0|    default:
  ------------------
  |  Branch (331:5): [True: 0, False: 911]
  ------------------
  332|      0|	UNIMPLEMENTED_TYPE("rep3", s);
  333|    911|    }
  334|    911|    UNPROTECT(1);
  ------------------
  |  |  358|    911|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  335|    911|    return a;
  336|    911|}
seq.c:rep4:
  482|      1|{
  483|      1|    SEXP a;
  484|      1|    R_xlen_t lx = xlength(x);
  ------------------
  |  | 1049|      1|#define xlength(x)		Rf_xlength(x)
  ------------------
  485|      1|    R_xlen_t i, j, k, k2, k3, sum;
  486|       |
  487|       |    // faster code for common special case
  488|      1|    if (each == 1 && nt == 1) return rep3(x, lx, len);
  ------------------
  |  Branch (488:9): [True: 1, False: 0]
  |  Branch (488:22): [True: 0, False: 1]
  ------------------
  489|       |
  490|      1|    PROTECT(a = allocVector(TYPEOF(x), len));
  ------------------
  |  |  357|      1|#define PROTECT(s)	Rf_protect(s)
  ------------------
  491|       |
  492|      1|#define R4_SWITCH_LOOP(itimes)						\
  493|      1|    switch (TYPEOF(x)) {						\
  494|      1|    case LGLSXP:							\
  495|      1|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  496|       |	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  497|      1|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  498|      1|	    for(k3 = 0; k3 < sum; k3++) {				\
  499|      1|		LOGICAL(a)[k2++] = LOGICAL(x)[i];			\
  500|      1|		if(k2 == len) goto done;				\
  501|      1|	    }								\
  502|      1|	}								\
  503|      1|	break;								\
  504|      1|    case INTSXP:							\
  505|      1|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  506|       |	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  507|      1|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  508|      1|	    for(k3 = 0; k3 < sum; k3++) {				\
  509|      1|		INTEGER(a)[k2++] = INTEGER(x)[i];			\
  510|      1|		if(k2 == len) goto done;				\
  511|      1|	    }								\
  512|      1|	}								\
  513|      1|	break;								\
  514|      1|    case REALSXP:							\
  515|      1|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  516|       |	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  517|      1|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  518|      1|	    for(k3 = 0; k3 < sum; k3++) {				\
  519|      1|		REAL(a)[k2++] = REAL(x)[i];				\
  520|      1|		if(k2 == len) goto done;				\
  521|      1|	    }								\
  522|      1|	}								\
  523|      1|	break;								\
  524|      1|    case CPLXSXP:							\
  525|      1|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  526|       |	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  527|      1|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  528|      1|	    for(k3 = 0; k3 < sum; k3++) {				\
  529|      1|		COMPLEX(a)[k2++] = COMPLEX(x)[i];			\
  530|      1|		if(k2 == len) goto done;				\
  531|      1|	    }								\
  532|      1|	}								\
  533|      1|	break;								\
  534|      1|    case STRSXP:							\
  535|      1|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  536|       |	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  537|      1|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  538|      1|	    for(k3 = 0; k3 < sum; k3++) {				\
  539|      1|		SET_STRING_ELT(a, k2++, STRING_ELT(x, i));		\
  540|      1|		if(k2 == len) goto done;				\
  541|      1|	    }								\
  542|      1|	}								\
  543|      1|	break;								\
  544|      1|    case VECSXP:							\
  545|      1|    case EXPRSXP:							\
  546|      1|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  547|       |	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  548|      1|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  549|      1|	    SEXP elt = lazy_duplicate(VECTOR_ELT(x, i));		\
  550|      1|	    for(k3 = 0; k3 < sum; k3++) {				\
  551|      1|		SET_VECTOR_ELT(a, k2++, elt);				\
  552|      1|		if(k2 == len) goto done;				\
  553|      1|	    }								\
  554|      1|	}								\
  555|      1|	break;								\
  556|      1|    case RAWSXP:							\
  557|      1|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  558|       |	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  559|      1|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  560|      1|	    for(k3 = 0; k3 < sum; k3++) {				\
  561|      1|		RAW(a)[k2++] = RAW(x)[i];				\
  562|      1|		if(k2 == len) goto done;				\
  563|      1|	    }								\
  564|      1|	}								\
  565|      1|	break;								\
  566|      1|    default:								\
  567|      1|	UNIMPLEMENTED_TYPE("rep4", x);					\
  568|      1|    }
  569|       |
  570|      1|    if(nt == 1)
  ------------------
  |  Branch (570:8): [True: 0, False: 1]
  ------------------
  571|      0|	switch (TYPEOF(x)) {
  572|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (572:2): [True: 0, False: 0]
  ------------------
  573|      0|	    for(i = 0; i < len; i++) {
  ------------------
  |  Branch (573:17): [True: 0, False: 0]
  ------------------
  574|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  575|      0|		LOGICAL(a)[i] = LOGICAL(x)[(i/each) % lx];
  576|      0|	    }
  577|      0|	    break;
  578|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (578:2): [True: 0, False: 0]
  ------------------
  579|      0|	    for(i = 0; i < len; i++) {
  ------------------
  |  Branch (579:17): [True: 0, False: 0]
  ------------------
  580|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  581|      0|		INTEGER(a)[i] = INTEGER(x)[(i/each) % lx];
  582|      0|	    }
  583|      0|	    break;
  584|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (584:2): [True: 0, False: 0]
  ------------------
  585|      0|	    for(i = 0; i < len; i++) {
  ------------------
  |  Branch (585:17): [True: 0, False: 0]
  ------------------
  586|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  587|      0|		REAL(a)[i] = REAL(x)[(i/each) % lx];
  588|      0|	    }
  589|      0|	    break;
  590|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (590:2): [True: 0, False: 0]
  ------------------
  591|      0|	    for(i = 0; i < len; i++) {
  ------------------
  |  Branch (591:17): [True: 0, False: 0]
  ------------------
  592|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  593|      0|		COMPLEX(a)[i] = COMPLEX(x)[(i/each) % lx];
  594|      0|	    }
  595|      0|	    break;
  596|      0|	case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (596:2): [True: 0, False: 0]
  ------------------
  597|      0|	    for(i = 0; i < len; i++) {
  ------------------
  |  Branch (597:17): [True: 0, False: 0]
  ------------------
  598|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  599|      0|		SET_STRING_ELT(a, i, STRING_ELT(x, (i/each) % lx));
  600|      0|	    }
  601|      0|	    break;
  602|      0|	case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (602:2): [True: 0, False: 0]
  ------------------
  603|      0|	case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (603:2): [True: 0, False: 0]
  ------------------
  604|      0|	    for(i = 0; i < len; i++) {
  ------------------
  |  Branch (604:17): [True: 0, False: 0]
  ------------------
  605|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  606|      0|		SEXP elt = lazy_duplicate(VECTOR_ELT(x, (i/each) % lx));
  ------------------
  |  |  985|      0|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
  607|      0|		SET_VECTOR_ELT(a, i, elt);
  ------------------
  |  |  911|      0|#define elt			Rf_elt
  ------------------
  608|      0|	    }
  609|      0|	    break;
  610|      0|	case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (610:2): [True: 0, False: 0]
  ------------------
  611|      0|	    for(i = 0; i < len; i++) {
  ------------------
  |  Branch (611:17): [True: 0, False: 0]
  ------------------
  612|       |//		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  613|      0|		RAW(a)[i] = RAW(x)[(i/each) % lx];
  614|      0|	    }
  615|      0|	    break;
  616|      0|	default:
  ------------------
  |  Branch (616:2): [True: 0, False: 0]
  ------------------
  617|      0|	    UNIMPLEMENTED_TYPE("rep4", x);
  618|      0|	}
  619|      1|    else if(TYPEOF(times) == REALSXP)
  ------------------
  |  |  124|      1|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (619:13): [True: 1, False: 0]
  ------------------
  620|      1|	R4_SWITCH_LOOP(REAL(times))
  ------------------
  |  |  493|      1|    switch (TYPEOF(x)) {						\
  |  |  494|      0|    case LGLSXP:							\
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (494:5): [True: 0, False: 1]
  |  |  ------------------
  |  |  495|      0|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (495:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  496|      0|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  497|      0|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (497:26): [True: 0, False: 0]
  |  |  ------------------
  |  |  498|      0|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (498:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  499|      0|		LOGICAL(a)[k2++] = LOGICAL(x)[i];			\
  |  |  500|      0|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (500:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  501|      0|	    }								\
  |  |  502|      0|	}								\
  |  |  503|      0|	break;								\
  |  |  504|      0|    case INTSXP:							\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (504:5): [True: 0, False: 1]
  |  |  ------------------
  |  |  505|      0|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (505:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  506|      0|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  507|      0|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (507:26): [True: 0, False: 0]
  |  |  ------------------
  |  |  508|      0|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (508:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  509|      0|		INTEGER(a)[k2++] = INTEGER(x)[i];			\
  |  |  510|      0|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (510:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  511|      0|	    }								\
  |  |  512|      0|	}								\
  |  |  513|      0|	break;								\
  |  |  514|      0|    case REALSXP:							\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (514:5): [True: 0, False: 1]
  |  |  ------------------
  |  |  515|      0|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (515:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  516|      0|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  517|      0|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (517:26): [True: 0, False: 0]
  |  |  ------------------
  |  |  518|      0|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (518:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  519|      0|		REAL(a)[k2++] = REAL(x)[i];				\
  |  |  520|      0|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (520:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  521|      0|	    }								\
  |  |  522|      0|	}								\
  |  |  523|      0|	break;								\
  |  |  524|      0|    case CPLXSXP:							\
  |  |  ------------------
  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |  |  Branch (524:5): [True: 0, False: 1]
  |  |  ------------------
  |  |  525|      0|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (525:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  526|      0|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  527|      0|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (527:26): [True: 0, False: 0]
  |  |  ------------------
  |  |  528|      0|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (528:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  529|      0|		COMPLEX(a)[k2++] = COMPLEX(x)[i];			\
  |  |  530|      0|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (530:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  531|      0|	    }								\
  |  |  532|      0|	}								\
  |  |  533|      0|	break;								\
  |  |  534|      1|    case STRSXP:							\
  |  |  ------------------
  |  |  |  |  126|      1|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (534:5): [True: 1, False: 0]
  |  |  ------------------
  |  |  535|      3|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (535:28): [True: 3, False: 0]
  |  |  ------------------
  |  |  536|      3|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  537|      6|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (537:26): [True: 3, False: 3]
  |  |  ------------------
  |  |  538|      3|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (538:18): [True: 1, False: 2]
  |  |  ------------------
  |  |  539|      1|		SET_STRING_ELT(a, k2++, STRING_ELT(x, i));		\
  |  |  540|      1|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (540:6): [True: 1, False: 0]
  |  |  ------------------
  |  |  541|      1|	    }								\
  |  |  542|      3|	}								\
  |  |  543|      1|	break;								\
  |  |  544|      1|    case VECSXP:							\
  |  |  ------------------
  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (544:5): [True: 0, False: 1]
  |  |  ------------------
  |  |  545|      0|    case EXPRSXP:							\
  |  |  ------------------
  |  |  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  ------------------
  |  |  |  Branch (545:5): [True: 0, False: 1]
  |  |  ------------------
  |  |  546|      0|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (546:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  547|      0|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  548|      0|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (548:26): [True: 0, False: 0]
  |  |  ------------------
  |  |  549|      0|	    SEXP elt = lazy_duplicate(VECTOR_ELT(x, i));		\
  |  |  ------------------
  |  |  |  |  985|      0|#define lazy_duplicate		Rf_lazy_duplicate
  |  |  ------------------
  |  |  550|      0|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (550:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  551|      0|		SET_VECTOR_ELT(a, k2++, elt);				\
  |  |  ------------------
  |  |  |  |  911|      0|#define elt			Rf_elt
  |  |  ------------------
  |  |  552|      0|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (552:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  553|      0|	    }								\
  |  |  554|      0|	}								\
  |  |  555|      0|	break;								\
  |  |  556|      0|    case RAWSXP:							\
  |  |  ------------------
  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (556:5): [True: 0, False: 1]
  |  |  ------------------
  |  |  557|      0|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (557:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  558|      0|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  559|      0|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (559:26): [True: 0, False: 0]
  |  |  ------------------
  |  |  560|      0|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (560:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  561|      0|		RAW(a)[k2++] = RAW(x)[i];				\
  |  |  562|      0|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (562:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  563|      0|	    }								\
  |  |  564|      0|	}								\
  |  |  565|      0|	break;								\
  |  |  566|      0|    default:								\
  |  |  ------------------
  |  |  |  Branch (566:5): [True: 0, False: 1]
  |  |  ------------------
  |  |  567|      0|	UNIMPLEMENTED_TYPE("rep4", x);					\
  |  |  568|      1|    }
  ------------------
  621|      0|	else
  622|      0|	    R4_SWITCH_LOOP(INTEGER(times))
  ------------------
  |  |  493|      0|    switch (TYPEOF(x)) {						\
  |  |  494|      0|    case LGLSXP:							\
  |  |  ------------------
  |  |  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  |  |  ------------------
  |  |  |  Branch (494:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  495|      0|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (495:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  496|      0|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  497|      0|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (497:26): [True: 0, False: 0]
  |  |  ------------------
  |  |  498|      0|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (498:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  499|      0|		LOGICAL(a)[k2++] = LOGICAL(x)[i];			\
  |  |  500|      0|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (500:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  501|      0|	    }								\
  |  |  502|      0|	}								\
  |  |  503|      0|	break;								\
  |  |  504|      0|    case INTSXP:							\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (504:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  505|      0|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (505:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  506|      0|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  507|      0|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (507:26): [True: 0, False: 0]
  |  |  ------------------
  |  |  508|      0|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (508:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  509|      0|		INTEGER(a)[k2++] = INTEGER(x)[i];			\
  |  |  510|      0|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (510:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  511|      0|	    }								\
  |  |  512|      0|	}								\
  |  |  513|      0|	break;								\
  |  |  514|      0|    case REALSXP:							\
  |  |  ------------------
  |  |  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |  |  Branch (514:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  515|      0|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (515:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  516|      0|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  517|      0|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (517:26): [True: 0, False: 0]
  |  |  ------------------
  |  |  518|      0|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (518:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  519|      0|		REAL(a)[k2++] = REAL(x)[i];				\
  |  |  520|      0|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (520:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  521|      0|	    }								\
  |  |  522|      0|	}								\
  |  |  523|      0|	break;								\
  |  |  524|      0|    case CPLXSXP:							\
  |  |  ------------------
  |  |  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  |  |  ------------------
  |  |  |  Branch (524:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  525|      0|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (525:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  526|      0|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  527|      0|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (527:26): [True: 0, False: 0]
  |  |  ------------------
  |  |  528|      0|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (528:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  529|      0|		COMPLEX(a)[k2++] = COMPLEX(x)[i];			\
  |  |  530|      0|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (530:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  531|      0|	    }								\
  |  |  532|      0|	}								\
  |  |  533|      0|	break;								\
  |  |  534|      0|    case STRSXP:							\
  |  |  ------------------
  |  |  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (534:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  535|      0|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (535:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  536|      0|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  537|      0|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (537:26): [True: 0, False: 0]
  |  |  ------------------
  |  |  538|      0|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (538:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  539|      0|		SET_STRING_ELT(a, k2++, STRING_ELT(x, i));		\
  |  |  540|      0|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (540:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  541|      0|	    }								\
  |  |  542|      0|	}								\
  |  |  543|      0|	break;								\
  |  |  544|      0|    case VECSXP:							\
  |  |  ------------------
  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (544:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  545|      0|    case EXPRSXP:							\
  |  |  ------------------
  |  |  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  ------------------
  |  |  |  Branch (545:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  546|      0|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (546:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  547|      0|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  548|      0|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (548:26): [True: 0, False: 0]
  |  |  ------------------
  |  |  549|      0|	    SEXP elt = lazy_duplicate(VECTOR_ELT(x, i));		\
  |  |  ------------------
  |  |  |  |  985|      0|#define lazy_duplicate		Rf_lazy_duplicate
  |  |  ------------------
  |  |  550|      0|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (550:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  551|      0|		SET_VECTOR_ELT(a, k2++, elt);				\
  |  |  ------------------
  |  |  |  |  911|      0|#define elt			Rf_elt
  |  |  ------------------
  |  |  552|      0|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (552:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  553|      0|	    }								\
  |  |  554|      0|	}								\
  |  |  555|      0|	break;								\
  |  |  556|      0|    case RAWSXP:							\
  |  |  ------------------
  |  |  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  |  |  ------------------
  |  |  |  Branch (556:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  557|      0|	for(i = 0, k = 0, k2 = 0; i < lx; i++) {			\
  |  |  ------------------
  |  |  |  Branch (557:28): [True: 0, False: 0]
  |  |  ------------------
  |  |  558|      0|	    /*		if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();*/ \
  |  |  559|      0|	    for(j = 0, sum = 0; j < each; j++) sum += (R_xlen_t) itimes[k++]; \
  |  |  ------------------
  |  |  |  Branch (559:26): [True: 0, False: 0]
  |  |  ------------------
  |  |  560|      0|	    for(k3 = 0; k3 < sum; k3++) {				\
  |  |  ------------------
  |  |  |  Branch (560:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  561|      0|		RAW(a)[k2++] = RAW(x)[i];				\
  |  |  562|      0|		if(k2 == len) goto done;				\
  |  |  ------------------
  |  |  |  Branch (562:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  563|      0|	    }								\
  |  |  564|      0|	}								\
  |  |  565|      0|	break;								\
  |  |  566|      0|    default:								\
  |  |  ------------------
  |  |  |  Branch (566:5): [True: 0, False: 0]
  |  |  ------------------
  |  |  567|      0|	UNIMPLEMENTED_TYPE("rep4", x);					\
  |  |  568|      0|    }
  ------------------
  623|      1|		done:
  624|      1|	    UNPROTECT(1);
  ------------------
  |  |  358|      1|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  625|      1|    return a;
  626|      1|}

R_Unserialize:
 2341|  1.59k|{
 2342|  1.59k|    int version;
 2343|  1.59k|    int writer_version, min_reader_version;
 2344|  1.59k|    SEXP obj, ref_table;
 2345|       |
 2346|  1.59k|    InFormat(stream);
 2347|       |
 2348|       |    /* Read the version numbers */
 2349|  1.59k|    version = InInteger(stream);
 2350|  1.59k|    writer_version = InInteger(stream);
 2351|  1.59k|    min_reader_version = InInteger(stream);
 2352|  1.59k|    switch (version) {
 2353|      0|    case 2: break;
  ------------------
  |  Branch (2353:5): [True: 0, False: 1.59k]
  ------------------
 2354|  1.59k|    case 3:
  ------------------
  |  Branch (2354:5): [True: 1.59k, False: 0]
  ------------------
 2355|  1.59k|    {
 2356|  1.59k|	int nelen = InInteger(stream);
 2357|  1.59k|	if (nelen > R_CODESET_MAX || nelen < 0)
  ------------------
  |  |  738|  3.18k|#define R_CODESET_MAX 63
  ------------------
  |  Branch (2357:6): [True: 0, False: 1.59k]
  |  Branch (2357:31): [True: 0, False: 1.59k]
  ------------------
 2358|      0|	    error(_("invalid length of encoding name"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid length of encoding name"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2359|  1.59k|	InString(stream, stream->native_encoding, nelen);
 2360|  1.59k|	stream->native_encoding[nelen] = '\0';
 2361|  1.59k|	if (memchr(stream->native_encoding, '\0', nelen))
  ------------------
  |  Branch (2361:6): [True: 0, False: 1.59k]
  ------------------
 2362|      0|	    error(_("embedded nul in encoding name"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("embedded nul in encoding name"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2363|  1.59k|	break;
 2364|      0|    }
 2365|      0|    default:
  ------------------
  |  Branch (2365:5): [True: 0, False: 1.59k]
  ------------------
 2366|      0|	{
 2367|      0|	    int vw, pw, sw;
 2368|      0|	    DecodeVersion(writer_version, &vw, &pw, &sw);
 2369|      0|	    if (min_reader_version < 0)
  ------------------
  |  Branch (2369:10): [True: 0, False: 0]
  ------------------
 2370|      0|		error(_("cannot read unreleased workspace version %d written by experimental R %d.%d.%d"), version, vw, pw, sw);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("cannot read unreleased workspace version %d written by experimental R %d.%d.%d"), version, vw, pw, sw);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2371|      0|	    else {
 2372|      0|		int vm, pm, sm;
 2373|      0|		DecodeVersion(min_reader_version, &vm, &pm, &sm);
 2374|      0|		error(_("cannot read workspace version %d written by R %d.%d.%d; need R %d.%d.%d or newer"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("cannot read workspace version %d written by R %d.%d.%d; need R %d.%d.%d or newer"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2375|      0|		      version, vw, pw, sw, vm, pm, sm);
 2376|      0|	    }
 2377|      0|	}
 2378|  1.59k|    }
 2379|       |
 2380|       |    /* Read the actual object back */
 2381|  1.59k|    PROTECT(ref_table = MakeReadRefTable());
  ------------------
  |  |  357|  1.59k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2382|       |
 2383|  1.59k|    RCNTXT cntxt;
 2384|  1.59k|    begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
  ------------------
  |  | 1864|  1.59k|# define begincontext		Rf_begincontext
  ------------------
 2385|  1.59k|		 R_NilValue, R_NilValue);
 2386|  1.59k|    cntxt.cend = &CloseInStreamConverters;
 2387|  1.59k|    cntxt.cenddata = stream;
 2388|       |
 2389|  1.59k|    obj = ReadItem(ref_table, stream);
 2390|       |
 2391|  1.59k|    endcontext(&cntxt);
  ------------------
  |  | 1895|  1.59k|# define endcontext		Rf_endcontext
  ------------------
 2392|  1.59k|    CloseInStreamConverters(stream);
 2393|  1.59k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.59k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2394|       |
 2395|  1.59k|    return obj;
 2396|  1.59k|}
R_InitInPStream:
 2474|  1.59k|{
 2475|  1.59k|    stream->data = data;
 2476|  1.59k|    stream->type = type;
 2477|  1.59k|    stream->InChar = inchar;
 2478|  1.59k|    stream->InBytes = inbytes;
 2479|  1.59k|    stream->InPersistHookFunc = phook;
 2480|  1.59k|    stream->InPersistHookData = pdata;
 2481|  1.59k|    stream->native_encoding[0] = 0;
 2482|  1.59k|    stream->nat2nat_obj = NULL;
 2483|       |    stream->nat2utf8_obj = NULL;
 2484|  1.59k|}
R_InitConnInPStream:
 2670|     72|{
 2671|     72|    CheckInConn(con);
 2672|     72|    if (con->text) {
  ------------------
  |  Branch (2672:9): [True: 0, False: 72]
  ------------------
 2673|      0|	if (type == R_pstream_any_format)
  ------------------
  |  Branch (2673:6): [True: 0, False: 0]
  ------------------
 2674|      0|	    type = R_pstream_ascii_format;
 2675|      0|	else if (type != R_pstream_ascii_format)
  ------------------
  |  Branch (2675:11): [True: 0, False: 0]
  ------------------
 2676|      0|	    error(_("only ascii format can be read from text mode connections"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("only ascii format can be read from text mode connections"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2677|      0|    }
 2678|     72|    R_InitInPStream(stream, (R_pstream_data_t) con, type,
 2679|     72|		    InCharConn, InBytesConn, phook, pdata);
 2680|     72|}
do_unserializeFromConn:
 2781|     72|{
 2782|       |    /* 0 .. unserializeFromConn(conn, hook) */
 2783|       |    /* 1 .. serializeInfoFromConn(conn) */
 2784|       |
 2785|     72|    struct R_inpstream_st in;
 2786|     72|    Rconnection con;
 2787|     72|    SEXP fun, ans;
 2788|     72|    SEXP (*hook)(SEXP, SEXP);
 2789|     72|    bool wasopen;
 2790|     72|    RCNTXT cntxt;
 2791|       |
 2792|     72|    checkArity(op, args);
  ------------------
  |  | 1788|     72|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2793|       |
 2794|     72|    con = getConnection(asInteger(CAR(args)));
  ------------------
  |  |  885|     72|#define asInteger		Rf_asInteger
  ------------------
 2795|       |
 2796|       |    /* Now we need to do some sanity checking of the arguments.
 2797|       |       A filename will already have been opened, so anything
 2798|       |       not open was specified as a connection directly.
 2799|       |     */
 2800|     72|    wasopen = con->isopen;
 2801|     72|    if(!wasopen) {
  ------------------
  |  Branch (2801:8): [True: 0, False: 72]
  ------------------
 2802|      0|	char mode[5];
 2803|      0|	strcpy(mode, con->mode);
 2804|      0|	strcpy(con->mode, "rb");
 2805|      0|	if(!con->open(con)) error(_("cannot open the connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if(!con->open(con)) error(_("cannot open the connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (2805:5): [True: 0, False: 0]
  ------------------
 2806|      0|	strcpy(con->mode, mode);
 2807|       |	/* Set up a context which will close the connection on error */
 2808|      0|	begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
  ------------------
  |  | 1864|      0|# define begincontext		Rf_begincontext
  ------------------
 2809|      0|		     R_NilValue, R_NilValue);
 2810|      0|	cntxt.cend = &con_cleanup;
 2811|      0|	cntxt.cenddata = con;
 2812|      0|    }
 2813|     72|    if(!con->canread) error(_("connection not open for reading"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if(!con->canread) error(_("connection not open for reading"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (2813:8): [True: 0, False: 72]
  ------------------
 2814|       |
 2815|     72|    fun = PRIMVAL(op) == 0 ? CADR(args) : R_NilValue;
  ------------------
  |  | 1347|     72|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (2815:11): [True: 72, False: 0]
  ------------------
 2816|     72|    hook = fun != R_NilValue ? CallHook : NULL;
  ------------------
  |  Branch (2816:12): [True: 18, False: 54]
  ------------------
 2817|     72|    R_InitConnInPStream(&in, con, R_pstream_any_format, hook, fun);
 2818|     72|    ans = PRIMVAL(op) == 0 ? R_Unserialize(&in) : R_SerializeInfo(&in);
  ------------------
  |  | 1347|     72|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (2818:11): [True: 72, False: 0]
  ------------------
 2819|     72|    if(!wasopen) {
  ------------------
  |  Branch (2819:8): [True: 0, False: 72]
  ------------------
 2820|      0|	PROTECT(ans); /* paranoia about next line */
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2821|      0|	endcontext(&cntxt);
  ------------------
  |  | 1895|      0|# define endcontext		Rf_endcontext
  ------------------
 2822|      0|	con->close(con);
 2823|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2824|      0|    }
 2825|     72|    return checkNotPromise(ans);
 2826|     72|}
do_lazyLoadDBfetch:
 3478|  1.51k|{
 3479|  1.51k|    SEXP key, file, compsxp, hook;
 3480|  1.51k|    PROTECT_INDEX vpi;
 3481|  1.51k|    int compressed;
 3482|  1.51k|    Rboolean err = FALSE;
 3483|  1.51k|    SEXP val;
 3484|       |
 3485|  1.51k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.51k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 3486|  1.51k|    key = CAR(args); args = CDR(args);
 3487|  1.51k|    file = CAR(args); args = CDR(args);
 3488|  1.51k|    compsxp = CAR(args); args = CDR(args);
 3489|  1.51k|    hook = CAR(args);
 3490|  1.51k|    compressed = asInteger(compsxp);
  ------------------
  |  |  885|  1.51k|#define asInteger		Rf_asInteger
  ------------------
 3491|       |
 3492|  1.51k|    PROTECT_WITH_INDEX(val = readRawFromFile(file, key), &vpi);
  ------------------
  |  |  366|  1.51k|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
 3493|  1.51k|    if (compressed == 3)
  ------------------
  |  Branch (3493:9): [True: 0, False: 1.51k]
  ------------------
 3494|      0|	REPROTECT(val = R_decompress3(val, &err), vpi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 3495|  1.51k|    else if (compressed == 2)
  ------------------
  |  Branch (3495:14): [True: 0, False: 1.51k]
  ------------------
 3496|      0|	REPROTECT(val = R_decompress2(val, &err), vpi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 3497|  1.51k|    else if (compressed)
  ------------------
  |  Branch (3497:14): [True: 1.51k, False: 0]
  ------------------
 3498|  1.51k|	REPROTECT(val = R_decompress1(val, &err), vpi);
  ------------------
  |  |  367|  1.51k|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 3499|  1.51k|    if (err) error("lazy-load database '%s' is corrupt",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (3499:9): [True: 0, False: 1.51k]
  ------------------
 3500|      0|		   translateChar(STRING_ELT(file, 0)));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
 3501|  1.51k|    val = R_unserialize(val, hook);
 3502|  1.51k|    if (TYPEOF(val) == PROMSXP) {
  ------------------
  |  |  116|  1.51k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (3502:9): [True: 0, False: 1.51k]
  ------------------
 3503|      0|	REPROTECT(val, vpi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 3504|      0|	val = eval(val, R_GlobalEnv);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 3505|      0|	ENSURE_NAMEDMAX(val);
 3506|      0|    }
 3507|  1.51k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.51k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3508|  1.51k|    return val;
 3509|  1.51k|}
serialize.c:InFormat:
  588|  1.59k|{
  589|  1.59k|    char buf[2];
  590|  1.59k|    R_pstream_format_t type;
  591|  1.59k|    stream->InBytes(stream, buf, 2);
  592|  1.59k|    switch (buf[0]) {
  593|      0|    case 'A': type = R_pstream_ascii_format; break; /* also for asciihex */
  ------------------
  |  Branch (593:5): [True: 0, False: 1.59k]
  ------------------
  594|      0|    case 'B': type = R_pstream_binary_format; break;
  ------------------
  |  Branch (594:5): [True: 0, False: 1.59k]
  ------------------
  595|  1.59k|    case 'X': type = R_pstream_xdr_format; break;
  ------------------
  |  Branch (595:5): [True: 1.59k, False: 0]
  ------------------
  596|      0|    case '\n':
  ------------------
  |  Branch (596:5): [True: 0, False: 1.59k]
  ------------------
  597|       |	/* GROSS HACK: ASCII unserialize may leave a trailing newline
  598|       |	   in the stream.  If the stream contains a second
  599|       |	   serialization, then a second unserialize will fail if such
  600|       |	   a newline is present.  The right fix is to make sure
  601|       |	   unserialize consumes exactly what serialize produces.  But
  602|       |	   this seems hard because of the current use of whitespace
  603|       |	   skipping in unserialize.  So a temporary hack to cure the
  604|       |	   symptom is to deal with a possible leading newline.  I
  605|       |	   don't think more than one is possible, but I'm not sure.
  606|       |	   LT */
  607|      0|	if (buf[1] == 'A') {
  ------------------
  |  Branch (607:6): [True: 0, False: 0]
  ------------------
  608|      0|	    type = R_pstream_ascii_format;
  609|      0|	    stream->InBytes(stream, buf, 1);
  610|      0|	    break;
  611|      0|	}
  612|      0|    default:
  ------------------
  |  Branch (612:5): [True: 0, False: 1.59k]
  ------------------
  613|      0|	type = R_pstream_any_format;  /* keep compiler happy */
  614|      0|	error(_("unknown input format"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("unknown input format"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  615|  1.59k|    }
  616|  1.59k|    if (stream->type == R_pstream_any_format)
  ------------------
  |  Branch (616:9): [True: 1.59k, False: 0]
  ------------------
  617|  1.59k|	stream->type = type;
  618|      0|    else if (type != stream->type)
  ------------------
  |  Branch (618:14): [True: 0, False: 0]
  ------------------
  619|      0|	error(_("input format does not match specified format"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("input format does not match specified format"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  620|  1.59k|}
serialize.c:InInteger:
  397|  2.10M|{
  398|  2.10M|    char word[128];
  399|  2.10M|    char buf[128];
  400|  2.10M|    int i;
  401|       |
  402|  2.10M|    switch (stream->type) {
  403|      0|    case R_pstream_ascii_format:
  ------------------
  |  Branch (403:5): [True: 0, False: 2.10M]
  ------------------
  404|      0|	InWord(stream, word, sizeof(word));
  405|      0|	if(sscanf(word, "%127s", buf) != 1) error(_("read error"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if(sscanf(word, "%127s", buf) != 1) error(_("read error"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (405:5): [True: 0, False: 0]
  ------------------
  406|      0|	if (strcmp(buf, "NA") == 0)
  ------------------
  |  Branch (406:6): [True: 0, False: 0]
  ------------------
  407|      0|	    return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  408|      0|	else
  409|      0|	    if(sscanf(buf, "%d", &i) != 1) error(_("read error"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    if(sscanf(buf, "%d", &i) != 1) error(_("read error"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (409:9): [True: 0, False: 0]
  ------------------
  410|      0|	return i;
  411|      0|    case R_pstream_binary_format:
  ------------------
  |  Branch (411:5): [True: 0, False: 2.10M]
  ------------------
  412|      0|	stream->InBytes(stream, &i, sizeof(int));
  413|      0|	return i;
  414|  2.10M|    case R_pstream_xdr_format:
  ------------------
  |  Branch (414:5): [True: 2.10M, False: 0]
  ------------------
  415|  2.10M|	stream->InBytes(stream, buf, R_XDR_INTEGER_SIZE);
  ------------------
  |  |  709|  2.10M|#define R_XDR_INTEGER_SIZE 4
  ------------------
  416|  2.10M|	return R_XDRDecodeInteger(buf);
  417|      0|    default:
  ------------------
  |  Branch (417:5): [True: 0, False: 2.10M]
  ------------------
  418|      0|	return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  419|  2.10M|    }
  420|  2.10M|}
serialize.c:InString:
  506|   139k|{
  507|   139k|    if (stream->type == R_pstream_ascii_format) {
  ------------------
  |  Branch (507:9): [True: 0, False: 139k]
  ------------------
  508|      0|	if (length > 0) {
  ------------------
  |  Branch (508:6): [True: 0, False: 0]
  ------------------
  509|      0|	    int c, d, i, j;
  510|      0|	    struct R_instring_stream_st iss;
  511|       |
  512|      0|	    InitInStringStream(&iss, stream);
  513|      0|	    while(isspace(c = GetChar(&iss)))
  ------------------
  |  Branch (513:12): [True: 0, False: 0]
  ------------------
  514|      0|		;
  515|      0|	    UngetChar(&iss, c);
  516|      0|	    for (i = 0; i < length; i++) {
  ------------------
  |  Branch (516:18): [True: 0, False: 0]
  ------------------
  517|       |		/* fgetc() and text connections return EOF without an
  518|       |		   error: stop here rather than fill the rest of the
  519|       |		   string with EOF bytes */
  520|      0|		if ((c = GetChar(&iss)) == EOF)
  ------------------
  |  Branch (520:7): [True: 0, False: 0]
  ------------------
  521|      0|		    error(_("read error"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("read error"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  522|      0|		if (c == '\\') {
  ------------------
  |  Branch (522:7): [True: 0, False: 0]
  ------------------
  523|      0|		    if ((c = GetChar(&iss)) == EOF)
  ------------------
  |  Branch (523:11): [True: 0, False: 0]
  ------------------
  524|      0|			error(_("read error"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              			error(_("read error"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  525|      0|		    switch(c) {
  526|      0|		    case 'n' : buf[i] = '\n'; break;
  ------------------
  |  Branch (526:7): [True: 0, False: 0]
  ------------------
  527|      0|		    case 't' : buf[i] = '\t'; break;
  ------------------
  |  Branch (527:7): [True: 0, False: 0]
  ------------------
  528|      0|		    case 'v' : buf[i] = '\v'; break;
  ------------------
  |  Branch (528:7): [True: 0, False: 0]
  ------------------
  529|      0|		    case 'b' : buf[i] = '\b'; break;
  ------------------
  |  Branch (529:7): [True: 0, False: 0]
  ------------------
  530|      0|		    case 'r' : buf[i] = '\r'; break;
  ------------------
  |  Branch (530:7): [True: 0, False: 0]
  ------------------
  531|      0|		    case 'f' : buf[i] = '\f'; break;
  ------------------
  |  Branch (531:7): [True: 0, False: 0]
  ------------------
  532|      0|		    case 'a' : buf[i] = '\a'; break;
  ------------------
  |  Branch (532:7): [True: 0, False: 0]
  ------------------
  533|      0|		    case '\\': buf[i] = '\\'; break;
  ------------------
  |  Branch (533:7): [True: 0, False: 0]
  ------------------
  534|      0|		    case '?' : buf[i] = '\?'; break;
  ------------------
  |  Branch (534:7): [True: 0, False: 0]
  ------------------
  535|      0|		    case '\'': buf[i] = '\''; break;
  ------------------
  |  Branch (535:7): [True: 0, False: 0]
  ------------------
  536|      0|		    case '\"': buf[i] = '\"'; break; /* closing " for emacs */
  ------------------
  |  Branch (536:7): [True: 0, False: 0]
  ------------------
  537|      0|		    case '0': case '1': case '2': case '3':
  ------------------
  |  Branch (537:7): [True: 0, False: 0]
  |  Branch (537:17): [True: 0, False: 0]
  |  Branch (537:27): [True: 0, False: 0]
  |  Branch (537:37): [True: 0, False: 0]
  ------------------
  538|      0|		    case '4': case '5': case '6': case '7':
  ------------------
  |  Branch (538:7): [True: 0, False: 0]
  |  Branch (538:17): [True: 0, False: 0]
  |  Branch (538:27): [True: 0, False: 0]
  |  Branch (538:37): [True: 0, False: 0]
  ------------------
  539|      0|			d = 0; j = 0;
  540|      0|			while('0' <= c && c < '8' && j < 3) {
  ------------------
  |  Branch (540:10): [True: 0, False: 0]
  |  Branch (540:22): [True: 0, False: 0]
  |  Branch (540:33): [True: 0, False: 0]
  ------------------
  541|      0|			    d = d * 8 + (c - '0');
  542|      0|			    c = GetChar(&iss);
  543|      0|			    j++;
  544|      0|			}
  545|      0|			buf[i] = (char) d;
  546|      0|			UngetChar(&iss, c);
  547|      0|			break;
  548|      0|		    default  : buf[i] = (char) c;
  ------------------
  |  Branch (548:7): [True: 0, False: 0]
  ------------------
  549|      0|		    }
  550|      0|		}
  551|      0|		else buf[i] = (char) c;
  552|      0|	    }
  553|      0|	}
  554|      0|    }
  555|   139k|    else  /* this limits the string length: used for CHARSXPs */
  556|   139k|	stream->InBytes(stream, buf, length);
  557|   139k|}
serialize.c:MakeReadRefTable:
 1479|  1.59k|{
 1480|  1.59k|    SEXP data = allocVector(VECSXP, INITIAL_REFREAD_TABLE_SIZE);
  ------------------
  |  |  875|  1.59k|#define allocVector		Rf_allocVector
  ------------------
                  SEXP data = allocVector(VECSXP, INITIAL_REFREAD_TABLE_SIZE);
  ------------------
  |  |  131|  1.59k|#define VECSXP	    19	  /* generic vectors */
  ------------------
                  SEXP data = allocVector(VECSXP, INITIAL_REFREAD_TABLE_SIZE);
  ------------------
  |  | 1476|  1.59k|#define INITIAL_REFREAD_TABLE_SIZE 128
  ------------------
 1481|  1.59k|    SET_TRUELENGTH(data, 0);
 1482|  1.59k|    return CONS(data, R_NilValue);
  ------------------
  |  |  309|  1.59k|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 1483|  1.59k|}
serialize.c:CloseInStreamConverters:
 2328|  1.59k|{
 2329|  1.59k|    R_inpstream_t stream = data;
 2330|  1.59k|    if (stream->nat2nat_obj && stream->nat2nat_obj != (void *)-1) {
  ------------------
  |  Branch (2330:9): [True: 0, False: 1.59k]
  |  Branch (2330:32): [True: 0, False: 0]
  ------------------
 2331|      0|	Riconv_close(stream->nat2nat_obj);
 2332|      0|	stream->nat2nat_obj = NULL;
 2333|      0|    }
 2334|  1.59k|    if (stream->nat2utf8_obj && stream->nat2utf8_obj != (void *)-1) {
  ------------------
  |  Branch (2334:9): [True: 0, False: 1.59k]
  |  Branch (2334:33): [True: 0, False: 0]
  ------------------
 2335|      0|	Riconv_close(stream->nat2utf8_obj);
 2336|       |	stream->nat2utf8_obj = NULL;
 2337|      0|    }
 2338|  1.59k|}
serialize.c:ReadItem:
 2157|   924k|{
 2158|   924k|    int flags = InInteger(stream);
 2159|   924k|    return ReadItem_Recursive(flags, ref_table, stream);
 2160|   924k|}
serialize.c:ReadItem_Recursive:
 1900|   985k|{
 1901|   985k|    SEXPTYPE type;
 1902|   985k|    SEXP s;
 1903|   985k|    R_xlen_t len, count;
 1904|   985k|    int levs, objf, hasattr, hastag, length;
 1905|       |
 1906|   985k|    R_assert(TYPEOF(ref_table) == LISTSXP && TYPEOF(CAR(ref_table)) == VECSXP);
  ------------------
  |  |  217|  1.97M|#define R_assert(e) ((e) ? (void) 0 : error("assertion '%s' failed: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (217:23): [True: 985k, False: 0]
  |  |  |  Branch (217:23): [True: 985k, False: 0]
  |  |  ------------------
  ------------------
 1907|       |
 1908|       |    /* Each level of nesting in the stream recurses here, so a stream
 1909|       |       nesting lists tens of thousands deep would otherwise overflow the
 1910|       |       C stack before anything else notices. */
 1911|   985k|    R_CheckStack();
 1912|       |
 1913|   985k|    UnpackFlags(flags, &type, &levs, &objf, &hasattr, &hastag);
 1914|       |
 1915|   985k|    switch(type) {
 1916|   327k|    case NILVALUE_SXP:      return R_NilValue;
  ------------------
  |  |  689|   327k|#define NILVALUE_SXP      254
  ------------------
  |  Branch (1916:5): [True: 327k, False: 657k]
  ------------------
 1917|     19|    case EMPTYENV_SXP:	    return R_EmptyEnv;
  ------------------
  |  |  702|     19|#define EMPTYENV_SXP	  242
  ------------------
  |  Branch (1917:5): [True: 19, False: 985k]
  ------------------
 1918|     44|    case BASEENV_SXP:	    return R_BaseEnv;
  ------------------
  |  |  703|     44|#define BASEENV_SXP	  241
  ------------------
  |  Branch (1918:5): [True: 44, False: 985k]
  ------------------
 1919|    156|    case GLOBALENV_SXP:     return R_GlobalEnv;
  ------------------
  |  |  690|    156|#define GLOBALENV_SXP     253
  ------------------
  |  Branch (1919:5): [True: 156, False: 985k]
  ------------------
 1920|      8|    case UNBOUNDVALUE_SXP:  return R_UnboundValue;
  ------------------
  |  |  691|      8|#define UNBOUNDVALUE_SXP  252
  ------------------
  |  Branch (1920:5): [True: 8, False: 985k]
  ------------------
 1921|  12.0k|    case MISSINGARG_SXP:    return R_MissingArg;
  ------------------
  |  |  692|  12.0k|#define MISSINGARG_SXP    251
  ------------------
  |  Branch (1921:5): [True: 12.0k, False: 973k]
  ------------------
 1922|    825|    case BASENAMESPACE_SXP:
  ------------------
  |  |  693|    825|#define BASENAMESPACE_SXP 250
  ------------------
  |  Branch (1922:5): [True: 825, False: 984k]
  ------------------
 1923|    825|	return R_BaseNamespace;
 1924|   254k|    case REFSXP:
  ------------------
  |  |  688|   254k|#define REFSXP            255
  ------------------
  |  Branch (1924:5): [True: 254k, False: 730k]
  ------------------
 1925|   254k|	return GetReadRef(ref_table, InRefIndex(stream, flags));
 1926|  1.36k|    case PERSISTSXP:
  ------------------
  |  |  696|  1.36k|#define PERSISTSXP        247
  ------------------
  |  Branch (1926:5): [True: 1.36k, False: 984k]
  ------------------
 1927|  1.36k|	PROTECT(s = InStringVec(stream, ref_table));
  ------------------
  |  |  357|  1.36k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1928|  1.36k|	s = PersistentRestore(stream, s);
 1929|  1.36k|	UNPROTECT(1);
  ------------------
  |  |  358|  1.36k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1930|  1.36k|	AddReadRef(ref_table, s);
 1931|  1.36k|	return s;
 1932|      8|    case ALTREP_SXP:
  ------------------
  |  |  718|      8|#define ALTREP_SXP	  238
  ------------------
  |  Branch (1932:5): [True: 8, False: 985k]
  ------------------
 1933|      8|	{
 1934|      8|	    R_ReadItemDepth++;
 1935|      8|	    SEXP info = PROTECT(ReadItem(ref_table, stream));
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1936|      8|	    SEXP state = PROTECT(ReadItem(ref_table, stream));
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1937|      8|	    SEXP attr = PROTECT(ReadItem(ref_table, stream));
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1938|      8|	    s = ALTREP_UNSERIALIZE_EX(info, state, attr, objf, levs);
 1939|      8|	    UNPROTECT(3); /* info, state, attr */
  ------------------
  |  |  358|      8|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1940|      8|	    R_ReadItemDepth--;
 1941|      8|	    return s;
 1942|      0|	}
 1943|  21.6k|    case SYMSXP:
  ------------------
  |  |  112|  21.6k|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1943:5): [True: 21.6k, False: 963k]
  ------------------
 1944|  21.6k|	R_ReadItemDepth++;
 1945|  21.6k|	PROTECT(s = ReadItem(ref_table, stream)); /* print name */
  ------------------
  |  |  357|  21.6k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1946|  21.6k|	R_ReadItemDepth--;
 1947|  21.6k|	s = installTrChar(s);
  ------------------
  |  |  937|  21.6k|#define installTrChar		Rf_installTrChar
  ------------------
 1948|  21.6k|	AddReadRef(ref_table, s);
 1949|  21.6k|	UNPROTECT(1);
  ------------------
  |  |  358|  21.6k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1950|  21.6k|	return s;
 1951|      0|    case PACKAGESXP:
  ------------------
  |  |  695|      0|#define PACKAGESXP        248
  ------------------
  |  Branch (1951:5): [True: 0, False: 985k]
  ------------------
 1952|      0|	PROTECT(s = InStringVec(stream, ref_table));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1953|      0|	s = R_FindPackageEnv(s);
 1954|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1955|      0|	AddReadRef(ref_table, s);
 1956|      0|	return s;
 1957|    680|    case NAMESPACESXP:
  ------------------
  |  |  694|    680|#define NAMESPACESXP      249
  ------------------
  |  Branch (1957:5): [True: 680, False: 985k]
  ------------------
 1958|    680|	PROTECT(s = InStringVec(stream, ref_table));
  ------------------
  |  |  357|    680|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1959|    680|	s = R_FindNamespace1(s);
 1960|    680|	AddReadRef(ref_table, s);
 1961|    680|	UNPROTECT(1);
  ------------------
  |  |  358|    680|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1962|    680|	return s;
 1963|      0|    case ENVSXP:
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (1963:5): [True: 0, False: 985k]
  ------------------
 1964|      0|	{
 1965|      0|	    int locked = InInteger(stream);
 1966|       |
 1967|      0|	    PROTECT(s = allocSExp(ENVSXP));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1968|       |
 1969|       |	    /* MUST register before filling in */
 1970|      0|	    AddReadRef(ref_table, s);
 1971|       |
 1972|       |	    /* Now fill it in  */
 1973|      0|	    R_ReadItemDepth++;
 1974|      0|	    SET_ENCLOS(s, ReadItem(ref_table, stream));
 1975|      0|	    SET_FRAME(s, ReadItem(ref_table, stream));
 1976|      0|	    SET_HASHTAB(s, ReadItem(ref_table, stream));
 1977|      0|	    SET_ATTRIB(s, ReadItem(ref_table, stream));
 1978|      0|	    R_ReadItemDepth--;
 1979|      0|	    if (ATTRIB(s) != R_NilValue &&
  ------------------
  |  Branch (1979:10): [True: 0, False: 0]
  ------------------
 1980|      0|		getAttrib(s, R_ClassSymbol) != R_NilValue)
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (1980:3): [True: 0, False: 0]
  ------------------
 1981|       |		/* We don't write out the object bit for environments,
 1982|       |		   so reconstruct it here if needed. */
 1983|      0|		SET_OBJECT(s, 1);
 1984|      0|	    R_RestoreHashCount(s);
 1985|      0|	    if (locked) R_LockEnvironment(s, FALSE);
  ------------------
  |  Branch (1985:10): [True: 0, False: 0]
  ------------------
 1986|       |	    /* Convert a NULL enclosure to baseenv() */
 1987|      0|	    if (ENCLOS(s) == R_NilValue) SET_ENCLOS(s, R_BaseEnv);
  ------------------
  |  Branch (1987:10): [True: 0, False: 0]
  ------------------
 1988|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1989|      0|	    return s;
 1990|      0|	}
 1991|  48.0k|    case LISTSXP:
  ------------------
  |  |  113|  48.0k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (1991:5): [True: 48.0k, False: 937k]
  ------------------
 1992|  54.5k|    case LANGSXP:
  ------------------
  |  |  117|  54.5k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (1992:5): [True: 6.40k, False: 979k]
  ------------------
 1993|  61.0k|    case CLOSXP:
  ------------------
  |  |  114|  61.0k|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1993:5): [True: 6.51k, False: 979k]
  ------------------
 1994|  61.0k|    case PROMSXP:
  ------------------
  |  |  116|  61.0k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (1994:5): [True: 82, False: 985k]
  ------------------
 1995|  61.0k|    case DOTSXP:
  ------------------
  |  |  127|  61.0k|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (1995:5): [True: 0, False: 985k]
  ------------------
 1996|  61.0k|	return ReadItem_Iterative(flags, ref_table, stream);
 1997|   305k|    default:
  ------------------
  |  Branch (1997:5): [True: 305k, False: 680k]
  ------------------
 1998|       |	/* These break out of the switch to have their ATTR,
 1999|       |	   LEVELS, and OBJECT fields filled in.  Each leaves the
 2000|       |	   newly allocated value PROTECTed */
 2001|   305k|	switch (type) {
 2002|    352|	case EXTPTRSXP:
  ------------------
  |  |  134|    352|#define EXTPTRSXP   22    /* external pointer */
  ------------------
  |  Branch (2002:2): [True: 352, False: 304k]
  ------------------
 2003|    352|	    PROTECT(s = allocSExp(type));
  ------------------
  |  |  357|    352|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2004|    352|	    AddReadRef(ref_table, s);
 2005|    352|	    R_SetExternalPtrAddr(s, NULL);
 2006|    352|	    R_ReadItemDepth++;
 2007|    352|	    R_SetExternalPtrProtected(s, ReadItem(ref_table, stream));
 2008|    352|	    R_SetExternalPtrTag(s, ReadItem(ref_table, stream));
 2009|    352|	    R_ReadItemDepth--;
 2010|    352|	    break;
 2011|      0|	case WEAKREFSXP:
  ------------------
  |  |  135|      0|#define WEAKREFSXP  23    /* weak reference */
  ------------------
  |  Branch (2011:2): [True: 0, False: 305k]
  ------------------
 2012|      0|	    PROTECT(s = R_MakeWeakRef(R_NilValue, R_NilValue, R_NilValue,
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2013|      0|				      FALSE));
 2014|      0|	    AddReadRef(ref_table, s);
 2015|      0|	    break;
 2016|    116|	case SPECIALSXP:
  ------------------
  |  |  118|    116|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (2016:2): [True: 116, False: 305k]
  ------------------
 2017|    816|	case BUILTINSXP:
  ------------------
  |  |  119|    816|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (2017:2): [True: 700, False: 304k]
  ------------------
 2018|    816|	    {
 2019|       |		/* These are all short strings */
 2020|    816|		length = InInteger(stream);
 2021|       |		/* Primitive names come from R_FunTab.  An implausible
 2022|       |		   length from the stream must not become a large
 2023|       |		   stack allocation. */
 2024|    816|		if (length < 0 || length > 255)
  ------------------
  |  Branch (2024:7): [True: 0, False: 816]
  |  Branch (2024:21): [True: 0, False: 816]
  ------------------
 2025|      0|		    error(_("invalid length"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("invalid length"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2026|    816|		R_CheckStack2(length+1);
 2027|    816|		char cbuf[length+1];
 2028|    816|		InString(stream, cbuf, length);
 2029|    816|		cbuf[length] = '\0';
 2030|    816|		int index = StrToInternal(cbuf);
  ------------------
  |  | 1994|    816|# define StrToInternal		Rf_StrToInternal
  ------------------
 2031|    816|		if (index == NA_INTEGER) {
  ------------------
  |  |   56|    816|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (2031:7): [True: 0, False: 816]
  ------------------
 2032|      0|		    warning(_("unrecognized internal function name \"%s\""), cbuf);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		    warning(_("unrecognized internal function name \"%s\""), cbuf);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2033|      0|		    PROTECT(s = R_NilValue);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2034|      0|		} else
 2035|    816|		    PROTECT(s = mkPRIMSXP(index, type == BUILTINSXP));
  ------------------
  |  |  357|    816|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2036|    816|	    }
 2037|    816|	    break;
 2038|   140k|	case CHARSXP:
  ------------------
  |  |  120|   140k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (2038:2): [True: 140k, False: 164k]
  ------------------
 2039|       |	    /* these are currently limited to 2^31 -1 bytes */
 2040|   140k|	    length = InInteger(stream);
 2041|   140k|	    if (length < -1)
  ------------------
  |  Branch (2041:10): [True: 0, False: 140k]
  ------------------
 2042|      0|		error(_("invalid length"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("invalid length"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2043|   140k|	    else if (length == -1)
  ------------------
  |  Branch (2043:15): [True: 2.68k, False: 137k]
  ------------------
 2044|  2.68k|		PROTECT(s = NA_STRING);
  ------------------
  |  |  357|  2.68k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2045|   137k|	    else if (length < 1000) {
  ------------------
  |  Branch (2045:15): [True: 137k, False: 0]
  ------------------
 2046|   137k|		char cbuf[length+1];
 2047|   137k|		PROTECT(s = ReadChar(stream, cbuf, length, levs));
  ------------------
  |  |  357|   137k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2048|   137k|	    } else {
 2049|       |		/* R_alloc, not Calloc: ReadChar can signal errors (truncated
 2050|       |		   stream, embedded nul), which would leak a Calloc'd buffer */
 2051|      0|		const void *vmax = vmaxget();
 2052|      0|		char *cbuf = R_alloc((size_t)length + 1, sizeof(char));
 2053|      0|		PROTECT(s = ReadChar(stream, cbuf, length, levs));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2054|      0|		vmaxset(vmax);
 2055|      0|	    }
 2056|   140k|	    break;
 2057|  13.3k|	case LGLSXP:
  ------------------
  |  |  121|  13.3k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (2057:2): [True: 13.3k, False: 291k]
  ------------------
 2058|  69.5k|	case INTSXP:
  ------------------
  |  |  123|  69.5k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (2058:2): [True: 56.1k, False: 248k]
  ------------------
 2059|  69.5k|	    len = ReadLENGTH(stream);
 2060|  69.5k|	    PROTECT(s = allocVector(type, len));
  ------------------
  |  |  357|  69.5k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2061|  69.5k|	    InIntegerVec(stream, s, len);
 2062|  69.5k|	    break;
 2063|  3.38k|	case REALSXP:
  ------------------
  |  |  124|  3.38k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (2063:2): [True: 3.38k, False: 301k]
  ------------------
 2064|  3.38k|	    len = ReadLENGTH(stream);
 2065|  3.38k|	    PROTECT(s = allocVector(type, len));
  ------------------
  |  |  357|  3.38k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2066|  3.38k|	    InRealVec(stream, s, len);
 2067|  3.38k|	    break;
 2068|      2|	case CPLXSXP:
  ------------------
  |  |  125|      2|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (2068:2): [True: 2, False: 305k]
  ------------------
 2069|      2|	    len = ReadLENGTH(stream);
 2070|      2|	    PROTECT(s = allocVector(type, len));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2071|      2|	    InComplexVec(stream, s, len);
 2072|      2|	    break;
 2073|  79.3k|	case STRSXP:
  ------------------
  |  |  126|  79.3k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (2073:2): [True: 79.3k, False: 225k]
  ------------------
 2074|  79.3k|	    len = ReadLENGTH(stream);
 2075|  79.3k|	    PROTECT(s = allocVector(type, len));
  ------------------
  |  |  357|  79.3k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2076|  79.3k|	    R_ReadItemDepth++;
 2077|   195k|	    for (count = 0; count < len; ++count)
  ------------------
  |  Branch (2077:22): [True: 115k, False: 79.3k]
  ------------------
 2078|   115k|		SET_STRING_ELT(s, count, ReadItem(ref_table, stream));
 2079|  79.3k|	    R_ReadItemDepth--;
 2080|  79.3k|	    break;
 2081|  4.03k|	case VECSXP:
  ------------------
  |  |  131|  4.03k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (2081:2): [True: 4.03k, False: 301k]
  ------------------
 2082|  4.03k|	case EXPRSXP:
  ------------------
  |  |  132|  4.03k|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (2082:2): [True: 2, False: 305k]
  ------------------
 2083|  4.03k|	    len = ReadLENGTH(stream);
 2084|  4.03k|	    PROTECT(s = allocVector(type, len));
  ------------------
  |  |  357|  4.03k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2085|  4.03k|	    R_ReadItemDepth++;
 2086|  24.6k|	    for (count = 0; count < len; ++count) {
  ------------------
  |  Branch (2086:22): [True: 20.6k, False: 4.03k]
  ------------------
 2087|  20.6k|		if (R_ReadItemDepth <= 0)
  ------------------
  |  Branch (2087:7): [True: 0, False: 20.6k]
  ------------------
 2088|      0|		    Rprintf("%*s[%lld]\n", 2*(R_ReadItemDepth - R_InitReadItemDepth),
 2089|      0|		            "", (long long)count+1);
 2090|  20.6k|		SET_VECTOR_ELT(s, count, ReadItem(ref_table, stream));
 2091|  20.6k|	    }
 2092|  4.03k|	    R_ReadItemDepth--;
 2093|  4.03k|	    break;
 2094|  5.66k|	case BCODESXP:
  ------------------
  |  |  133|  5.66k|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (2094:2): [True: 5.66k, False: 299k]
  ------------------
 2095|  5.66k|	    PROTECT(s = ReadBC(ref_table, stream));
  ------------------
  |  |  357|  5.66k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2096|  5.66k|	    break;
 2097|      0|	case CLASSREFSXP:
  ------------------
  |  |  698|      0|#define CLASSREFSXP       246
  ------------------
  |  Branch (2097:2): [True: 0, False: 305k]
  ------------------
 2098|      0|	    error(_("this version of R cannot read class references"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("this version of R cannot read class references"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2099|      0|	case GENERICREFSXP:
  ------------------
  |  |  699|      0|#define GENERICREFSXP     245
  ------------------
  |  Branch (2099:2): [True: 0, False: 305k]
  ------------------
 2100|      0|	    error(_("this version of R cannot read generic function references"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("this version of R cannot read generic function references"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2101|      2|	case RAWSXP:
  ------------------
  |  |  136|      2|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (2101:2): [True: 2, False: 305k]
  ------------------
 2102|      2|	    len = ReadLENGTH(stream);
 2103|      2|	    PROTECT(s = allocVector(type, len));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2104|      2|	    switch (stream->type) {
 2105|      0|	    case R_pstream_ascii_format:
  ------------------
  |  Branch (2105:6): [True: 0, False: 2]
  ------------------
 2106|      0|		for (R_xlen_t ix = 0; ix < len; ix++) {
  ------------------
  |  Branch (2106:25): [True: 0, False: 0]
  ------------------
 2107|      0|		    char word[128];
 2108|      0|		    unsigned int i; // unsigned to avoid compiler warnings
 2109|      0|		    InWord(stream, word, sizeof(word));
 2110|      0|		    if(sscanf(word, "%2x", &i) != 1) error(_("read error"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    if(sscanf(word, "%2x", &i) != 1) error(_("read error"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (2110:10): [True: 0, False: 0]
  ------------------
 2111|      0|		    RAW(s)[ix] = (Rbyte) i;
 2112|      0|		}
 2113|      0|		break;
 2114|      2|	    default:
  ------------------
  |  Branch (2114:6): [True: 2, False: 0]
  ------------------
 2115|      2|	    {
 2116|      2|		R_xlen_t done, this;
 2117|      2|		for (done = 0; done < len; done += this) {
  ------------------
  |  Branch (2117:18): [True: 0, False: 2]
  ------------------
 2118|      0|		    this = min2(CHUNK_SIZE, len - done);
  ------------------
  |  |  915|      0|#define min2(a, b) ((a) < (b)) ? (a) : (b)
  |  |  ------------------
  |  |  |  Branch (915:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2119|      0|		    stream->InBytes(stream, RAW(s) + done, (int) this);
 2120|      0|		}
 2121|      2|	    }
 2122|      2|	    }
 2123|      2|	    break;
 2124|  1.88k|	case OBJSXP:
  ------------------
  |  |  137|  1.88k|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (2124:2): [True: 1.88k, False: 303k]
  ------------------
 2125|  1.88k|	    PROTECT(s = R_allocObject());
  ------------------
  |  |  357|  1.88k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2126|  1.88k|	    break;
 2127|      0|	default:
  ------------------
  |  Branch (2127:2): [True: 0, False: 305k]
  ------------------
 2128|      0|	    s = R_NilValue; /* keep compiler happy */
 2129|      0|	    error(_("ReadItem: unknown type %i, perhaps written by later version of R"), type);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("ReadItem: unknown type %i, perhaps written by later version of R"), type);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2130|   305k|	}
 2131|   305k|	if (type != CHARSXP) SETLEVELS(s, levs);
  ------------------
  |  |  120|   305k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (2131:6): [True: 164k, False: 140k]
  ------------------
 2132|   305k|	SET_OBJECT(s, objf);
 2133|   305k|	if (TYPEOF(s) == CHARSXP) {
  ------------------
  |  |  120|   305k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (2133:6): [True: 140k, False: 164k]
  ------------------
 2134|       |	    /* With the CHARSXP cache maintained through the ATTRIB
 2135|       |	       field that field has already been filled in by the
 2136|       |	       mkChar/mkCharCE call above, so we need to leave it
 2137|       |	       alone.  If there is an attribute (as there might be if
 2138|       |	       the serialized data was created by an older version) we
 2139|       |	       read and ignore the value. */
 2140|   140k|	    R_ReadItemDepth++;
 2141|   140k|	    if (hasattr) ReadItem(ref_table, stream);
  ------------------
  |  Branch (2141:10): [True: 0, False: 140k]
  ------------------
 2142|   140k|	    R_ReadItemDepth--;
 2143|   140k|	}
 2144|   164k|	else {
 2145|   164k|	    R_ReadItemDepth++;
 2146|   164k|	    SET_ATTRIB(s, hasattr ? ReadItem(ref_table, stream) : R_NilValue);
  ------------------
  |  Branch (2146:20): [True: 40.6k, False: 124k]
  ------------------
 2147|   164k|	    R_ReadItemDepth--;
 2148|   164k|	}
 2149|   305k|	UNPROTECT(1); /* s */
  ------------------
  |  |  358|   305k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2150|   305k|	if (TYPEOF(s) == BCODESXP && !R_BCVersionOK(s))
  ------------------
  |  |  133|   610k|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (2150:6): [True: 5.66k, False: 299k]
  |  Branch (2150:31): [True: 0, False: 5.66k]
  ------------------
 2151|      0|	    return R_BytecodeExpr(s);
 2152|   305k|	return s;
 2153|   985k|    }
 2154|   985k|}
serialize.c:UnpackFlags:
  774|  1.09M|{
  775|  1.09M|    *ptype = DECODE_TYPE(flags);
  ------------------
  |  |  735|  1.09M|#define DECODE_TYPE(v) ((v) & 255)
  ------------------
  776|  1.09M|    *plevs = DECODE_LEVELS(flags);
  ------------------
  |  |  734|  1.09M|#define DECODE_LEVELS(v) ((v) >> 12)
  ------------------
  777|  1.09M|    *pisobj = flags & IS_OBJECT_BIT_MASK ? true : FALSE;
  ------------------
  |  |  730|  1.09M|#define IS_OBJECT_BIT_MASK (1 << 8)
  ------------------
  |  Branch (777:15): [True: 147k, False: 944k]
  ------------------
  778|  1.09M|    *phasattr = flags & HAS_ATTR_BIT_MASK ? true : FALSE;
  ------------------
  |  |  731|  1.09M|#define HAS_ATTR_BIT_MASK (1 << 9)
  ------------------
  |  Branch (778:17): [True: 178k, False: 914k]
  ------------------
  779|  1.09M|    *phastag = flags & HAS_TAG_BIT_MASK ? true : FALSE;
  ------------------
  |  |  732|  1.09M|#define HAS_TAG_BIT_MASK (1 << 10)
  ------------------
  |  Branch (779:16): [True: 258k, False: 834k]
  ------------------
  780|  1.09M|}
serialize.c:GetReadRef:
 1486|   254k|{
 1487|   254k|    int i = index - 1;
 1488|   254k|    SEXP data = CAR(table);
 1489|       |
 1490|   254k|    if (i < 0 || i >= LENGTH(data))
  ------------------
  |  Branch (1490:9): [True: 0, False: 254k]
  |  Branch (1490:18): [True: 0, False: 254k]
  ------------------
 1491|      0|	error(_("reference index out of range"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("reference index out of range"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1492|   254k|    return VECTOR_ELT(data, i);
 1493|   254k|}
serialize.c:InRefIndex:
  807|   254k|{
  808|   254k|    int i = UNPACK_REF_INDEX(flags);
  ------------------
  |  |  794|   254k|#define UNPACK_REF_INDEX(i) ((i) >> 8)
  ------------------
  809|   254k|    if (i == 0)
  ------------------
  |  Branch (809:9): [True: 0, False: 254k]
  ------------------
  810|      0|	return InInteger(stream);
  811|   254k|    else
  812|   254k|	return i;
  813|   254k|}
serialize.c:InStringVec:
 1517|  2.04k|{
 1518|  2.04k|    if (InInteger(stream) != 0)
  ------------------
  |  Branch (1518:9): [True: 0, False: 2.04k]
  ------------------
 1519|      0|	error(_("names in persistent strings are not supported yet"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("names in persistent strings are not supported yet"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1520|  2.04k|    int len = InInteger(stream);
 1521|  2.04k|    SEXP s = PROTECT(allocVector(STRSXP, len));
  ------------------
  |  |  357|  2.04k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1522|  2.04k|    R_ReadItemDepth++;
 1523|  4.77k|    for (int i = 0; i < len; i++)
  ------------------
  |  Branch (1523:21): [True: 2.72k, False: 2.04k]
  ------------------
 1524|  2.72k|	SET_STRING_ELT(s, i, ReadItem(ref_table, stream));
 1525|  2.04k|    R_ReadItemDepth--;
 1526|  2.04k|    UNPROTECT(1);
  ------------------
  |  |  358|  2.04k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1527|  2.04k|    return s;
 1528|  2.04k|}
serialize.c:PersistentRestore:
  847|  1.36k|{
  848|  1.36k|    if (stream->InPersistHookFunc == NULL)
  ------------------
  |  Branch (848:9): [True: 0, False: 1.36k]
  ------------------
  849|      0|	error(_("no restore method available"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("no restore method available"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  850|  1.36k|    return stream->InPersistHookFunc(s, stream->InPersistHookData);
  851|  1.36k|}
serialize.c:AddReadRef:
 1496|  24.0k|{
 1497|  24.0k|    SEXP data = CAR(table);
 1498|  24.0k|    R_xlen_t count = TRUELENGTH(data) + 1;
 1499|  24.0k|    if (count >= LENGTH(data)) {
  ------------------
  |  Branch (1499:9): [True: 31, False: 24.0k]
  ------------------
 1500|     31|	R_xlen_t i, len;
 1501|     31|	SEXP newdata;
 1502|       |
 1503|     31|	PROTECT(value);
  ------------------
  |  |  357|     31|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1504|     31|	len = 2 * count;
 1505|     31|	newdata = allocVector(VECSXP, len);
  ------------------
  |  |  875|     31|#define allocVector		Rf_allocVector
  ------------------
              	newdata = allocVector(VECSXP, len);
  ------------------
  |  |  131|     31|#define VECSXP	    19	  /* generic vectors */
  ------------------
 1506|  4.76k|	for (i = 0; i < LENGTH(data); i++)
  ------------------
  |  Branch (1506:14): [True: 4.73k, False: 31]
  ------------------
 1507|  4.73k|	    SET_VECTOR_ELT(newdata, i, VECTOR_ELT(data, i));
 1508|     31|	SETCAR(table, newdata);
 1509|     31|	data = newdata;
 1510|     31|	UNPROTECT(1);
  ------------------
  |  |  358|     31|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1511|     31|    }
 1512|  24.0k|    SET_TRUELENGTH(data, count);
 1513|  24.0k|    SET_VECTOR_ELT(data, count - 1, value);
 1514|  24.0k|}
serialize.c:R_FindNamespace1:
 1814|    680|{
 1815|    680|    SEXP expr, val, where;
 1816|    680|    PROTECT(info);
  ------------------
  |  |  357|    680|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1817|    680|    where = PROTECT(ScalarString(mkChar(lastname)));
  ------------------
  |  |  357|    680|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1818|    680|    SEXP s_getNamespace = install("..getNamespace");
  ------------------
  |  |  934|    680|#define install			Rf_install
  ------------------
 1819|    680|    PROTECT(expr = LCONS(s_getNamespace,
  ------------------
  |  |  357|    680|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1820|    680|			 LCONS(info, LCONS(where, R_NilValue))));
 1821|    680|    val = eval(expr, R_BaseEnv);
  ------------------
  |  |  913|    680|#define eval			Rf_eval
  ------------------
 1822|    680|    UNPROTECT(3);
  ------------------
  |  |  358|    680|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1823|    680|    return val;
 1824|    680|}
serialize.c:ReadItem_Iterative:
 1829|  61.0k|{
 1830|       |    /* Building dotted pair objects with recursion on the CDR will
 1831|       |       overflow the PROTECT stack for long lists. Instead we build
 1832|       |       pairlists in an iterative loop */
 1833|       |    
 1834|  61.0k|    SEXPTYPE type = DECODE_TYPE(flags);
  ------------------
  |  |  735|  61.0k|#define DECODE_TYPE(v) ((v) & 255)
  ------------------
 1835|  61.0k|    SEXP s, sfirst = NULL, slast = NULL;
 1836|       |    
 1837|       |    /* An assertion here guarantees that we go through the loop at
 1838|       |       least once. This make for cleaner exit code and avoids a
 1839|       |       potential infinite loop: ReadItem_Recursive <->
 1840|       |       ReadIterm_iterative */
 1841|  61.0k|    R_assert(type == LISTSXP || type == LANGSXP || type == CLOSXP ||
  ------------------
  |  |  217|   264k|#define R_assert(e) ((e) ? (void) 0 : error("assertion '%s' failed: file '%s', line %d\n", #e, __FILE__, __LINE__))
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |  |  Branch (217:23): [True: 48.0k, False: 12.9k]
  |  |  |  Branch (217:23): [True: 6.40k, False: 6.59k]
  |  |  |  Branch (217:23): [True: 6.51k, False: 82]
  |  |  |  Branch (217:23): [True: 82, False: 0]
  |  |  |  Branch (217:23): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1842|  61.0k|	     type == PROMSXP || type == DOTSXP);
 1843|       |    
 1844|   167k|    while (type == LISTSXP || type == LANGSXP || type == CLOSXP ||
  ------------------
  |  |  113|   335k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
                  while (type == LISTSXP || type == LANGSXP || type == CLOSXP ||
  ------------------
  |  |  117|   242k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
                  while (type == LISTSXP || type == LANGSXP || type == CLOSXP ||
  ------------------
  |  |  114|   235k|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1844:12): [True: 92.6k, False: 74.9k]
  |  Branch (1844:31): [True: 7.24k, False: 67.6k]
  |  Branch (1844:50): [True: 6.51k, False: 61.1k]
  ------------------
 1845|   106k|	   type == PROMSXP || type == DOTSXP) {
  ------------------
  |  |  116|   228k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
              	   type == PROMSXP || type == DOTSXP) {
  ------------------
  |  |  127|  61.0k|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (1845:5): [True: 90, False: 61.0k]
  |  Branch (1845:24): [True: 0, False: 61.0k]
  ------------------
 1846|   106k|	int levs, objf, hasattr, hastag;
 1847|   106k|	UnpackFlags(flags, &type, &levs, &objf, &hasattr, &hastag);
 1848|       |
 1849|   106k|	PROTECT(s = allocSExp(type));
  ------------------
  |  |  357|   106k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1850|   106k|	SETLEVELS(s, levs);
 1851|   106k|	SET_OBJECT(s, objf);
 1852|   106k|	R_ReadItemDepth++;
 1853|   106k|	bool set_lastname = false;
 1854|   106k|	SET_ATTRIB(s, hasattr ? ReadItem(ref_table, stream) : R_NilValue);
  ------------------
  |  Branch (1854:16): [True: 818, False: 105k]
  ------------------
 1855|   106k|	SET_TAG(s, hastag ? ReadItem(ref_table, stream) : R_NilValue);
  ------------------
  |  Branch (1855:13): [True: 85.8k, False: 20.6k]
  ------------------
 1856|   106k|	if (hastag && R_ReadItemDepth == R_InitReadItemDepth + 1 &&
  ------------------
  |  Branch (1856:6): [True: 85.8k, False: 20.6k]
  |  Branch (1856:16): [True: 872, False: 84.9k]
  ------------------
 1857|    872|	    isSymbol(TAG(s))) {
  ------------------
  |  |  953|    872|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1857:6): [True: 0, False: 872]
  ------------------
 1858|      0|	    snprintf(lastname, 8192, "%s", CHAR(PRINTNAME(TAG(s))));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1859|      0|	    set_lastname = TRUE;
 1860|      0|	}
 1861|   106k|	if (hastag && R_ReadItemDepth <= 0) {
  ------------------
  |  Branch (1861:6): [True: 85.8k, False: 20.6k]
  |  Branch (1861:16): [True: 0, False: 85.8k]
  ------------------
 1862|      0|	    Rprintf("%*s", 2*(R_ReadItemDepth - R_InitReadItemDepth), "");
 1863|      0|	    PrintValue(TAG(s));
  ------------------
  |  | 1013|      0|#define PrintValue		Rf_PrintValue
  ------------------
 1864|      0|	}
 1865|   106k|	SETCAR(s, ReadItem(ref_table, stream));
 1866|   106k|	R_ReadItemDepth--;
 1867|   106k|	R_CheckStack();
 1868|       |
 1869|   106k|	if (sfirst == NULL) {
  ------------------
  |  Branch (1869:6): [True: 61.0k, False: 45.3k]
  ------------------
 1870|  61.0k|	    sfirst = s; /* First iteration: start list */
 1871|  61.0k|	}
 1872|  45.3k|	else {
 1873|  45.3k|	    SETCDR(slast, s); /* Subsequent iterations: extend list */
 1874|  45.3k|	    UNPROTECT(1); /* s, which is now protected as part of sfirst */
  ------------------
  |  |  358|  45.3k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1875|  45.3k|	}
 1876|   106k|	slast = s;
 1877|       |
 1878|       |	/* For reading closures and promises stored in earlier
 1879|       |	   versions, convert NULL env to baseenv() */
 1880|   106k|	if (type == CLOSXP && CLOENV(s) == R_NilValue)
  ------------------
  |  |  114|   212k|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1880:6): [True: 6.51k, False: 99.9k]
  |  Branch (1880:24): [True: 0, False: 6.51k]
  ------------------
 1881|      0|	    SET_CLOENV(s, R_BaseEnv);
 1882|   106k|	else if (type == PROMSXP && PRENV(s) == R_NilValue)
  ------------------
  |  |  116|   212k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (1882:11): [True: 90, False: 106k]
  |  Branch (1882:30): [True: 82, False: 8]
  ------------------
 1883|     82|	    SET_PRENV(s, R_BaseEnv);
 1884|   106k|	if (set_lastname) strcpy(lastname, "<unknown>");
  ------------------
  |  Branch (1884:6): [True: 0, False: 106k]
  ------------------
 1885|       |
 1886|   106k|	flags = InInteger(stream);
 1887|   106k|	type = DECODE_TYPE(flags);
  ------------------
  |  |  735|   106k|#define DECODE_TYPE(v) ((v) & 255)
  ------------------
 1888|   106k|    }
 1889|       |
 1890|  61.0k|    R_ReadItemDepth++;
 1891|  61.0k|    PROTECT(s = ReadItem_Recursive(flags, ref_table, stream));
  ------------------
  |  |  357|  61.0k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1892|  61.0k|    R_ReadItemDepth--;
 1893|  61.0k|    SETCDR(slast, s);
 1894|  61.0k|    UNPROTECT(2); /* s, sfirst */
  ------------------
  |  |  358|  61.0k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1895|  61.0k|    return sfirst;
 1896|  61.0k|}
serialize.c:ReadChar:
 1719|   137k|{
 1720|   137k|    InString(stream, buf, length);
 1721|   137k|    buf[length] = '\0';
 1722|   137k|    if (levs & UTF8_MASK)
  ------------------
  |  |  935|   137k|#define UTF8_MASK (1<<3)
  ------------------
  |  Branch (1722:9): [True: 0, False: 137k]
  ------------------
 1723|      0|	return mkCharLenCE(buf, length, CE_UTF8);
  ------------------
  |  | 1001|      0|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
 1724|   137k|    if (levs & LATIN1_MASK)
  ------------------
  |  |  934|   137k|#define LATIN1_MASK (1<<2)
  ------------------
  |  Branch (1724:9): [True: 0, False: 137k]
  ------------------
 1725|      0|	return mkCharLenCE(buf, length, CE_LATIN1);
  ------------------
  |  | 1001|      0|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
 1726|   137k|    if (levs & BYTES_MASK)
  ------------------
  |  |  933|   137k|#define BYTES_MASK (1<<1)
  ------------------
  |  Branch (1726:9): [True: 0, False: 137k]
  ------------------
 1727|      0|	return mkCharLenCE(buf, length, CE_BYTES);
  ------------------
  |  | 1001|      0|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
 1728|   137k|    if (levs & ASCII_MASK)
  ------------------
  |  |  939|   137k|#define ASCII_MASK (1<<6)
  ------------------
  |  Branch (1728:9): [True: 137k, False: 0]
  ------------------
 1729|   137k|	return mkCharLenCE(buf, length, CE_NATIVE);
  ------------------
  |  | 1001|   137k|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
 1730|       |
 1731|       |    /* native encoding, not ascii */
 1732|      0|    if (!stream->native_encoding[0] || /* original native encoding unknown */
  ------------------
  |  Branch (1732:9): [True: 0, False: 0]
  ------------------
 1733|      0|        (stream->nat2nat_obj == (void *)-1 && /* translation impossible or disabled */
  ------------------
  |  Branch (1733:10): [True: 0, False: 0]
  ------------------
 1734|      0|         stream->nat2utf8_obj == (void *)-1))
  ------------------
  |  Branch (1734:10): [True: 0, False: 0]
  ------------------
 1735|      0|	return mkCharLenCE(buf, length, CE_NATIVE);
  ------------------
  |  | 1001|      0|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
 1736|       |    /* try converting to native encoding */
 1737|      0|    if (!stream->nat2nat_obj &&
  ------------------
  |  Branch (1737:9): [True: 0, False: 0]
  ------------------
 1738|      0|        !strcmp(stream->native_encoding, R_nativeEncoding())) {
  ------------------
  |  Branch (1738:9): [True: 0, False: 0]
  ------------------
 1739|       |	/* No translation needed. Performance optimization but also leaves
 1740|       |	   invalid strings in their encoding undetected. */
 1741|      0|	stream->nat2nat_obj = (void *)-1;
 1742|      0|	stream->nat2utf8_obj = (void *)-1;
 1743|       |#ifdef WARN_DESERIALIZE_INVALID_UTF8
 1744|       |	if (known_to_be_utf8 && !utf8Valid(buf))
 1745|       |	    warning(_("deserializing invalid UTF-8 string '%s'"), buf);
 1746|       |#endif
 1747|      0|    }
 1748|      0|    if (!stream->nat2nat_obj) {
  ------------------
  |  Branch (1748:9): [True: 0, False: 0]
  ------------------
 1749|      0|	char *from = native_fromcode(stream);
 1750|      0|	stream->nat2nat_obj = Riconv_open("", from);
 1751|      0|	if (stream->nat2nat_obj == (void *)-1)
  ------------------
  |  Branch (1751:6): [True: 0, False: 0]
  ------------------
 1752|      0|	    warning(_("unsupported conversion from '%s' to '%s'"), from, "");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("unsupported conversion from '%s' to '%s'"), from, "");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1753|      0|    }
 1754|      0|    if (stream->nat2nat_obj != (void *)-1) {
  ------------------
  |  Branch (1754:9): [True: 0, False: 0]
  ------------------
 1755|      0|	cetype_t enc = CE_NATIVE;
 1756|      0|	if (known_to_be_utf8) enc = CE_UTF8;
  ------------------
  |  Branch (1756:6): [True: 0, False: 0]
  ------------------
 1757|      0|	else if (known_to_be_latin1) enc = CE_LATIN1;
  ------------------
  |  Branch (1757:11): [True: 0, False: 0]
  ------------------
 1758|      0|	SEXP ans = ConvertChar(stream->nat2nat_obj, buf, length, enc);
 1759|      0|	if (ans != R_NilValue)
  ------------------
  |  Branch (1759:6): [True: 0, False: 0]
  ------------------
 1760|      0|	    return ans;
 1761|      0|	if (known_to_be_utf8) {
  ------------------
  |  Branch (1761:6): [True: 0, False: 0]
  ------------------
 1762|       |	    /* nat2nat_obj is converting to UTF-8, no need to use nat2utf8_obj */
 1763|      0|	    stream->nat2utf8_obj = (void *)-1;
 1764|      0|	    invalid_utf8_warning(buf, length, native_fromcode(stream));
 1765|      0|	}
 1766|      0|    }
 1767|       |    /* try converting to UTF-8 */
 1768|      0|    if (!stream->nat2utf8_obj) {
  ------------------
  |  Branch (1768:9): [True: 0, False: 0]
  ------------------
 1769|      0|	char *from = native_fromcode(stream);
 1770|      0|	stream->nat2utf8_obj = Riconv_open("UTF-8", from);
 1771|      0|	if (stream->nat2utf8_obj == (void *)-1) {
  ------------------
  |  Branch (1771:6): [True: 0, False: 0]
  ------------------
 1772|       |	    /* very unlikely */
 1773|      0|	    warning(_("unsupported conversion from '%s' to '%s'"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("unsupported conversion from '%s' to '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1774|      0|	            from, "UTF-8");
 1775|      0|	    warning(_("strings not representable in native encoding will not be translated"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("strings not representable in native encoding will not be translated"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1776|      0|	} else
 1777|      0|	    warning(_("strings not representable in native encoding will be translated to UTF-8"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("strings not representable in native encoding will be translated to UTF-8"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1778|      0|    }
 1779|      0|    if (stream->nat2utf8_obj != (void *)-1) {
  ------------------
  |  Branch (1779:9): [True: 0, False: 0]
  ------------------
 1780|      0|	SEXP ans = ConvertChar(stream->nat2utf8_obj, buf, length, CE_UTF8);
 1781|      0|	if (ans != R_NilValue)
  ------------------
  |  Branch (1781:6): [True: 0, False: 0]
  ------------------
 1782|      0|	    return ans;
 1783|      0|	invalid_utf8_warning(buf, length, native_fromcode(stream));
 1784|      0|    }
 1785|       |    /* no translation possible */
 1786|      0|    return mkCharLenCE(buf, length, CE_NATIVE);
  ------------------
  |  | 1001|      0|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
 1787|      0|}
serialize.c:ReadLENGTH:
 1790|   156k|{
 1791|   156k|    int len = InInteger(stream);
 1792|   156k|#ifdef LONG_VECTOR_SUPPORT
 1793|   156k|    if (len < -1)
  ------------------
  |  Branch (1793:9): [True: 0, False: 156k]
  ------------------
 1794|      0|	error(_("negative serialized length for vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("negative serialized length for vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1795|   156k|    if (len == -1) {
  ------------------
  |  Branch (1795:9): [True: 0, False: 156k]
  ------------------
 1796|      0|	unsigned int len1, len2;
 1797|      0|	len1 = InInteger(stream); /* upper part */
 1798|      0|	len2 = InInteger(stream); /* lower part */
 1799|      0|	R_xlen_t xlen = len1;
 1800|       |	/* sanity check for now */
 1801|      0|	if (len1 > 65536)
  ------------------
  |  Branch (1801:6): [True: 0, False: 0]
  ------------------
 1802|      0|	    error (_("invalid upper part of serialized vector length"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error (_("invalid upper part of serialized vector length"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1803|      0|	return (xlen << 32) + len2;
 1804|   156k|    } else return len;
 1805|       |#else
 1806|       |    if (len < 0)
 1807|       |	error(_("negative serialized vector length:\nperhaps long vector from 64-bit version of R?"));
 1808|       |    return len;
 1809|       |#endif
 1810|   156k|}
serialize.c:InIntegerVec:
 1533|  69.5k|{
 1534|  69.5k|    switch (stream->type) {
 1535|  69.5k|    case R_pstream_xdr_format:
  ------------------
  |  Branch (1535:5): [True: 69.5k, False: 0]
  ------------------
 1536|  69.5k|    {
 1537|  69.5k|	static char buf[CHUNK_SIZE * sizeof(int)];
 1538|  69.5k|	R_xlen_t done, this;
 1539|  69.5k|	XDR xdrs;
 1540|   139k|	for (done = 0; done < length; done += this) {
  ------------------
  |  Branch (1540:17): [True: 69.4k, False: 69.5k]
  ------------------
 1541|  69.4k|	    this = min2(CHUNK_SIZE, length - done);
  ------------------
  |  |  915|  69.4k|#define min2(a, b) ((a) < (b)) ? (a) : (b)
  |  |  ------------------
  |  |  |  Branch (915:20): [True: 0, False: 69.4k]
  |  |  ------------------
  ------------------
 1542|  69.4k|	    stream->InBytes(stream, buf, (int)(sizeof(int) * this));
 1543|  69.4k|	    xdrmem_create(&xdrs, buf, (int)(this * sizeof(int)), XDR_DECODE);
 1544|   872k|	    for(int cnt = 0; cnt < this; cnt++)
  ------------------
  |  Branch (1544:23): [True: 802k, False: 69.4k]
  ------------------
 1545|   802k|		if(!xdr_int(&xdrs, INTEGER(obj) + done + cnt))
  ------------------
  |  Branch (1545:6): [True: 0, False: 802k]
  ------------------
 1546|      0|		    error(_("XDR read failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("XDR read failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1547|  69.4k|	    xdr_destroy(&xdrs);
  ------------------
  |  Branch (1547:6): [True: 69.4k, False: 0]
  |  Branch (1547:6): [Folded, False: 69.4k]
  ------------------
 1548|  69.4k|	}
 1549|  69.5k|	break;
 1550|      0|    }
 1551|      0|    case R_pstream_binary_format:
  ------------------
  |  Branch (1551:5): [True: 0, False: 69.5k]
  ------------------
 1552|      0|    {
 1553|      0|	R_xlen_t done, this;
 1554|      0|	for (done = 0; done < length; done += this) {
  ------------------
  |  Branch (1554:17): [True: 0, False: 0]
  ------------------
 1555|      0|	    this = min2(CHUNK_SIZE, length - done);
  ------------------
  |  |  915|      0|#define min2(a, b) ((a) < (b)) ? (a) : (b)
  |  |  ------------------
  |  |  |  Branch (915:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1556|      0|	    stream->InBytes(stream, INTEGER(obj) + done,
 1557|      0|			    (int)(sizeof(int) * this));
 1558|      0|	}
 1559|      0|	break;
 1560|      0|    }
 1561|      0|    default:
  ------------------
  |  Branch (1561:5): [True: 0, False: 69.5k]
  ------------------
 1562|      0|	for (R_xlen_t cnt = 0; cnt < length; cnt++)
  ------------------
  |  Branch (1562:25): [True: 0, False: 0]
  ------------------
 1563|      0|	    INTEGER(obj)[cnt] = InInteger(stream);
 1564|  69.5k|    }
 1565|  69.5k|}
serialize.c:InRealVec:
 1569|  3.38k|{
 1570|  3.38k|    switch (stream->type) {
 1571|  3.38k|    case R_pstream_xdr_format:
  ------------------
  |  Branch (1571:5): [True: 3.38k, False: 0]
  ------------------
 1572|  3.38k|    {
 1573|  3.38k|	static char buf[CHUNK_SIZE * sizeof(double)];
 1574|  3.38k|	R_xlen_t done, this;
 1575|  3.38k|	XDR xdrs;
 1576|  6.75k|	for (done = 0; done < length; done += this) {
  ------------------
  |  Branch (1576:17): [True: 3.37k, False: 3.38k]
  ------------------
 1577|  3.37k|	    this = min2(CHUNK_SIZE, length - done);
  ------------------
  |  |  915|  3.37k|#define min2(a, b) ((a) < (b)) ? (a) : (b)
  |  |  ------------------
  |  |  |  Branch (915:20): [True: 0, False: 3.37k]
  |  |  ------------------
  ------------------
 1578|  3.37k|	    stream->InBytes(stream, buf, (int)(sizeof(double) * this));
 1579|  3.37k|	    xdrmem_create(&xdrs, buf, (int)(this * sizeof(double)), XDR_DECODE);
 1580|  6.78k|	    for(R_xlen_t cnt = 0; cnt < this; cnt++)
  ------------------
  |  Branch (1580:28): [True: 3.40k, False: 3.37k]
  ------------------
 1581|  3.40k|		if(!xdr_double(&xdrs, REAL(obj) + done + cnt))
  ------------------
  |  Branch (1581:6): [True: 0, False: 3.40k]
  ------------------
 1582|      0|		    error(_("XDR read failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("XDR read failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1583|  3.37k|	    xdr_destroy(&xdrs);
  ------------------
  |  Branch (1583:6): [True: 3.37k, False: 0]
  |  Branch (1583:6): [Folded, False: 3.37k]
  ------------------
 1584|  3.37k|	}
 1585|  3.38k|	break;
 1586|      0|    }
 1587|      0|    case R_pstream_binary_format:
  ------------------
  |  Branch (1587:5): [True: 0, False: 3.38k]
  ------------------
 1588|      0|    {
 1589|      0|	R_xlen_t done, this;
 1590|      0|	for (done = 0; done < length; done += this) {
  ------------------
  |  Branch (1590:17): [True: 0, False: 0]
  ------------------
 1591|      0|	    this = min2(CHUNK_SIZE, length - done);
  ------------------
  |  |  915|      0|#define min2(a, b) ((a) < (b)) ? (a) : (b)
  |  |  ------------------
  |  |  |  Branch (915:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1592|      0|	    stream->InBytes(stream, REAL(obj) + done,
 1593|      0|			    (int)(sizeof(double) * this));
 1594|      0|	}
 1595|      0|	break;
 1596|      0|    }
 1597|      0|    default:
  ------------------
  |  Branch (1597:5): [True: 0, False: 3.38k]
  ------------------
 1598|      0|	for (R_xlen_t cnt = 0; cnt < length; cnt++)
  ------------------
  |  Branch (1598:25): [True: 0, False: 0]
  ------------------
 1599|      0|	    REAL(obj)[cnt] = InReal(stream);
 1600|  3.38k|    }
 1601|  3.38k|}
serialize.c:InComplexVec:
 1605|      2|{
 1606|      2|    switch (stream->type) {
 1607|      2|    case R_pstream_xdr_format:
  ------------------
  |  Branch (1607:5): [True: 2, False: 0]
  ------------------
 1608|      2|    {
 1609|      2|	static char buf[CHUNK_SIZE * sizeof(Rcomplex)];
 1610|      2|	R_xlen_t done, this;
 1611|      2|	XDR xdrs;
 1612|      2|	Rcomplex *output = COMPLEX(obj);
 1613|      2|	for (done = 0; done < length; done += this) {
  ------------------
  |  Branch (1613:17): [True: 0, False: 2]
  ------------------
 1614|      0|	    this = min2(CHUNK_SIZE, length - done);
  ------------------
  |  |  915|      0|#define min2(a, b) ((a) < (b)) ? (a) : (b)
  |  |  ------------------
  |  |  |  Branch (915:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1615|      0|	    stream->InBytes(stream, buf, (int)(sizeof(Rcomplex) * this));
 1616|      0|	    xdrmem_create(&xdrs, buf, (int)(this * sizeof(Rcomplex)), XDR_DECODE);
 1617|      0|	    for(R_xlen_t cnt = 0; cnt < this; cnt++) {
  ------------------
  |  Branch (1617:28): [True: 0, False: 0]
  ------------------
 1618|      0|		if(!xdr_double(&xdrs, &(output[done+cnt].r)) ||
  ------------------
  |  Branch (1618:6): [True: 0, False: 0]
  ------------------
 1619|      0|		   !xdr_double(&xdrs, &(output[done+cnt].i)))
  ------------------
  |  Branch (1619:6): [True: 0, False: 0]
  ------------------
 1620|      0|		    error(_("XDR read failed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("XDR read failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1621|      0|	    }
 1622|      0|	    xdr_destroy(&xdrs);
  ------------------
  |  Branch (1622:6): [True: 0, False: 0]
  |  Branch (1622:6): [Folded, False: 0]
  ------------------
 1623|      0|	}
 1624|      2|	break;
 1625|      0|    }
 1626|      0|    case R_pstream_binary_format:
  ------------------
  |  Branch (1626:5): [True: 0, False: 2]
  ------------------
 1627|      0|    {
 1628|      0|	R_xlen_t done, this;
 1629|      0|	for (done = 0; done < length; done += this) {
  ------------------
  |  Branch (1629:17): [True: 0, False: 0]
  ------------------
 1630|      0|	    this = min2(CHUNK_SIZE, length - done);
  ------------------
  |  |  915|      0|#define min2(a, b) ((a) < (b)) ? (a) : (b)
  |  |  ------------------
  |  |  |  Branch (915:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1631|      0|	    stream->InBytes(stream, COMPLEX(obj) + done,
 1632|      0|			    (int)(sizeof(Rcomplex) * this));
 1633|      0|	}
 1634|      0|	break;
 1635|      0|    }
 1636|      0|    default:
  ------------------
  |  Branch (1636:5): [True: 0, False: 2]
  ------------------
 1637|      0|	for (R_xlen_t cnt = 0; cnt < length; cnt++)
  ------------------
  |  Branch (1637:25): [True: 0, False: 0]
  ------------------
 1638|      0|	    COMPLEX(obj)[cnt] = InComplex(stream);
 1639|      2|    }
 1640|      2|}
serialize.c:ReadBC:
 2301|  5.66k|{
 2302|  5.66k|    BCReps reps;
 2303|  5.66k|    SEXP ans;
 2304|  5.66k|    int n = InInteger(stream);
 2305|       |
 2306|  5.66k|    if (n < 0)
  ------------------
  |  Branch (2306:9): [True: 0, False: 5.66k]
  ------------------
 2307|      0|	error(_("bytecode reference index out of range"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("bytecode reference index out of range"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2308|  5.66k|    reps.ndefs = 0;
 2309|  5.66k|    PROTECT_WITH_INDEX(reps.slots = allocVector(VECSXP, n < BC_REPS_INIT ?
  ------------------
  |  |  366|  11.3k|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  |  |  ------------------
  |  |  |  Branch (366:52): [True: 5.66k, False: 0]
  |  |  ------------------
  ------------------
 2310|  5.66k|						n : BC_REPS_INIT),
 2311|  5.66k|		       &reps.ipx);
 2312|  5.66k|    ans = ReadBC1(ref_table, &reps, stream);
 2313|  5.66k|    UNPROTECT(1);
  ------------------
  |  |  358|  5.66k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2314|  5.66k|    return ans;
 2315|  5.66k|}
serialize.c:ReadBC1:
 2285|  22.1k|{
 2286|  22.1k|    SEXP s;
 2287|  22.1k|    PROTECT(s = allocSExp(BCODESXP));
  ------------------
  |  |  357|  22.1k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2288|  22.1k|    R_ReadItemDepth++;
 2289|  22.1k|    SETCAR(s, ReadItem(ref_table, stream)); /* code */
 2290|  22.1k|    R_ReadItemDepth--;
 2291|  22.1k|    SEXP bytes = PROTECT(CAR(s));
  ------------------
  |  |  357|  22.1k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2292|  22.1k|    SETCAR(s, R_bcEncode(bytes));
 2293|  22.1k|    SETCDR(s, ReadBCConsts(ref_table, reps, stream)); /* consts */
 2294|  22.1k|    SET_TAG(s, R_NilValue); /* expr */
 2295|  22.1k|    R_registerBC(bytes, s);
 2296|  22.1k|    UNPROTECT(2);
  ------------------
  |  |  358|  22.1k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2297|  22.1k|    return s;
 2298|  22.1k|}
serialize.c:ReadBCConsts:
 2253|  22.1k|{
 2254|  22.1k|    SEXP ans, c;
 2255|  22.1k|    int i, n;
 2256|  22.1k|    n = InInteger(stream);
 2257|  22.1k|    PROTECT(ans = allocVector(VECSXP, n));
  ------------------
  |  |  357|  22.1k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2258|   184k|    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (2258:17): [True: 162k, False: 22.1k]
  ------------------
 2259|   162k|	int type = InInteger(stream);
 2260|   162k|	switch (type) {
 2261|  16.4k|	case BCODESXP:
  ------------------
  |  |  133|  16.4k|#define BCODESXP    21    /* byte code */
  ------------------
  |  Branch (2261:2): [True: 16.4k, False: 145k]
  ------------------
 2262|  16.4k|	    c = ReadBC1(ref_table, reps, stream);
 2263|  16.4k|	    SET_VECTOR_ELT(ans, i, c);
 2264|  16.4k|	    break;
 2265|  8.98k|	case LANGSXP:
  ------------------
  |  |  117|  8.98k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (2265:2): [True: 8.98k, False: 153k]
  ------------------
 2266|  8.98k|	case LISTSXP:
  ------------------
  |  |  113|  8.98k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2266:2): [True: 0, False: 162k]
  ------------------
 2267|  11.4k|	case BCREPDEF:
  ------------------
  |  |  700|  11.4k|#define BCREPDEF          244
  ------------------
  |  Branch (2267:2): [True: 2.46k, False: 159k]
  ------------------
 2268|  66.4k|	case BCREPREF:
  ------------------
  |  |  701|  66.4k|#define BCREPREF          243
  ------------------
  |  Branch (2268:2): [True: 55.0k, False: 107k]
  ------------------
 2269|  66.4k|	case ATTRLANGSXP:
  ------------------
  |  |  715|  66.4k|#define ATTRLANGSXP       240
  ------------------
  |  Branch (2269:2): [True: 0, False: 162k]
  ------------------
 2270|  66.4k|	case ATTRLISTSXP:
  ------------------
  |  |  716|  66.4k|#define ATTRLISTSXP       239
  ------------------
  |  Branch (2270:2): [True: 0, False: 162k]
  ------------------
 2271|  66.4k|	    c = ReadBCLang(type, ref_table, reps, stream);
 2272|  66.4k|	    SET_VECTOR_ELT(ans, i, c);
 2273|  66.4k|	    break;
 2274|  79.1k|	default:
  ------------------
  |  Branch (2274:2): [True: 79.1k, False: 82.9k]
  ------------------
 2275|  79.1k|	    R_ReadItemDepth++;
 2276|  79.1k|	    SET_VECTOR_ELT(ans, i, ReadItem(ref_table, stream));
 2277|  79.1k|	    R_ReadItemDepth--;
 2278|   162k|	}
 2279|   162k|    }
 2280|  22.1k|    UNPROTECT(1);
  ------------------
  |  |  358|  22.1k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2281|  22.1k|    return ans;
 2282|  22.1k|}
serialize.c:ReadBCLang:
 2188|   487k|{
 2189|   487k|    switch (type) {
 2190|  60.7k|    case BCREPREF:
  ------------------
  |  |  701|  60.7k|#define BCREPREF          243
  ------------------
  |  Branch (2190:5): [True: 60.7k, False: 426k]
  ------------------
 2191|  60.7k|	{
 2192|  60.7k|	    int pos = InInteger(stream);
 2193|  60.7k|	    if (pos < 0 || pos >= reps->ndefs)
  ------------------
  |  Branch (2193:10): [True: 0, False: 60.7k]
  |  Branch (2193:21): [True: 0, False: 60.7k]
  ------------------
 2194|      0|		error(_("bytecode reference index out of range"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("bytecode reference index out of range"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2195|  60.7k|	    return VECTOR_ELT(reps->slots, pos);
 2196|      0|	}
 2197|  45.2k|    case BCREPDEF:
  ------------------
  |  |  700|  45.2k|#define BCREPDEF          244
  ------------------
  |  Branch (2197:5): [True: 45.2k, False: 441k]
  ------------------
 2198|  67.7k|    case LANGSXP:
  ------------------
  |  |  117|  67.7k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (2198:5): [True: 22.5k, False: 464k]
  ------------------
 2199|   210k|    case LISTSXP:
  ------------------
  |  |  113|   210k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2199:5): [True: 142k, False: 344k]
  ------------------
 2200|   210k|    case ATTRLANGSXP:
  ------------------
  |  |  715|   210k|#define ATTRLANGSXP       240
  ------------------
  |  Branch (2200:5): [True: 0, False: 487k]
  ------------------
 2201|   210k|    case ATTRLISTSXP:
  ------------------
  |  |  716|   210k|#define ATTRLISTSXP       239
  ------------------
  |  Branch (2201:5): [True: 0, False: 487k]
  ------------------
 2202|   210k|	{
 2203|   210k|	    SEXP ans;
 2204|   210k|	    int pos = -1;
 2205|   210k|	    int hasattr = false;
 2206|   210k|	    if (type == BCREPDEF) {
  ------------------
  |  |  700|   210k|#define BCREPDEF          244
  ------------------
  |  Branch (2206:10): [True: 45.2k, False: 165k]
  ------------------
 2207|  45.2k|		pos = InInteger(stream);
 2208|       |		/* definitions are numbered in writing order, so a
 2209|       |		   well-formed stream never skips ahead */
 2210|  45.2k|		if (pos < 0 || pos > reps->ndefs)
  ------------------
  |  Branch (2210:7): [True: 0, False: 45.2k]
  |  Branch (2210:18): [True: 0, False: 45.2k]
  ------------------
 2211|      0|		    error(_("bytecode reference index out of range"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("bytecode reference index out of range"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2212|  45.2k|		type = InInteger(stream);
 2213|  45.2k|	    }
 2214|   210k|	    switch (type) {
  ------------------
  |  Branch (2214:14): [True: 0, False: 210k]
  ------------------
 2215|      0|	    case ATTRLANGSXP: type = LANGSXP; hasattr = TRUE; break;
  ------------------
  |  |  715|      0|#define ATTRLANGSXP       240
  ------------------
              	    case ATTRLANGSXP: type = LANGSXP; hasattr = TRUE; break;
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (2215:6): [True: 0, False: 210k]
  ------------------
 2216|      0|	    case ATTRLISTSXP: type = LISTSXP; hasattr = TRUE; break;
  ------------------
  |  |  716|      0|#define ATTRLISTSXP       239
  ------------------
              	    case ATTRLISTSXP: type = LISTSXP; hasattr = TRUE; break;
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2216:6): [True: 0, False: 210k]
  ------------------
 2217|   210k|	    }
 2218|       |	    /* the BCREPDEF type comes from the stream; allocSExp would
 2219|       |	       happily build a cons cell labelled as any other type */
 2220|   210k|	    if (type != LANGSXP && type != LISTSXP)
  ------------------
  |  |  117|   420k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
              	    if (type != LANGSXP && type != LISTSXP)
  ------------------
  |  |  113|   142k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (2220:10): [True: 142k, False: 67.7k]
  |  Branch (2220:29): [True: 0, False: 142k]
  ------------------
 2221|      0|		error(_("ReadBCLang: invalid type %i"), type);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("ReadBCLang: invalid type %i"), type);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2222|   210k|	    PROTECT(ans = allocSExp(type));
  ------------------
  |  |  357|   210k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2223|   210k|	    if (pos >= 0) {
  ------------------
  |  Branch (2223:10): [True: 45.2k, False: 165k]
  ------------------
 2224|  45.2k|		if (pos >= XLENGTH(reps->slots))
  ------------------
  |  Branch (2224:7): [True: 0, False: 45.2k]
  ------------------
 2225|      0|		    GrowBCReps(reps);
 2226|  45.2k|		SET_VECTOR_ELT(reps->slots, pos, ans);
 2227|  45.2k|		if (pos == reps->ndefs)
  ------------------
  |  Branch (2227:7): [True: 45.2k, False: 0]
  ------------------
 2228|  45.2k|		    reps->ndefs++;
 2229|  45.2k|	    }
 2230|   210k|	    R_ReadItemDepth++;
 2231|   210k|	    if (hasattr)
  ------------------
  |  Branch (2231:10): [True: 0, False: 210k]
  ------------------
 2232|      0|		SET_ATTRIB(ans, ReadItem(ref_table, stream));
 2233|   210k|	    SET_TAG(ans, ReadItem(ref_table, stream));
 2234|   210k|	    R_ReadItemDepth--;
 2235|   210k|	    SETCAR(ans, ReadBCLang(InInteger(stream), ref_table, reps,
 2236|   210k|				   stream));
 2237|   210k|	    SETCDR(ans, ReadBCLang(InInteger(stream), ref_table, reps,
 2238|   210k|				   stream));
 2239|   210k|	    UNPROTECT(1);
  ------------------
  |  |  358|   210k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2240|   210k|	    return ans;
 2241|   210k|	}
 2242|   216k|    default:
  ------------------
  |  Branch (2242:5): [True: 216k, False: 271k]
  ------------------
 2243|   216k|	{
 2244|   216k|	    R_ReadItemDepth++;
 2245|   216k|	    SEXP res = ReadItem(ref_table, stream);
 2246|   216k|	    R_ReadItemDepth--;
 2247|   216k|	    return res;
 2248|   210k|	}
 2249|   487k|    }
 2250|   487k|}
serialize.c:CheckInConn:
 2560|  88.1k|{
 2561|  88.1k|    if (! con->isopen)
  ------------------
  |  Branch (2561:9): [True: 0, False: 88.1k]
  ------------------
 2562|      0|	error(_("connection is not open"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("connection is not open"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2563|  88.1k|    if (! con->canread || con->read == NULL)
  ------------------
  |  Branch (2563:9): [True: 0, False: 88.1k]
  |  Branch (2563:27): [True: 0, False: 88.1k]
  ------------------
 2564|      0|	error(_("cannot read from this connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot read from this connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2565|  88.1k|}
serialize.c:InBytesConn:
 2576|  88.0k|{
 2577|  88.0k|    Rconnection con = (Rconnection) stream->data;
 2578|  88.0k|    CheckInConn(con);
 2579|  88.0k|    if (con->text) {
  ------------------
  |  Branch (2579:9): [True: 0, False: 88.0k]
  ------------------
 2580|      0|	int i;
 2581|      0|	char *p = buf;
 2582|      0|	for (i = 0; i < length; i++)
  ------------------
  |  Branch (2582:14): [True: 0, False: 0]
  ------------------
 2583|      0|	    p[i] = (char) Rconn_fgetc(con);
 2584|      0|    }
 2585|  88.0k|    else {
 2586|  88.0k|	if (stream->type == R_pstream_ascii_format) {
  ------------------
  |  Branch (2586:6): [True: 0, False: 88.0k]
  ------------------
 2587|      0|	    char linebuf[4];
 2588|      0|	    unsigned char *p = buf;
 2589|      0|	    int i;
 2590|      0|	    unsigned int res;
 2591|      0|	    for (i = 0; i < length; i++) {
  ------------------
  |  Branch (2591:18): [True: 0, False: 0]
  ------------------
 2592|      0|		size_t ncread = Rconn_getline(con, linebuf, 3);
 2593|      0|		if (ncread != 2)
  ------------------
  |  Branch (2593:7): [True: 0, False: 0]
  ------------------
 2594|      0|		    error(_("error reading from ascii connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("error reading from ascii connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2595|      0|		if (!sscanf(linebuf, "%02x", &res))
  ------------------
  |  Branch (2595:7): [True: 0, False: 0]
  ------------------
 2596|      0|		    error(_("unexpected format in ascii connection '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("unexpected format in ascii connection '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2597|      0|			con->description);
 2598|      0|		*p++ = (unsigned char)res;
 2599|      0|	    }
 2600|  88.0k|	} else {
 2601|  88.0k|	    if (length != con->read(buf, 1, length, con))
  ------------------
  |  Branch (2601:10): [True: 0, False: 88.0k]
  ------------------
 2602|      0|		error(_("error reading from connection '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("error reading from connection '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2603|      0|		      con->description);
 2604|  88.0k|	}
 2605|  88.0k|    }
 2606|  88.0k|}
serialize.c:CallHook:
 2684|  1.36k|{
 2685|  1.36k|    SEXP val, call;
 2686|  1.36k|    PROTECT(call = LCONS(fun, LCONS(x, R_NilValue)));
  ------------------
  |  |  357|  1.36k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2687|  1.36k|    val = eval(call, R_GlobalEnv);
  ------------------
  |  |  913|  1.36k|#define eval			Rf_eval
  ------------------
 2688|  1.36k|    UNPROTECT(1);
  ------------------
  |  |  358|  1.36k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2689|  1.36k|    return val;
 2690|  1.36k|}
serialize.c:checkNotPromise:
 2770|     72|{
 2771|     72|    if (TYPEOF(val) == PROMSXP)
  ------------------
  |  |  116|     72|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (2771:9): [True: 0, False: 72]
  ------------------
 2772|      0|	error(_("cannot return a promise (PROMSXP) object"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot return a promise (PROMSXP) object"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2773|     72|    return val;
 2774|     72|}
serialize.c:readRawFromFile:
 3261|  1.51k|{
 3262|  1.51k|    FILE *fp;
 3263|  1.51k|    int offset, len, in, i, icache = -1;
 3264|  1.51k|    long filelen;
 3265|  1.51k|    SEXP val;
 3266|  1.51k|    const void *vmax;
 3267|  1.51k|    const char *cfile;
 3268|       |
 3269|  1.51k|    if (! IS_PROPER_STRING(file))
  ------------------
  |  | 3125|  1.51k|#define IS_PROPER_STRING(s) (TYPEOF(s) == STRSXP && LENGTH(s) > 0)
  |  |  ------------------
  |  |  |  |  126|  3.03k|#define STRSXP	    16	  /* string vectors */
  |  |  ------------------
  |  |  |  Branch (3125:30): [True: 1.51k, False: 0]
  |  |  |  Branch (3125:53): [True: 1.51k, False: 0]
  |  |  ------------------
  ------------------
 3270|      0|	error(_("not a proper file name"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("not a proper file name"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3271|  1.51k|    vmax = vmaxget();
 3272|  1.51k|    cfile = translateCharFP(STRING_ELT(file, 0));
  ------------------
  |  | 1998|  1.51k|# define translateCharFP	Rf_translateCharFP
  ------------------
 3273|  1.51k|    if (TYPEOF(key) != INTSXP || LENGTH(key) != 2)
  ------------------
  |  |  123|  3.03k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (3273:9): [True: 0, False: 1.51k]
  |  Branch (3273:34): [True: 0, False: 1.51k]
  ------------------
 3274|      0|	error(_("bad offset/length argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("bad offset/length argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3275|       |
 3276|  1.51k|    offset = INTEGER(key)[0];
 3277|  1.51k|    len = INTEGER(key)[1];
 3278|       |
 3279|  1.51k|    val = allocVector(RAWSXP, len);
  ------------------
  |  |  875|  1.51k|#define allocVector		Rf_allocVector
  ------------------
                  val = allocVector(RAWSXP, len);
  ------------------
  |  |  136|  1.51k|#define RAWSXP      24    /* raw bytes */
  ------------------
 3280|       |    /* Do we have this database cached? */
 3281|  4.31k|    for (i = 0; i < used; i++)
  ------------------
  |  Branch (3281:17): [True: 4.29k, False: 14]
  ------------------
 3282|  4.29k|	if(names[i] != NULL && strcmp(cfile, names[i]) == 0) {icache = i; break;}
  ------------------
  |  Branch (3282:5): [True: 4.29k, False: 0]
  |  Branch (3282:25): [True: 1.50k, False: 2.79k]
  ------------------
 3283|  1.51k|    if (icache >= 0) {
  ------------------
  |  Branch (3283:9): [True: 1.50k, False: 14]
  ------------------
 3284|       |	/* The file may have been replaced since it was cached, e.g. by
 3285|       |	   re-installing the package, possibly from another process.  If
 3286|       |	   so, drop the cached copy: the offsets in 'key' come from the
 3287|       |	   current index file and need not be valid in a stale copy of
 3288|       |	   the database. */
 3289|  1.50k|	struct fileid id;
 3290|  1.50k|	if (! getFileID(cfile, &id) ||
  ------------------
  |  Branch (3290:6): [True: 0, False: 1.50k]
  ------------------
 3291|  1.50k|	    id.size != ids[icache].size || id.mtime != ids[icache].mtime ||
  ------------------
  |  Branch (3291:6): [True: 0, False: 1.50k]
  |  Branch (3291:37): [True: 0, False: 1.50k]
  ------------------
 3292|  1.50k|	    id.ino != ids[icache].ino || id.dev != ids[icache].dev) {
  ------------------
  |  Branch (3292:6): [True: 0, False: 1.50k]
  |  Branch (3292:35): [True: 0, False: 1.50k]
  ------------------
 3293|      0|	    free(names[icache]);
 3294|      0|	    names[icache] = NULL;
 3295|      0|	    free(ptr[icache]);
 3296|      0|	    icache = -1;
 3297|      0|	}
 3298|  1.50k|    }
 3299|  1.51k|    if (icache >= 0) {
  ------------------
  |  Branch (3299:9): [True: 1.50k, False: 14]
  ------------------
 3300|  1.50k|	if (offset < 0 || (size_t) offset + (size_t) len > lens[icache])
  ------------------
  |  Branch (3300:6): [True: 0, False: 1.50k]
  |  Branch (3300:20): [True: 0, False: 1.50k]
  ------------------
 3301|      0|	    error(_("bad offset/length argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("bad offset/length argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3302|  1.50k|	if (len)
  ------------------
  |  Branch (3302:6): [True: 1.50k, False: 0]
  ------------------
 3303|  1.50k|	    memcpy(RAW(val), ptr[icache]+offset, len);
 3304|  1.50k|	vmaxset(vmax);
 3305|  1.50k|	return val;
 3306|  1.50k|    }
 3307|       |
 3308|       |    /* find a vacant slot? */
 3309|     56|    for (i = 0; i < used; i++)
  ------------------
  |  Branch (3309:17): [True: 42, False: 14]
  ------------------
 3310|     42|	if(names[i] == NULL) {icache = i; break;}
  ------------------
  |  Branch (3310:5): [True: 0, False: 42]
  ------------------
 3311|     14|    if(icache < 0 && used < NC) {
  ------------------
  |  | 3192|     14|#define NC 256
  ------------------
  |  Branch (3311:8): [True: 14, False: 0]
  |  Branch (3311:22): [True: 14, False: 0]
  ------------------
 3312|     14|	icache = used++;
 3313|     14|	names[icache] = NULL;
 3314|     14|    }
 3315|       |
 3316|     14|    if(icache >= 0) {
  ------------------
  |  Branch (3316:8): [True: 14, False: 0]
  ------------------
 3317|       |	/* Capture the file's identity before reading it: if the file
 3318|       |	   is replaced while it is being read, the next fetch will see
 3319|       |	   a mismatch and drop the cached copy. */
 3320|     14|	struct fileid id;
 3321|     14|	bool cacheable = getFileID(cfile, &id);
 3322|     14|	if ((fp = R_fopen(cfile, "rb")) == NULL)
  ------------------
  |  Branch (3322:6): [True: 0, False: 14]
  ------------------
 3323|      0|	    error(_("cannot open file '%s': %s"), cfile, strerror(errno));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("cannot open file '%s': %s"), cfile, strerror(errno));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3324|     14|	if (fseek(fp, 0, SEEK_END) != 0) {
  ------------------
  |  Branch (3324:6): [True: 0, False: 14]
  ------------------
 3325|      0|	    fclose(fp);
 3326|      0|	    error(_("seek failed on %s"), cfile);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("seek failed on %s"), cfile);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3327|      0|	}
 3328|     14|	filelen = ftell(fp);
 3329|     14|	if (cacheable && filelen < LEN_LIMIT) {
  ------------------
  |  | 3259|     14|#define LEN_LIMIT 10*1048576
  ------------------
  |  Branch (3329:6): [True: 14, False: 0]
  |  Branch (3329:19): [True: 14, False: 0]
  ------------------
 3330|     14|	    char *p, *n;
 3331|       |	    /* fprintf(stderr, "adding file '%s' at pos %d in cache, length %d\n",
 3332|       |	       cfile, icache, filelen); */
 3333|     14|	    p = (char *) malloc(filelen);
 3334|     14|	    n = (char *) malloc(strlen(cfile) + 1);
 3335|     14|	    if (p && n) {
  ------------------
  |  Branch (3335:10): [True: 14, False: 0]
  |  Branch (3335:15): [True: 14, False: 0]
  ------------------
 3336|     14|		names[icache] = n;
 3337|     14|		strcpy(names[icache], cfile);
 3338|     14|		ptr[icache] = p;
 3339|     14|		lens[icache] = (size_t) filelen;
 3340|     14|		ids[icache] = id;
 3341|     14|		if (fseek(fp, 0, SEEK_SET) != 0) {
  ------------------
  |  Branch (3341:7): [True: 0, False: 14]
  ------------------
 3342|      0|		    fclose(fp);
 3343|      0|		    error(_("seek failed on %s"), cfile);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("seek failed on %s"), cfile);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3344|      0|		}
 3345|     14|		in = (int) fread(p, 1, filelen, fp);
 3346|     14|		fclose(fp);
 3347|     14|		if (filelen != in) error(_("read failed on %s"), cfile);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		if (filelen != in) error(_("read failed on %s"), cfile);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (3347:7): [True: 0, False: 14]
  ------------------
 3348|     14|		if (offset < 0 || (size_t) offset + (size_t) len > lens[icache])
  ------------------
  |  Branch (3348:7): [True: 0, False: 14]
  |  Branch (3348:21): [True: 0, False: 14]
  ------------------
 3349|      0|		    error(_("bad offset/length argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("bad offset/length argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3350|     14|		if (len)
  ------------------
  |  Branch (3350:7): [True: 14, False: 0]
  ------------------
 3351|     14|		    memcpy(RAW(val), p+offset, len);
 3352|     14|	    } else {
 3353|      0|		if (p)
  ------------------
  |  Branch (3353:7): [True: 0, False: 0]
  ------------------
 3354|      0|		    free(p);
 3355|      0|		if (n)
  ------------------
  |  Branch (3355:7): [True: 0, False: 0]
  ------------------
 3356|      0|		    free(n);
 3357|      0|		if (fseek(fp, offset, SEEK_SET) != 0) {
  ------------------
  |  Branch (3357:7): [True: 0, False: 0]
  ------------------
 3358|      0|		    fclose(fp);
 3359|      0|		    error(_("seek failed on %s"), cfile);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		    error(_("seek failed on %s"), cfile);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3360|      0|		}
 3361|      0|		in = (int) fread(RAW(val), 1, len, fp);
 3362|      0|		fclose(fp);
 3363|      0|		if (len != in) error(_("read failed on %s"), cfile);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		if (len != in) error(_("read failed on %s"), cfile);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (3363:7): [True: 0, False: 0]
  ------------------
 3364|      0|	    }
 3365|     14|	    vmaxset(vmax);
 3366|     14|	    return val;
 3367|     14|	} else {
 3368|      0|	    if (fseek(fp, offset, SEEK_SET) != 0) {
  ------------------
  |  Branch (3368:10): [True: 0, False: 0]
  ------------------
 3369|      0|		fclose(fp);
 3370|      0|		error(_("seek failed on %s"), cfile);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("seek failed on %s"), cfile);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3371|      0|	    }
 3372|      0|	    in = (int) fread(RAW(val), 1, len, fp);
 3373|      0|	    fclose(fp);
 3374|      0|	    if (len != in) error(_("read failed on %s"), cfile);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    if (len != in) error(_("read failed on %s"), cfile);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (3374:10): [True: 0, False: 0]
  ------------------
 3375|      0|	    vmaxset(vmax);
 3376|      0|	    return val;
 3377|      0|	}
 3378|     14|    }
 3379|       |
 3380|      0|    if ((fp = R_fopen(cfile, "rb")) == NULL)
  ------------------
  |  Branch (3380:9): [True: 0, False: 0]
  ------------------
 3381|      0|	error(_("cannot open file '%s': %s"), cfile, strerror(errno));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("cannot open file '%s': %s"), cfile, strerror(errno));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3382|      0|    if (fseek(fp, offset, SEEK_SET) != 0) {
  ------------------
  |  Branch (3382:9): [True: 0, False: 0]
  ------------------
 3383|      0|	fclose(fp);
 3384|      0|	error(_("seek failed on %s"), cfile);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("seek failed on %s"), cfile);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3385|      0|    }
 3386|      0|    in = (int) fread(RAW(val), 1, len, fp);
 3387|      0|    fclose(fp);
 3388|      0|    if (len != in) error(_("read failed on %s"), cfile);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (len != in) error(_("read failed on %s"), cfile);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (3388:9): [True: 0, False: 0]
  ------------------
 3389|      0|    vmaxset(vmax);
 3390|      0|    return val;
 3391|     14|}
serialize.c:getFileID:
 3205|  1.51k|{
 3206|       |#ifdef Win32
 3207|       |    struct _stati64 sb;
 3208|       |    if (_stati64(cfile, &sb) != 0)
 3209|       |	return false;
 3210|       |#else
 3211|  1.51k|    struct stat sb;
 3212|  1.51k|    if (stat(cfile, &sb) != 0)
  ------------------
  |  Branch (3212:9): [True: 0, False: 1.51k]
  ------------------
 3213|      0|	return false;
 3214|  1.51k|#endif
 3215|  1.51k|    id->size = (double) sb.st_size;
 3216|       |    /* use sub-second modification times where available, as in
 3217|       |       do_fileinfo (platform.c) */
 3218|  1.51k|#if defined HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC \
 3219|  1.51k|    && defined TYPEOF_STRUCT_STAT_ST_ATIM_IS_STRUCT_TIMESPEC
 3220|  1.51k|    id->mtime = (double) sb.st_mtim.tv_sec
 3221|  1.51k|	+ 1e-9 * (double) sb.st_mtim.tv_nsec;
 3222|       |#elif defined HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC
 3223|       |    id->mtime = (double) sb.st_mtimespec.tv_sec
 3224|       |	+ 1e-9 * (double) sb.st_mtimespec.tv_nsec;
 3225|       |#else
 3226|       |    id->mtime = (double) sb.st_mtime;
 3227|       |#endif
 3228|  1.51k|    id->ino = (double) sb.st_ino;
 3229|  1.51k|    id->dev = (double) sb.st_dev;
 3230|  1.51k|    return true;
 3231|  1.51k|}
serialize.c:R_unserialize:
 3095|  1.51k|{
 3096|  1.51k|    struct R_inpstream_st in;
 3097|  1.51k|    SEXP (*hook)(SEXP, SEXP);
 3098|       |
 3099|  1.51k|    hook = fun != R_NilValue ? CallHook : NULL;
  ------------------
  |  Branch (3099:12): [True: 1.51k, False: 0]
  ------------------
 3100|       |
 3101|  1.51k|    if (TYPEOF(icon) == STRSXP && LENGTH(icon) > 0) {
  ------------------
  |  |  126|  3.03k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (3101:9): [True: 0, False: 1.51k]
  |  Branch (3101:35): [True: 0, False: 0]
  ------------------
 3102|       |	/* was the format in R < 2.4.0, removed in R 2.8.0 */
 3103|      0|	error("character vectors are no longer accepted by unserialize()");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 3104|      0|	return R_NilValue; /* -Wall */
 3105|  1.51k|    } else if (TYPEOF(icon) == RAWSXP) {
  ------------------
  |  |  136|  1.51k|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (3105:16): [True: 1.51k, False: 0]
  ------------------
 3106|       |	/* We might want to read from a long raw vector */
 3107|  1.51k|	struct membuf_st mbs;
 3108|  1.51k|	void *data = RAW(icon);
 3109|  1.51k|	R_size_t length = XLENGTH(icon);
 3110|  1.51k|	InitMemInPStream(&in, &mbs, data,  length, hook, fun);
 3111|  1.51k|	return R_Unserialize(&in);
 3112|  1.51k|    } else {
 3113|      0|	Rconnection con = getConnection(asInteger(icon));
  ------------------
  |  |  885|      0|#define asInteger		Rf_asInteger
  ------------------
 3114|      0|	R_InitConnInPStream(&in, con, R_pstream_any_format, hook, fun);
 3115|      0|	return R_Unserialize(&in);
 3116|      0|    }
 3117|  1.51k|}
serialize.c:InitMemInPStream:
 2991|  1.51k|{
 2992|  1.51k|    mb->count = 0;
 2993|  1.51k|    mb->size = length;
 2994|  1.51k|    mb->buf = buf;
 2995|  1.51k|    R_InitInPStream(stream, (R_pstream_data_t) mb, R_pstream_any_format,
 2996|  1.51k|		    InCharMem, InBytesMem, phook, pdata);
 2997|  1.51k|}
serialize.c:InBytesMem:
 2979|  2.22M|{
 2980|  2.22M|    membuf_t mb = stream->data;
 2981|  2.22M|    if (mb->count + (R_size_t) length > mb->size)
  ------------------
  |  Branch (2981:9): [True: 0, False: 2.22M]
  ------------------
 2982|      0|	error(_("read error"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("read error"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2983|  2.22M|    if (length)
  ------------------
  |  Branch (2983:9): [True: 2.22M, False: 547]
  ------------------
 2984|  2.22M|	memcpy(buf, mb->buf + mb->count, length);
 2985|  2.22M|    mb->count += length;
 2986|  2.22M|}

Rf_isUnsorted:
   88|      8|{
   89|      8|    R_xlen_t n, i;
   90|      8|    int itmp = INT_MIN; /* this is NA_INTEGER, < all valid nonNA R integer
   91|       |			   values */
   92|      8|    double dtmp = R_NegInf; /*  R_NegInf is min possible double	"value",
   93|       |			        ***this is <= all nonNA R numeric values but
   94|       |				NOT < all nonNA	values*** */
   95|      8|    if (!isVectorAtomic(x))
  ------------------
  |  |  975|      8|#define isVectorAtomic		Rf_isVectorAtomic
  ------------------
  |  Branch (95:9): [True: 0, False: 8]
  ------------------
   96|      0|	error(_("only atomic vectors can be tested to be sorted"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("only atomic vectors can be tested to be sorted"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   97|      8|    n = XLENGTH(x);
   98|      8|    if(n >= 2)
  ------------------
  |  Branch (98:8): [True: 8, False: 0]
  ------------------
   99|      8|	switch (TYPEOF(x)) {
  100|       |
  101|       |	    /* NOTE: x must have no NAs {is.na(.) in R};
  102|       |	       hence be faster than `rcmp()', `icmp()' for these two cases */
  103|       |
  104|       |	    /* The only difference between strictly and not is '>' vs '>='
  105|       |	       but we want the if() outside the loop */
  106|       |
  107|       |	    /* x can be an ALTREP here provided that its sortedness is unknown, 
  108|       |	       so we use ITERATE_BY_REGION to get the multiple INTEGER calls
  109|       |	       outside of the tight loop and be ALTREP safe. */
  110|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (110:2): [True: 0, False: 8]
  ------------------
  111|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (111:2): [True: 0, False: 8]
  ------------------
  112|      0|	    if(strictly) {
  ------------------
  |  Branch (112:9): [True: 0, False: 0]
  ------------------
  113|      0|		ITERATE_BY_REGION(x, xptr, i, nbatch, int, INTEGER, {
  ------------------
  |  |  251|      0|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|      0|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|      0|				  strt, nfull, expr) do {		\
  |  |  |  |  221|      0|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|      0|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|      0|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|      0|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|      0|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|      0|	    px += strt;							\
  |  |  |  |  227|      0|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|      0|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  229|      0|	    }                                                           \
  |  |  |  |  230|      0|	}								\
  |  |  |  |  231|      0|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|      0|					strt, nfull, expr);		\
  |  |  |  |  233|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|      0|				  0, XLENGTH(sx), expr);		\
  |  |  254|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  114|       |			/* itmp initialized to INT_MIN which is < all
  115|       |			   valid nonNA R int values so no need to
  116|       |			   exclude first iteration
  117|       |
  118|       |			   After first iteration itmp is value at end
  119|       |			   of last batch */
  120|      0|			if(itmp >= xptr[0]) 
  121|      0|			    return TRUE;
  122|      0|			for(R_xlen_t k = 0; k < nbatch - 1; k++) {
  123|      0|			    if(xptr[k] >= xptr[k+1])
  124|      0|				return TRUE;
  125|      0|			}
  126|      0|			itmp = xptr[nbatch - 1];
  127|      0|		    });
  128|      0|	    } else {
  129|      0|		ITERATE_BY_REGION(x, xptr, i, nbatch, int, INTEGER, {
  ------------------
  |  |  251|      0|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|      0|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|      0|				  strt, nfull, expr) do {		\
  |  |  |  |  221|      0|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|      0|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|      0|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|      0|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|      0|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|      0|	    px += strt;							\
  |  |  |  |  227|      0|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|      0|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  229|      0|	    }                                                           \
  |  |  |  |  230|      0|	}								\
  |  |  |  |  231|      0|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|      0|					strt, nfull, expr);		\
  |  |  |  |  233|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|      0|				  0, XLENGTH(sx), expr);		\
  |  |  254|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  130|      0|			if(itmp > xptr[0]) //deal with batch barriers
  131|      0|			    return TRUE;
  132|      0|			for(R_xlen_t k = 0; k < nbatch - 1; k++) {
  133|      0|			    if(xptr[k] > xptr[k+1])
  134|      0|				return TRUE;
  135|      0|			}
  136|      0|			itmp = xptr[nbatch - 1];
  137|      0|		    });
  138|      0|	    }
  139|      0|	    break;
  140|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (140:2): [True: 0, False: 8]
  ------------------
  141|      0|	    if(strictly) {
  ------------------
  |  Branch (141:9): [True: 0, False: 0]
  ------------------
  142|      0|		ITERATE_BY_REGION(x, xptr, i, nbatch, double, REAL, {
  ------------------
  |  |  251|      0|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|      0|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|      0|				  strt, nfull, expr) do {		\
  |  |  |  |  221|      0|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|      0|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|      0|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|      0|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|      0|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|      0|	    px += strt;							\
  |  |  |  |  227|      0|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|      0|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  229|      0|	    }                                                           \
  |  |  |  |  230|      0|	}								\
  |  |  |  |  231|      0|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|      0|					strt, nfull, expr);		\
  |  |  |  |  233|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|      0|				  0, XLENGTH(sx), expr);		\
  |  |  254|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  143|       |			/* first element could be R_NegInf which is
  144|       |			   initialization value of dtmp so don't do
  145|       |			   the barrier check at i == 0 since its >=
  146|       |			   here
  147|       |
  148|       |			   After first iteration dtmp is value at end
  149|       |			   of last batch */
  150|      0|			if(i > 0 && dtmp >= xptr[0]) //deal with batch barriers
  151|      0|			    return TRUE;
  152|      0|			for(R_xlen_t k = 0; k < nbatch - 1; k++) {
  153|      0|			    if(xptr[k] >= xptr[k+1])
  154|      0|				return TRUE;
  155|      0|			}
  156|      0|			dtmp = xptr[nbatch - 1];
  157|      0|		    });
  158|      0|	    } else {
  159|       |		/* nonstrict, first element can never be < dtmp (== R_NegInf),
  160|       |		   so no need to exclude first iteration in barrier check */
  161|      0|		ITERATE_BY_REGION(x, xptr, i, nbatch, double, REAL, {
  ------------------
  |  |  251|      0|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|      0|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|      0|				  strt, nfull, expr) do {		\
  |  |  |  |  221|      0|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|      0|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|      0|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|      0|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|      0|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|      0|	    px += strt;							\
  |  |  |  |  227|      0|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|      0|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  229|      0|	    }                                                           \
  |  |  |  |  230|      0|	}								\
  |  |  |  |  231|      0|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|      0|					strt, nfull, expr);		\
  |  |  |  |  233|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|      0|				  0, XLENGTH(sx), expr);		\
  |  |  254|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  162|      0|			if(dtmp > xptr[0]) /* deal with batch barriers, dtmp
  163|       |					      is end of last batch */
  164|      0|			    return TRUE;
  165|      0|			for(R_xlen_t k = 0; k < nbatch - 1; k++) {
  166|      0|			    if(xptr[k] > xptr[k+1])
  167|      0|				return TRUE;
  168|      0|			}
  169|      0|			dtmp = xptr[nbatch - 1];
  170|      0|		    });
  171|      0|	    }
  172|      0|	    break;
  173|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (173:2): [True: 0, False: 8]
  ------------------
  174|      0|	    if(strictly) {
  ------------------
  |  Branch (174:9): [True: 0, False: 0]
  ------------------
  175|      0|		for(i = 0; i+1 < n ; i++)
  ------------------
  |  Branch (175:14): [True: 0, False: 0]
  ------------------
  176|      0|		    if(ccmp(COMPLEX(x)[i], COMPLEX(x)[i+1], true) >= 0)
  ------------------
  |  Branch (176:10): [True: 0, False: 0]
  ------------------
  177|      0|			return TRUE;
  178|      0|	    } else {
  179|      0|		for(i = 0; i+1 < n ; i++)
  ------------------
  |  Branch (179:14): [True: 0, False: 0]
  ------------------
  180|      0|		    if(ccmp(COMPLEX(x)[i], COMPLEX(x)[i+1], true) > 0)
  ------------------
  |  Branch (180:10): [True: 0, False: 0]
  ------------------
  181|      0|			return TRUE;
  182|      0|	    }
  183|      0|	    break;
  184|      8|	case STRSXP:
  ------------------
  |  |  126|      8|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (184:2): [True: 8, False: 0]
  ------------------
  185|      8|	    if(strictly) {
  ------------------
  |  Branch (185:9): [True: 0, False: 8]
  ------------------
  186|      0|		for(i = 0; i+1 < n ; i++)
  ------------------
  |  Branch (186:14): [True: 0, False: 0]
  ------------------
  187|      0|		    if(scmp(STRING_ELT(x, i ),
  ------------------
  |  Branch (187:10): [True: 0, False: 0]
  ------------------
  188|      0|			    STRING_ELT(x,i+1), true) >= 0)
  189|      0|			return TRUE;
  190|      8|	    } else {
  191|     16|		for(i = 0; i+1 < n ; i++)
  ------------------
  |  Branch (191:14): [True: 16, False: 0]
  ------------------
  192|     16|		    if(scmp(STRING_ELT(x, i ),
  ------------------
  |  Branch (192:10): [True: 8, False: 8]
  ------------------
  193|     16|			    STRING_ELT(x,i+1), true) > 0)
  194|      8|			return TRUE;
  195|      8|	    }
  196|      0|	    break;
  197|      0|	case RAWSXP: // being compatible with raw_relop() in ./relop.c
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (197:2): [True: 0, False: 8]
  ------------------
  198|      0|	    if(strictly) {
  ------------------
  |  Branch (198:9): [True: 0, False: 0]
  ------------------
  199|      0|		for(i = 0; i+1 < n ; i++)
  ------------------
  |  Branch (199:14): [True: 0, False: 0]
  ------------------
  200|      0|		    if(RAW(x)[i] >= RAW(x)[i+1])
  ------------------
  |  Branch (200:10): [True: 0, False: 0]
  ------------------
  201|      0|			return TRUE;
  202|       |
  203|      0|	    } else {
  204|      0|		for(i = 0; i+1 < n ; i++)
  ------------------
  |  Branch (204:14): [True: 0, False: 0]
  ------------------
  205|      0|		    if(RAW(x)[i] > RAW(x)[i+1])
  ------------------
  |  Branch (205:10): [True: 0, False: 0]
  ------------------
  206|      0|			return TRUE;
  207|      0|	    }
  208|      0|	    break;
  209|      0|	default:
  ------------------
  |  Branch (209:2): [True: 0, False: 8]
  ------------------
  210|      0|	    UNIMPLEMENTED_TYPE("isUnsorted", x);
  211|      8|	}
  212|      0|    return FALSE;/* sorted */
  213|      8|} // isUnsorted()
do_sorted_fpass:
  511|      2|{
  512|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  513|       |
  514|      2|    int decr = asInteger(CADR(args)); 
  ------------------
  |  |  885|      2|#define asInteger		Rf_asInteger
  ------------------
  515|      2|    int nalast = asInteger(CADDR(args)); 
  ------------------
  |  |  885|      2|#define asInteger		Rf_asInteger
  ------------------
  516|      2|    int wanted = makeSortEnum(decr, nalast);
  517|      2|    SEXP x = PROTECT(CAR(args));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
  518|      2|    bool wassorted = fastpass_sortcheck(x, wanted);
  519|      2|    UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  520|      2|    return ScalarLogical(wassorted);
  ------------------
  |  | 1023|      2|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  521|      2|}
Rf_sortVector:
  636|      8|{
  637|      8|    R_xlen_t n = XLENGTH(s);
  638|      8|    if (n >= 2 && (decreasing || isUnsorted(s, FALSE)))
  ------------------
  |  |  970|      8|#define isUnsorted		Rf_isUnsorted
  ------------------
  |  Branch (638:9): [True: 8, False: 0]
  |  Branch (638:20): [True: 0, False: 8]
  |  Branch (638:34): [True: 8, False: 0]
  ------------------
  639|      8|	switch (TYPEOF(s)) {
  640|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (640:2): [True: 0, False: 8]
  ------------------
  641|      0|	case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (641:2): [True: 0, False: 8]
  ------------------
  642|      0|	    R_isort2(INTEGER(s), n, decreasing);
  643|      0|	    break;
  644|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (644:2): [True: 0, False: 8]
  ------------------
  645|      0|	    R_rsort2(REAL(s), n, decreasing);
  646|      0|	    break;
  647|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (647:2): [True: 0, False: 8]
  ------------------
  648|      0|	    R_csort2(COMPLEX(s), n, decreasing);
  649|      0|	    break;
  650|      8|	case STRSXP:
  ------------------
  |  |  126|      8|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (650:2): [True: 8, False: 0]
  ------------------
  651|      8|	    ssort2(STRING_PTR(s), n, decreasing); /* STRING_PTR is safe here */
  652|      8|	    break;
  653|      0|	default:
  ------------------
  |  Branch (653:2): [True: 0, False: 8]
  ------------------
  654|      0|	    UNIMPLEMENTED_TYPE("sortVector", s);
  655|      8|	}
  656|      8|}
sort.c:scmp:
   77|  63.4k|{
   78|  63.4k|    if (x == NA_STRING && y == NA_STRING) return 0;
  ------------------
  |  |  433|   126k|#define NA_STRING	R_NaString
  ------------------
                  if (x == NA_STRING && y == NA_STRING) return 0;
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (78:9): [True: 0, False: 63.4k]
  |  Branch (78:27): [True: 0, False: 0]
  ------------------
   79|  63.4k|    if (x == NA_STRING) return nalast ? 1 : -1;
  ------------------
  |  |  433|  63.4k|#define NA_STRING	R_NaString
  ------------------
  |  Branch (79:9): [True: 0, False: 63.4k]
  |  Branch (79:32): [True: 0, False: 0]
  ------------------
   80|  63.4k|    if (y == NA_STRING) return nalast ? -1 : 1;
  ------------------
  |  |  433|  63.4k|#define NA_STRING	R_NaString
  ------------------
  |  Branch (80:9): [True: 0, False: 63.4k]
  |  Branch (80:32): [True: 0, False: 0]
  ------------------
   81|  63.4k|    if (x == y) return 0;  /* same string in cache */
  ------------------
  |  Branch (81:9): [True: 0, False: 63.4k]
  ------------------
   82|  63.4k|    return Scollate(x, y);
  ------------------
  |  | 1985|  63.4k|# define Scollate		Rf_Scollate
  ------------------
   83|  63.4k|}
sort.c:makeSortEnum:
  494|      2|static int makeSortEnum(int decr, int nalast) {
  495|       |    
  496|       |    /* passing decr = NA_INTEGER indicates UNKNOWN_SORTEDNESS. */
  497|      2|    if (decr == NA_INTEGER)
  ------------------
  |  |   56|      2|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (497:9): [True: 0, False: 2]
  ------------------
  498|      0|	return UNKNOWN_SORTEDNESS;
  499|       |    
  500|      2|    if (nalast == NA_INTEGER)
  ------------------
  |  |   56|      2|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (500:9): [True: 0, False: 2]
  ------------------
  501|      0|	nalast = 1; //  they were/will be removed so we say they are "last"
  502|       |
  503|      2|    if (decr)
  ------------------
  |  Branch (503:9): [True: 0, False: 2]
  ------------------
  504|      0|	return nalast ? SORTED_DECR : SORTED_DECR_NA_1ST;
  ------------------
  |  Branch (504:9): [True: 0, False: 0]
  ------------------
  505|      2|    else /* increasing */
  506|      2|	return nalast ? SORTED_INCR : SORTED_INCR_NA_1ST;
  ------------------
  |  Branch (506:9): [True: 2, False: 0]
  ------------------
  507|      2|}
sort.c:fastpass_sortcheck:
  438|      2|static bool fastpass_sortcheck(SEXP x, int wanted) {
  439|      2|    if(!KNOWN_SORTED(wanted)) 
  ------------------
  |  | 1162|      2|#define KNOWN_SORTED(sorted) (sorted == SORTED_DECR ||			\
  |  |  ------------------
  |  |  |  Branch (1162:31): [True: 0, False: 2]
  |  |  ------------------
  |  | 1163|      2|			      sorted == SORTED_INCR ||			\
  |  |  ------------------
  |  |  |  Branch (1163:10): [True: 2, False: 0]
  |  |  ------------------
  |  | 1164|      2|			      sorted == SORTED_DECR_NA_1ST ||		\
  |  |  ------------------
  |  |  |  Branch (1164:10): [True: 0, False: 0]
  |  |  ------------------
  |  | 1165|      2|			      sorted == SORTED_INCR_NA_1ST)
  |  |  ------------------
  |  |  |  Branch (1165:10): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  440|      0|	return false;
  441|       |
  442|      2|    int sorted = UNKNOWN_SORTEDNESS;
  443|      2|    bool noNA = false, done = false;
  444|       |
  445|      2|    switch(TYPEOF(x)) {
  446|      2|    case INTSXP:
  ------------------
  |  |  123|      2|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (446:5): [True: 2, False: 0]
  ------------------
  447|      2|	sorted = INTEGER_IS_SORTED(x);
  448|      2|	noNA = (bool)INTEGER_NO_NA(x);
  449|      2|	break;
  450|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (450:5): [True: 0, False: 2]
  ------------------
  451|      0|	sorted = REAL_IS_SORTED(x);
  452|      0|	noNA = (bool)REAL_NO_NA(x);
  453|      0|	break;
  454|      0|    default:
  ------------------
  |  Branch (454:5): [True: 0, False: 2]
  ------------------
  455|       |	/* keep sorted == UNKNOWN_SORTEDNESS */
  456|      0|	break;
  457|      2|    }
  458|       |
  459|       |    /* we know wanted is not NA_INTEGER or 0 at this point because
  460|       |       of the immediate return at the beginning for that case */
  461|      2|    if(!KNOWN_SORTED(sorted)) {
  ------------------
  |  | 1162|      2|#define KNOWN_SORTED(sorted) (sorted == SORTED_DECR ||			\
  |  |  ------------------
  |  |  |  Branch (1162:31): [True: 0, False: 2]
  |  |  ------------------
  |  | 1163|      2|			      sorted == SORTED_INCR ||			\
  |  |  ------------------
  |  |  |  Branch (1163:10): [True: 0, False: 2]
  |  |  ------------------
  |  | 1164|      2|			      sorted == SORTED_DECR_NA_1ST ||		\
  |  |  ------------------
  |  |  |  Branch (1164:10): [True: 0, False: 2]
  |  |  ------------------
  |  | 1165|      2|			      sorted == SORTED_INCR_NA_1ST)
  |  |  ------------------
  |  |  |  Branch (1165:10): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  462|      2|	done = false;
  463|      2|    } else if(sorted == wanted) {   
  ------------------
  |  Branch (463:15): [True: 0, False: 0]
  ------------------
  464|      0|	done = true;
  465|       |	/* if there are no NAs, na.last can be ignored */
  466|      0|    } else if(noNA && sorted * wanted > 0) {
  ------------------
  |  Branch (466:15): [True: 0, False: 0]
  |  Branch (466:23): [True: 0, False: 0]
  ------------------
  467|       |	/* same sign, thus same direction of sort */
  468|      0|	done = true;
  469|      0|    }
  470|       |
  471|       |    /* Increasing, usually fairly short, sequences of integers often
  472|       |       arise as levels in as.factor.  A quick check here allows a fast
  473|       |       return in sort.int. */
  474|      2|    if (! done && TYPEOF(x) == INTSXP && wanted > 0 && ! ALTREP(x)) {
  ------------------
  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (474:9): [True: 2, False: 0]
  |  Branch (474:19): [True: 2, False: 0]
  |  Branch (474:42): [True: 2, False: 0]
  |  Branch (474:56): [True: 2, False: 0]
  ------------------
  475|      2|	R_xlen_t len = XLENGTH(x);
  476|      2|	if (len > 0) {
  ------------------
  |  Branch (476:6): [True: 2, False: 0]
  ------------------
  477|      2|	    int *px = INTEGER(x);
  478|      2|	    int last = px[0];
  479|      2|	    if (last != NA_INTEGER) {
  ------------------
  |  |   56|      2|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (479:10): [True: 2, False: 0]
  ------------------
  480|      2|		for (R_xlen_t i = 1; i < len; i++) {
  ------------------
  |  Branch (480:24): [True: 0, False: 2]
  ------------------
  481|      0|		    int next = px[i];
  482|      0|		    if (next < last || next == NA_INTEGER)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (482:11): [True: 0, False: 0]
  |  Branch (482:26): [True: 0, False: 0]
  ------------------
  483|      0|			return false;
  484|      0|		    else last = next;
  485|      0|		}
  486|      2|		return true;
  487|      2|	    }
  488|      2|	}
  489|      2|    }
  490|       |
  491|      0|    return done;
  492|      2|}
sort.c:ssort2:
  611|      8|{
  612|      8|    SEXP v;
  613|      8|    R_xlen_t i, j, h, t;
  614|       |
  615|      8|    if (n < 2) error("'n >= 2' is required");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (615:9): [True: 0, False: 8]
  ------------------
  616|    136|    for (t = 0; incs[t] > n; t++);
  ------------------
  |  Branch (616:17): [True: 128, False: 8]
  ------------------
  617|     40|    for (h = incs[t]; t < NI; h = incs[++t])
  ------------------
  |  |  529|     40|#define NI 20
  ------------------
  |  Branch (617:23): [True: 32, False: 8]
  ------------------
  618|  20.1k|	for (i = h; i < n; i++) {
  ------------------
  |  Branch (618:14): [True: 20.1k, False: 32]
  ------------------
  619|  20.1k|	    v = x[i];
  620|  20.1k|	    j = i;
  621|  20.1k|	    PROTECT(v);
  ------------------
  |  |  357|  20.1k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  622|  20.1k|	    if(decreasing)
  ------------------
  |  Branch (622:9): [True: 0, False: 20.1k]
  ------------------
  623|      0|		while (j >= h && scmp(x[j - h], v, true) < 0)
  ------------------
  |  Branch (623:10): [True: 0, False: 0]
  |  Branch (623:20): [True: 0, False: 0]
  ------------------
  624|      0|		{ x[j] = x[j - h]; j -= h; }
  625|  20.1k|	    else
  626|  65.4k|		while (j >= h && scmp(x[j - h], v, true) > 0)
  ------------------
  |  Branch (626:10): [True: 63.4k, False: 2.03k]
  |  Branch (626:20): [True: 45.3k, False: 18.1k]
  ------------------
  627|  45.3k|		{ x[j] = x[j - h]; j -= h; }
  628|  20.1k|	    x[j] = v;
  629|  20.1k|	    UNPROTECT(1); /* v */
  ------------------
  |  |  358|  20.1k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  630|  20.1k|	}
  631|      8|}

do_parse:
  206|     12|{
  207|     12|    checkArity(op, args);
  ------------------
  |  | 1788|     12|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  208|     12|    if(!inherits(CAR(args), "connection"))
  ------------------
  |  |  933|     12|#define inherits		Rf_inherits
  ------------------
  |  Branch (208:8): [True: 0, False: 12]
  ------------------
  209|      0|	error(_("'file' must be a character string or connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'file' must be a character string or connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  210|     12|    R_ParseError = 0;
  211|     12|    R_ParseErrorMsg[0] = '\0';
  212|       |
  213|     12|    int ifile = asInteger(CAR(args));                   args = CDR(args);
  ------------------
  |  |  885|     12|#define asInteger		Rf_asInteger
  ------------------
  214|     12|    Rconnection con = getConnection(ifile);
  215|     12|    bool wasopen = con->isopen;
  216|     12|    int num = asInteger(CAR(args));			args = CDR(args);
  ------------------
  |  |  885|     12|#define asInteger		Rf_asInteger
  ------------------
  217|     12|    if (num == 0)
  ------------------
  |  Branch (217:9): [True: 0, False: 12]
  ------------------
  218|      0|	return(allocVector(EXPRSXP, 0));
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	return(allocVector(EXPRSXP, 0));
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  219|       |
  220|     12|    SEXP text = PROTECT(coerceVector(CAR(args), STRSXP));
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
  221|     12|    if(length(CAR(args)) && !length(text))
  ------------------
  |  |  987|     24|#define length(x)		Rf_length(x)
  |  |  ------------------
  |  |  |  Branch (987:20): [True: 0, False: 12]
  |  |  ------------------
  ------------------
                  if(length(CAR(args)) && !length(text))
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (221:29): [True: 0, False: 0]
  ------------------
  222|      0|	error(_("coercion of 'text' to character was unsuccessful"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("coercion of 'text' to character was unsuccessful"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  223|     12|    args = CDR(args);
  224|     12|    SEXP prompt = CAR(args);				args = CDR(args);
  225|     12|    SEXP source = CAR(args);				args = CDR(args);
  226|     12|    if(!isString(CAR(args)) || LENGTH(CAR(args)) != 1)
  ------------------
  |  |  966|     12|#define isString		Rf_isString
  ------------------
  |  Branch (226:8): [True: 0, False: 12]
  |  Branch (226:32): [True: 0, False: 12]
  ------------------
  227|      0|	error(_("invalid '%s' value"), "encoding");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' value"), "encoding");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  228|     12|    const char *encoding = CHAR(STRING_ELT(CAR(args), 0)); /* ASCII */
  ------------------
  |  |  203|     12|#define CHAR(x) R_CHAR(x)
  ------------------
  229|       |
  230|     12|    parse_cleanup_info pci;
  231|     12|    pci.con = NULL;
  232|     12|    pci.old_latin1 = known_to_be_latin1;
  233|     12|    pci.old_utf8 = known_to_be_utf8;
  234|     12|    RCNTXT cntxt;
  235|       |    /* set up context to recover known_to_be_* and to close connection on
  236|       |       error if opened by do_parse */
  237|     12|    begincontext(&cntxt, CTXT_CCODE, R_NilValue, R_BaseEnv, R_BaseEnv,
  ------------------
  |  | 1864|     12|# define begincontext		Rf_begincontext
  ------------------
  238|     12|		 R_NilValue, R_NilValue);
  239|     12|    cntxt.cend = &parse_cleanup;
  240|     12|    cntxt.cenddata = &pci;
  241|       |
  242|     12|    known_to_be_latin1 = known_to_be_utf8 = false;
  243|     12|    bool allKnown = true;
  244|       |    /* allow 'encoding' to override declaration on 'text'. */
  245|     12|    if(streql(encoding, "latin1")) {
  ------------------
  |  | 1498|     12|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 12]
  |  |  ------------------
  ------------------
  246|      0|	if (!mbcslocale) {
  ------------------
  |  Branch (246:6): [True: 0, False: 0]
  ------------------
  247|      0|	    known_to_be_latin1 = true;
  248|      0|	    allKnown = false;
  249|      0|	} else
  250|      0|	    warning(_("argument encoding=\"latin1\" is ignored in MBCS locales"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("argument encoding=\"latin1\" is ignored in MBCS locales"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  251|     12|    } else if(streql(encoding, "UTF-8"))  {
  ------------------
  |  | 1498|     12|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 12]
  |  |  ------------------
  ------------------
  252|      0|	if (!mbcslocale || utf8locale) {
  ------------------
  |  Branch (252:6): [True: 0, False: 0]
  |  Branch (252:21): [True: 0, False: 0]
  ------------------
  253|      0|	    known_to_be_utf8 = true;
  254|      0|	    allKnown = false;
  255|      0|	} else
  256|       |	    /* the input may be invalid or not parseable when interpreted as
  257|       |	       in different multi-byte encoding; related to PR#16819 */
  258|      0|	    warning(_("argument encoding=\"UTF-8\" is ignored in MBCS locales"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("argument encoding=\"UTF-8\" is ignored in MBCS locales"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  259|     12|    } else if(!streql(encoding, "unknown") && !streql(encoding, "native.enc"))
  ------------------
  |  | 1498|     24|#define streql(s, t)	(!strcmp((s), (t)))
  ------------------
                  } else if(!streql(encoding, "unknown") && !streql(encoding, "native.enc"))
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  ------------------
  |  Branch (259:15): [True: 0, False: 12]
  |  Branch (259:47): [True: 0, False: 0]
  ------------------
  260|      0|	warning(_("argument '%s = \"%s\"' will be ignored"), "encoding", encoding);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("argument '%s = \"%s\"' will be ignored"), "encoding", encoding);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  261|       |
  262|     12|    if (prompt == R_NilValue)
  ------------------
  |  Branch (262:9): [True: 0, False: 12]
  ------------------
  263|      0|	PROTECT(prompt);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  264|     12|    else
  265|     12|	PROTECT(prompt = coerceVector(prompt, STRSXP));
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
  266|       |
  267|     12|    ParseStatus status;
  268|     12|    SEXP s;
  269|     12|    if (length(text) > 0) {
  ------------------
  |  |  987|     12|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (269:9): [True: 0, False: 12]
  ------------------
  270|       |	/* If 'text' has known encoding then we can be sure it will be
  271|       |	   correctly re-encoded to the current encoding by
  272|       |	   translateChar in the parser and so could mark the result in
  273|       |	   a Latin-1 or UTF-8 locale.
  274|       |
  275|       |	   A small complication is that different elements could have
  276|       |	   different encodings, but all that matters is that all
  277|       |	   non-ASCII elements have known encoding.
  278|       |	*/
  279|      0|	if(allKnown)
  ------------------
  |  Branch (279:5): [True: 0, False: 0]
  ------------------
  280|      0|	  for(int i = 0; i < length(text); i++)
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (280:19): [True: 0, False: 0]
  ------------------
  281|      0|	    if(!ENC_KNOWN(STRING_ELT(text, i)) &&
  ------------------
  |  Branch (281:9): [True: 0, False: 0]
  ------------------
  282|      0|	       ! IS_ASCII(STRING_ELT(text, i))) {
  ------------------
  |  Branch (282:9): [True: 0, False: 0]
  ------------------
  283|      0|		allKnown = false;
  284|      0|		break;
  285|      0|	    }
  286|      0|	if(allKnown) {
  ------------------
  |  Branch (286:5): [True: 0, False: 0]
  ------------------
  287|      0|	    known_to_be_latin1 = pci.old_latin1;
  288|      0|	    known_to_be_utf8 = pci.old_utf8;
  289|      0|	}
  290|      0|	if (num == NA_INTEGER) num = -1;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (290:6): [True: 0, False: 0]
  ------------------
  291|      0|	s = R_ParseVector(text, num, &status, source);
  292|      0|    }
  293|     12|    else if (ifile >= 3) {/* file != "" */
  ------------------
  |  Branch (293:14): [True: 12, False: 0]
  ------------------
  294|     12|	if (num == NA_INTEGER) num = -1;
  ------------------
  |  |   56|     12|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (294:6): [True: 0, False: 12]
  ------------------
  295|     12|	if(!wasopen) {
  ------------------
  |  Branch (295:5): [True: 0, False: 12]
  ------------------
  296|      0|	    if(!con->open(con)) error(_("cannot open the connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    if(!con->open(con)) error(_("cannot open the connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (296:9): [True: 0, False: 0]
  ------------------
  297|      0|	    pci.con = con; /* close the connection on error */
  298|      0|	}
  299|     12|	if(!con->canread) error(_("cannot read from this connection"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	if(!con->canread) error(_("cannot read from this connection"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (299:5): [True: 0, False: 12]
  ------------------
  300|     12|	s = R_ParseConn(con, num, &status, source);
  301|     12|	if(!wasopen) {
  ------------------
  |  Branch (301:5): [True: 0, False: 12]
  ------------------
  302|      0|	    PROTECT(s);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  303|      0|	    pci.con = NULL;
  304|      0|	    con->close(con);
  305|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  306|      0|	}
  307|     12|    }
  308|      0|    else {
  309|      0|	if (num == NA_INTEGER) num = 1;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (309:6): [True: 0, False: 0]
  ------------------
  310|      0|	s = R_ParseBuffer(&R_ConsoleIob, num, &status, prompt, source);
  311|      0|    }
  312|     12|    if (status != PARSE_OK) parseError(call, R_ParseError);
  ------------------
  |  Branch (312:9): [True: 0, False: 12]
  ------------------
  313|       |
  314|     12|    known_to_be_latin1 = pci.old_latin1;
  315|     12|    known_to_be_utf8 = pci.old_utf8;
  316|     12|    PROTECT(s);
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
  317|     12|    endcontext(&cntxt);
  ------------------
  |  | 1895|     12|# define endcontext		Rf_endcontext
  ------------------
  318|     12|    UNPROTECT(3);
  ------------------
  |  |  358|     12|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  319|     12|    return s;
  320|     12|}

do_sprintf:
  124|     68|{
  125|     68|    int i, nargs, cnt, v, thislen, nfmt, nprotect = 0;
  126|       |    /* fmt2 is a copy of fmt with '*' expanded.
  127|       |       bit will hold numeric formats and %<w>s, so be quite small. */
  128|     68|    char fmt[MAXLINE+1], fmt2[MAXLINE+10], *fmtp, bit[MAXLINE+1],
  129|     68|	*outputString;
  130|     68|    const char *formatString;
  131|     68|    size_t n, cur, chunk;
  132|       |
  133|     68|    SEXP format, _this, a[MAXNARGS], ans /* -Wall */ = R_NilValue;
  134|     68|    int ns, maxlen, lens[MAXNARGS], nthis, nstar, star_arg = 0, nunused;
  135|     68|    bool used[MAXNARGS];
  136|     68|    static R_StringBuffer outbuff = {NULL, 0, MAXELTSIZE};
  ------------------
  |  |   85|     68|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
  137|     68|    bool has_star, use_UTF8;
  138|       |
  139|     68|#define _my_sprintf(_X_)						\
  140|     68|    {									\
  141|     68|	boundspec(fmtp);						\
  142|     68|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  143|     68|	if (nc > MAXLINE)						\
  144|     68|	    error(_("required resulting string length %d is greater than maximal %d"), \
  145|     68|		  nc, MAXLINE);						\
  146|     68|    }
  147|       |
  148|     68|    nargs = length(args);
  ------------------
  |  |  987|     68|#define length(x)		Rf_length(x)
  ------------------
  149|       |    /* grab the format string */
  150|     68|    format = CAR(args);
  151|     68|    if (!isString(format))
  ------------------
  |  |  966|     68|#define isString		Rf_isString
  ------------------
  |  Branch (151:9): [True: 0, False: 68]
  ------------------
  152|      0|	error(_("'fmt' is not a character vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'fmt' is not a character vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  153|     68|    nfmt = length(format);
  ------------------
  |  |  987|     68|#define length(x)		Rf_length(x)
  ------------------
  154|     68|    if (nfmt == 0) return allocVector(STRSXP, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
                  if (nfmt == 0) return allocVector(STRSXP, 0);
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (154:9): [True: 0, False: 68]
  ------------------
  155|     68|    args = CDR(args); nargs--;
  156|     68|    if(nargs >= MAXNARGS)
  ------------------
  |  |   35|     68|#define MAXNARGS 100
  ------------------
  |  Branch (156:8): [True: 0, False: 68]
  ------------------
  157|      0|	error(_("only %d arguments are allowed"), MAXNARGS);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("only %d arguments are allowed"), MAXNARGS);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              	error(_("only %d arguments are allowed"), MAXNARGS);
  ------------------
  |  |   35|      0|#define MAXNARGS 100
  ------------------
  158|       |
  159|       |    /* record the args for possible coercion and later re-ordering */
  160|    136|    for(i = 0; i < nargs; i++, args = CDR(args)) {
  ------------------
  |  Branch (160:16): [True: 68, False: 68]
  ------------------
  161|     68|	SEXPTYPE t_ai;
  162|     68|	a[i] = CAR(args);
  163|     68|	used[i] = false;
  164|     68|	if((t_ai = TYPEOF(a[i])) == LANGSXP || t_ai == SYMSXP) /* << maybe add more .. */
  ------------------
  |  |  117|    136|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
              	if((t_ai = TYPEOF(a[i])) == LANGSXP || t_ai == SYMSXP) /* << maybe add more .. */
  ------------------
  |  |  112|     68|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (164:5): [True: 0, False: 68]
  |  Branch (164:41): [True: 0, False: 68]
  ------------------
  165|      0|	    error(_("invalid type of argument[%d]: '%s'"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid type of argument[%d]: '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  166|      0|		  i+1, CHAR(type2str(t_ai)));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  167|     68|	lens[i] = length(a[i]);
  ------------------
  |  |  987|     68|#define length(x)		Rf_length(x)
  ------------------
  168|     68|	if(lens[i] == 0) return allocVector(STRSXP, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	if(lens[i] == 0) return allocVector(STRSXP, 0);
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (168:5): [True: 0, False: 68]
  ------------------
  169|     68|    }
  170|       |
  171|     68|#define CHECK_maxlen							\
  172|     68|    maxlen = nfmt;							\
  173|     68|    for(i = 0; i < nargs; i++)						\
  174|     68|	if(maxlen < lens[i]) maxlen = lens[i];				\
  175|     68|    if(maxlen % nfmt)							\
  176|     68|	error(_("arguments cannot be recycled to the same length"));	\
  177|     68|    for(i = 0; i < nargs; i++)						\
  178|     68|	if(maxlen % lens[i])						\
  179|     68|	    error(_("arguments cannot be recycled to the same length"))
  180|       |
  181|     68|    CHECK_maxlen;
  ------------------
  |  |  172|     68|    maxlen = nfmt;							\
  |  |  173|    136|    for(i = 0; i < nargs; i++)						\
  |  |  ------------------
  |  |  |  Branch (173:16): [True: 68, False: 68]
  |  |  ------------------
  |  |  174|     68|	if(maxlen < lens[i]) maxlen = lens[i];				\
  |  |  ------------------
  |  |  |  Branch (174:5): [True: 0, False: 68]
  |  |  ------------------
  |  |  175|     68|    if(maxlen % nfmt)							\
  |  |  ------------------
  |  |  |  Branch (175:8): [True: 0, False: 68]
  |  |  ------------------
  |  |  176|     68|	error(_("arguments cannot be recycled to the same length"));	\
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("arguments cannot be recycled to the same length"));	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  177|    136|    for(i = 0; i < nargs; i++)						\
  |  |  ------------------
  |  |  |  Branch (177:16): [True: 68, False: 68]
  |  |  ------------------
  |  |  178|     68|	if(maxlen % lens[i])						\
  |  |  ------------------
  |  |  |  Branch (178:5): [True: 0, False: 68]
  |  |  ------------------
  |  |  179|     68|	    error(_("arguments cannot be recycled to the same length"))
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("arguments cannot be recycled to the same length"))
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  ------------------
  182|       |
  183|     68|    outputString = R_AllocStringBuffer(0, &outbuff);
  184|       |
  185|       |    /* We do the format analysis a row at a time */
  186|    136|    for(ns = 0; ns < maxlen; ns++) {
  ------------------
  |  Branch (186:17): [True: 68, False: 68]
  ------------------
  187|     68|	outputString[0] = '\0';
  188|     68|	use_UTF8 = getCharCE(STRING_ELT(format, ns % nfmt)) == CE_UTF8;
  ------------------
  |  |  925|     68|#define getCharCE		Rf_getCharCE
  ------------------
  189|     68|	if (!use_UTF8) {
  ------------------
  |  Branch (189:6): [True: 68, False: 0]
  ------------------
  190|    136|	    for(i = 0; i < nargs; i++) {
  ------------------
  |  Branch (190:17): [True: 68, False: 68]
  ------------------
  191|     68|		if (!isString(a[i])) continue;
  ------------------
  |  |  966|     68|#define isString		Rf_isString
  ------------------
  |  Branch (191:7): [True: 0, False: 68]
  ------------------
  192|     68|		if (getCharCE(STRING_ELT(a[i], ns % lens[i])) == CE_UTF8) {
  ------------------
  |  |  925|     68|#define getCharCE		Rf_getCharCE
  ------------------
  |  Branch (192:7): [True: 0, False: 68]
  ------------------
  193|      0|		    use_UTF8 = true; break;
  194|      0|		}
  195|     68|	    }
  196|     68|	}
  197|       |
  198|     68|	formatString = TRANSLATE_CHAR(format, ns % nfmt);
  ------------------
  |  |  119|     68|   ((use_UTF8) ? translateCharUTF8(STRING_ELT(_STR_, _i_))  \
  |  |  ------------------
  |  |  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  |  |  ------------------
  |  |  |  Branch (119:5): [True: 0, False: 68]
  |  |  ------------------
  |  |  120|     68|    : translateChar(STRING_ELT(_STR_, _i_)))
  |  |  ------------------
  |  |  |  | 1037|     68|#define translateChar		Rf_translateChar
  |  |  ------------------
  ------------------
  199|     68|	n = strlen(formatString);
  200|     68|	if (n > MAXLINE)
  ------------------
  |  |   34|     68|#define MAXLINE MAXELTSIZE
  |  |  ------------------
  |  |  |  |   85|     68|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  ------------------
  ------------------
  |  Branch (200:6): [True: 0, False: 68]
  ------------------
  201|      0|	    error(_("'fmt' length exceeds maximal format length %d"), MAXLINE);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("'fmt' length exceeds maximal format length %d"), MAXLINE);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              	    error(_("'fmt' length exceeds maximal format length %d"), MAXLINE);
  ------------------
  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  ------------------
  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  ------------------
  ------------------
  202|       |	/* process the format string */
  203|    244|	for (cur = 0, cnt = 0; cur < n; cur += chunk) {
  ------------------
  |  Branch (203:25): [True: 176, False: 68]
  ------------------
  204|    176|	    const char *curFormat = formatString + cur, *ss;
  205|    176|	    char *starc;
  206|    176|	    ss = NULL;
  207|    176|	    if (formatString[cur] == '%') { /* handle special format command */
  ------------------
  |  Branch (207:10): [True: 68, False: 108]
  ------------------
  208|       |
  209|     68|		if (cur < n - 1 && formatString[cur + 1] == '%') {
  ------------------
  |  Branch (209:7): [True: 68, False: 0]
  |  Branch (209:22): [True: 0, False: 68]
  ------------------
  210|       |		    /* take care of %% in the format */
  211|      0|		    chunk = 2;
  212|      0|		    strcpy(bit, "%");
  213|      0|		}
  214|     68|		else {
  215|       |		    /* recognise selected types from Table B-1 of K&R */
  216|       |		    /* NB: we deal with "%%" in branch above. */
  217|       |		    /* This is MBCS-OK, as we are in a format spec */
  218|     68|		    chunk = strcspn(curFormat + 1, "diosfeEgGxXaA") + 2;
  219|     68|		    if (cur + chunk > n)
  ------------------
  |  Branch (219:11): [True: 0, False: 68]
  ------------------
  220|      0|			error(_("unrecognised format specification '%s'"), curFormat);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              			error(_("unrecognised format specification '%s'"), curFormat);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  221|       |
  222|     68|		    strncpy(fmt, curFormat, chunk);
  223|     68|		    fmt[chunk] = '\0';
  224|       |
  225|     68|		    nthis = -1;
  226|       |		    /* now look for %n$ or %nn$ form */
  227|     68|		    if (strlen(fmt) > 3 && fmt[1] >= '1' && fmt[1] <= '9') {
  ------------------
  |  Branch (227:11): [True: 0, False: 68]
  |  Branch (227:30): [True: 0, False: 0]
  |  Branch (227:47): [True: 0, False: 0]
  ------------------
  228|      0|			v = fmt[1] - '0';
  229|      0|			if(fmt[2] == '$') {
  ------------------
  |  Branch (229:7): [True: 0, False: 0]
  ------------------
  230|      0|			    if(v > nargs)
  ------------------
  |  Branch (230:11): [True: 0, False: 0]
  ------------------
  231|      0|				error(_("reference to non-existent argument %d"), v);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              				error(_("reference to non-existent argument %d"), v);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  232|      0|			    nthis = v-1;
  233|      0|			    memmove(fmt+1, fmt+3, strlen(fmt)-2);
  234|      0|			} else if(fmt[2] >= '0' && fmt[2] <= '9' && fmt[3] == '$') {
  ------------------
  |  Branch (234:14): [True: 0, False: 0]
  |  Branch (234:31): [True: 0, False: 0]
  |  Branch (234:48): [True: 0, False: 0]
  ------------------
  235|      0|			    v = 10*v + fmt[2] - '0';
  236|      0|			    if(v > nargs)
  ------------------
  |  Branch (236:11): [True: 0, False: 0]
  ------------------
  237|      0|				error(_("reference to non-existent argument %d"), v);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              				error(_("reference to non-existent argument %d"), v);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  238|      0|			    nthis = v-1;
  239|      0|			    memmove(fmt+1, fmt+4, strlen(fmt)-3);
  240|      0|			}
  241|      0|		    }
  242|       |
  243|     68|		    starc = Rf_strchr(fmt, '*');
  244|     68|		    if (starc) { /* handle  *  format if present */
  ------------------
  |  Branch (244:11): [True: 0, False: 68]
  ------------------
  245|      0|			nstar = -1;
  246|      0|			if (strlen(starc) > 3 && starc[1] >= '1' && starc[1] <= '9') {
  ------------------
  |  Branch (246:8): [True: 0, False: 0]
  |  Branch (246:29): [True: 0, False: 0]
  |  Branch (246:48): [True: 0, False: 0]
  ------------------
  247|      0|			    v = starc[1] - '0';
  248|      0|			    if(starc[2] == '$') {
  ------------------
  |  Branch (248:11): [True: 0, False: 0]
  ------------------
  249|      0|				if(v > nargs)
  ------------------
  |  Branch (249:8): [True: 0, False: 0]
  ------------------
  250|      0|				    error(_("reference to non-existent argument %d"), v);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              				    error(_("reference to non-existent argument %d"), v);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  251|      0|				nstar = v-1;
  252|      0|				memmove(starc+1, starc+3, strlen(starc)-2);
  253|      0|			    } else if(starc[2] >= '0' && starc[2] <= '9'
  ------------------
  |  Branch (253:18): [True: 0, False: 0]
  |  Branch (253:37): [True: 0, False: 0]
  ------------------
  254|      0|				      && starc[3] == '$') {
  ------------------
  |  Branch (254:14): [True: 0, False: 0]
  ------------------
  255|      0|				v = 10*v + starc[2] - '0';
  256|      0|				if(v > nargs)
  ------------------
  |  Branch (256:8): [True: 0, False: 0]
  ------------------
  257|      0|				    error(_("reference to non-existent argument %d"), v);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              				    error(_("reference to non-existent argument %d"), v);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  258|      0|				nstar = v-1;
  259|      0|				memmove(starc+1, starc+4, strlen(starc)-3);
  260|      0|			    }
  261|      0|			}
  262|       |
  263|      0|			if(nstar < 0) {
  ------------------
  |  Branch (263:7): [True: 0, False: 0]
  ------------------
  264|      0|			    if (cnt >= nargs) error(_("too few arguments"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              			    if (cnt >= nargs) error(_("too few arguments"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (264:12): [True: 0, False: 0]
  ------------------
  265|      0|			    nstar = cnt++;
  266|      0|			}
  267|       |
  268|      0|			if (Rf_strchr(starc+1, '*'))
  ------------------
  |  Branch (268:8): [True: 0, False: 0]
  ------------------
  269|      0|			    error(_("at most one asterisk '*' is supported in each conversion specification"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              			    error(_("at most one asterisk '*' is supported in each conversion specification"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  270|       |
  271|      0|			_this = a[nstar];
  272|      0|			used[nstar] = true;
  273|      0|			if(ns == 0 && TYPEOF(_this) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (273:7): [True: 0, False: 0]
  |  Branch (273:18): [True: 0, False: 0]
  ------------------
  274|      0|			    _this = coerceVector(_this, INTSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              			    _this = coerceVector(_this, INTSXP);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  275|      0|			    PROTECT(a[nstar] = _this);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  276|      0|			    nprotect++;
  277|      0|			}
  278|      0|			if(TYPEOF(_this) != INTSXP || LENGTH(_this)<1 ||
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (278:7): [True: 0, False: 0]
  |  Branch (278:34): [True: 0, False: 0]
  ------------------
  279|      0|			   INTEGER(_this)[ns % LENGTH(_this)] == NA_INTEGER)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (279:7): [True: 0, False: 0]
  ------------------
  280|      0|			    error(_("argument for '*' conversion specification must be a number"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              			    error(_("argument for '*' conversion specification must be a number"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  281|      0|			star_arg = INTEGER(_this)[ns % LENGTH(_this)];
  282|      0|			has_star = true;
  283|      0|		    }
  284|     68|		    else
  285|     68|			has_star = false;
  286|       |
  287|     68|		    if (fmt[strlen(fmt) - 1] == '%') {
  ------------------
  |  Branch (287:11): [True: 0, False: 68]
  ------------------
  288|       |			/* handle % with formatting options */
  289|      0|			if (has_star)
  ------------------
  |  Branch (289:8): [True: 0, False: 0]
  ------------------
  290|      0|			    snprintf(bit, MAXLINE+1, fmt, star_arg);
  ------------------
  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  ------------------
  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  ------------------
  ------------------
  291|      0|			else
  292|      0|			    strcpy(bit, fmt);
  293|       |			/* was sprintf(..)  for which some compiler warn */
  294|     68|		    } else {
  295|     68|			bool did_this = false;
  296|     68|			if(nthis < 0) {
  ------------------
  |  Branch (296:7): [True: 68, False: 0]
  ------------------
  297|     68|			    if (cnt >= nargs) error(_("too few arguments"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              			    if (cnt >= nargs) error(_("too few arguments"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (297:12): [True: 0, False: 68]
  ------------------
  298|     68|			    nthis = cnt++;
  299|     68|			}
  300|     68|			_this = a[nthis];
  301|     68|			used[nthis] = true;
  302|     68|			if (has_star) {
  ------------------
  |  Branch (302:8): [True: 0, False: 68]
  ------------------
  303|      0|			    size_t nf; char *p, *q = fmt2;
  304|      0|			    for (p = fmt; *p; p++)
  ------------------
  |  Branch (304:22): [True: 0, False: 0]
  ------------------
  305|      0|				if (*p == '*')
  ------------------
  |  Branch (305:9): [True: 0, False: 0]
  ------------------
  306|      0|				    q += snprintf(q, sizeof(fmt2) - (q - fmt2),
  307|      0|						  "%d", star_arg);
  308|      0|				else *q++ = *p;
  309|      0|			    *q = '\0';
  310|      0|			    nf = strlen(fmt2);
  311|      0|			    if (nf > MAXLINE)
  ------------------
  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  ------------------
  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  ------------------
  ------------------
  |  Branch (311:12): [True: 0, False: 0]
  ------------------
  312|      0|				error(_("'fmt' length exceeds maximal format length %d"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              				error(_("'fmt' length exceeds maximal format length %d"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  313|      0|				      MAXLINE);
  ------------------
  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  ------------------
  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  ------------------
  ------------------
  314|      0|			    fmtp = fmt2;
  315|     68|			} else fmtp = fmt;
  316|       |
  317|     68|#define CHECK_this_length						\
  318|     68|			do {						\
  319|     68|			    PROTECT(_this);				\
  320|     68|			    thislen = length(_this);			\
  321|     68|			    if(thislen == 0)				\
  322|     68|				error(_("coercion has changed vector length to 0")); \
  323|     68|			} while (0)
  324|       |
  325|       |			/* Now let us see if some minimal coercion
  326|       |			   would be sensible, but only do so once, for ns = 0: */
  327|     68|			if(ns == 0) {
  ------------------
  |  Branch (327:7): [True: 68, False: 0]
  ------------------
  328|     68|			    SEXP tmp;
  329|     68|			    bool do_check;
  330|     68|			    switch(*findspec(fmtp)) {
  331|      0|			    case 'd':
  ------------------
  |  Branch (331:8): [True: 0, False: 68]
  ------------------
  332|      0|			    case 'i':
  ------------------
  |  Branch (332:8): [True: 0, False: 68]
  ------------------
  333|      0|			    case 'o':
  ------------------
  |  Branch (333:8): [True: 0, False: 68]
  ------------------
  334|      0|			    case 'x':
  ------------------
  |  Branch (334:8): [True: 0, False: 68]
  ------------------
  335|      0|			    case 'X':
  ------------------
  |  Branch (335:8): [True: 0, False: 68]
  ------------------
  336|      0|				if(TYPEOF(_this) == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (336:8): [True: 0, False: 0]
  ------------------
  337|       |				    // qdapTools manages to call this with NaN
  338|      0|				    bool exactlyInteger = true;
  339|      0|				    R_xlen_t i = 0;
  340|      0|				    R_xlen_t n = XLENGTH(_this);
  341|      0|				    for(i = 0; i < n; i++) {
  ------------------
  |  Branch (341:20): [True: 0, False: 0]
  ------------------
  342|      0|					double r = REAL(_this)[i];
  343|      0|					if (R_IsNA(r)) continue; // NA_REAL is ok
  ------------------
  |  Branch (343:10): [True: 0, False: 0]
  ------------------
  344|      0|					if (!R_FINITE(r) || (double)((int) r) != r) {
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (344:10): [True: 0, False: 0]
  |  Branch (344:26): [True: 0, False: 0]
  ------------------
  345|      0|					    exactlyInteger = false;
  346|      0|					    break;
  347|      0|					}
  348|      0|				    } 
  349|      0|				    if(exactlyInteger)
  ------------------
  |  Branch (349:12): [True: 0, False: 0]
  ------------------
  350|      0|					_this = coerceVector(_this, INTSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              					_this = coerceVector(_this, INTSXP);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  351|      0|				    PROTECT(a[nthis] = _this);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  352|      0|				    nprotect++;
  353|      0|				}
  354|      0|				break;
  355|      0|			    case 'a':
  ------------------
  |  Branch (355:8): [True: 0, False: 68]
  ------------------
  356|      0|			    case 'A':
  ------------------
  |  Branch (356:8): [True: 0, False: 68]
  ------------------
  357|      0|			    case 'e':
  ------------------
  |  Branch (357:8): [True: 0, False: 68]
  ------------------
  358|      0|			    case 'f':
  ------------------
  |  Branch (358:8): [True: 0, False: 68]
  ------------------
  359|      0|			    case 'g':
  ------------------
  |  Branch (359:8): [True: 0, False: 68]
  ------------------
  360|      0|			    case 'E':
  ------------------
  |  Branch (360:8): [True: 0, False: 68]
  ------------------
  361|      0|			    case 'G':
  ------------------
  |  Branch (361:8): [True: 0, False: 68]
  ------------------
  362|      0|				if(TYPEOF(_this) != REALSXP &&
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (362:8): [True: 0, False: 0]
  ------------------
  363|       |				   /* no automatic as.double(<string>) : */
  364|      0|				   TYPEOF(_this) != STRSXP) {
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (364:8): [True: 0, False: 0]
  ------------------
  365|      0|				    PROTECT(tmp = lang2(install("as.double"), _this));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  366|      0|#define COERCE_THIS_TO_A						\
  367|      0|				    _this = eval(tmp, env);		\
  368|      0|				    UNPROTECT(1);			\
  369|      0|				    PROTECT(a[nthis] = _this);		\
  370|      0|				    nprotect++;				\
  371|      0|				    did_this = true;			\
  372|      0|				    CHECK_this_length;			\
  373|      0|				    do_check = (lens[nthis] == maxlen);	\
  374|      0|				    lens[nthis] = thislen; /* may have changed! */ \
  375|      0|				    if(do_check && thislen < maxlen) {	\
  376|      0|					CHECK_maxlen;			\
  377|      0|				    }
  378|       |
  379|      0|				    COERCE_THIS_TO_A
  ------------------
  |  |  367|      0|				    _this = eval(tmp, env);		\
  |  |  ------------------
  |  |  |  |  913|      0|#define eval			Rf_eval
  |  |  ------------------
  |  |  368|      0|				    UNPROTECT(1);			\
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |  369|      0|				    PROTECT(a[nthis] = _this);		\
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  370|      0|				    nprotect++;				\
  |  |  371|      0|				    did_this = true;			\
  |  |  372|      0|				    CHECK_this_length;			\
  |  |  ------------------
  |  |  |  |  318|      0|			do {						\
  |  |  |  |  319|      0|			    PROTECT(_this);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  |  |  ------------------
  |  |  |  |  320|      0|			    thislen = length(_this);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  |  |  ------------------
  |  |  |  |  321|      0|			    if(thislen == 0)				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:11): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|      0|				error(_("coercion has changed vector length to 0")); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |               				error(_("coercion has changed vector length to 0")); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  |  |  323|      0|			} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (323:13): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  373|      0|				    do_check = (lens[nthis] == maxlen);	\
  |  |  374|      0|				    lens[nthis] = thislen; /* may have changed! */ \
  |  |  375|      0|				    if(do_check && thislen < maxlen) {	\
  |  |  ------------------
  |  |  |  Branch (375:12): [True: 0, False: 0]
  |  |  |  Branch (375:24): [True: 0, False: 0]
  |  |  ------------------
  |  |  376|      0|					CHECK_maxlen;			\
  |  |  ------------------
  |  |  |  |  172|      0|    maxlen = nfmt;							\
  |  |  |  |  173|      0|    for(i = 0; i < nargs; i++)						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (173:16): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  174|      0|	if(maxlen < lens[i]) maxlen = lens[i];				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (174:5): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  175|      0|    if(maxlen % nfmt)							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (175:8): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  176|      0|	error(_("arguments cannot be recycled to the same length"));	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |               	error(_("arguments cannot be recycled to the same length"));	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  |  |  177|      0|    for(i = 0; i < nargs; i++)						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (177:16): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  178|      0|	if(maxlen % lens[i])						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (178:5): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  179|      0|	    error(_("arguments cannot be recycled to the same length"))
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |               	    error(_("arguments cannot be recycled to the same length"))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  377|      0|				    }
  ------------------
  380|      0|				}
  381|      0|				break;
  382|     68|			    case 's':
  ------------------
  |  Branch (382:8): [True: 68, False: 0]
  ------------------
  383|     68|				if(TYPEOF(_this) != STRSXP) {
  ------------------
  |  |  126|     68|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (383:8): [True: 0, False: 68]
  ------------------
  384|       |				    /* as.character method might call sprintf() */
  385|      0|				    size_t nc = strlen(outputString);
  386|      0|				    char *z = R_Calloc(nc+1, char);
  ------------------
  |  |   55|      0|#define R_Calloc(n, t)   (t *) R_chk_calloc( (R_SIZE_T) (n), sizeof(t) )
  ------------------
  387|      0|				    strcpy(z, outputString);
  388|      0|				    PROTECT(tmp = lang2(R_AsCharacterSymbol, _this));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  389|       |
  390|      0|				    COERCE_THIS_TO_A
  ------------------
  |  |  367|      0|				    _this = eval(tmp, env);		\
  |  |  ------------------
  |  |  |  |  913|      0|#define eval			Rf_eval
  |  |  ------------------
  |  |  368|      0|				    UNPROTECT(1);			\
  |  |  ------------------
  |  |  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  |  |  ------------------
  |  |  369|      0|				    PROTECT(a[nthis] = _this);		\
  |  |  ------------------
  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  370|      0|				    nprotect++;				\
  |  |  371|      0|				    did_this = true;			\
  |  |  372|      0|				    CHECK_this_length;			\
  |  |  ------------------
  |  |  |  |  318|      0|			do {						\
  |  |  |  |  319|      0|			    PROTECT(_this);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  |  |  |  |  ------------------
  |  |  |  |  320|      0|			    thislen = length(_this);			\
  |  |  |  |  ------------------
  |  |  |  |  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  |  |  ------------------
  |  |  |  |  321|      0|			    if(thislen == 0)				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:11): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|      0|				error(_("coercion has changed vector length to 0")); \
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |               				error(_("coercion has changed vector length to 0")); \
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  |  |  323|      0|			} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (323:13): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  373|      0|				    do_check = (lens[nthis] == maxlen);	\
  |  |  374|      0|				    lens[nthis] = thislen; /* may have changed! */ \
  |  |  375|      0|				    if(do_check && thislen < maxlen) {	\
  |  |  ------------------
  |  |  |  Branch (375:12): [True: 0, False: 0]
  |  |  |  Branch (375:24): [True: 0, False: 0]
  |  |  ------------------
  |  |  376|      0|					CHECK_maxlen;			\
  |  |  ------------------
  |  |  |  |  172|      0|    maxlen = nfmt;							\
  |  |  |  |  173|      0|    for(i = 0; i < nargs; i++)						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (173:16): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  174|      0|	if(maxlen < lens[i]) maxlen = lens[i];				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (174:5): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  175|      0|    if(maxlen % nfmt)							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (175:8): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  176|      0|	error(_("arguments cannot be recycled to the same length"));	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |               	error(_("arguments cannot be recycled to the same length"));	\
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  |  |  177|      0|    for(i = 0; i < nargs; i++)						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (177:16): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  178|      0|	if(maxlen % lens[i])						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (178:5): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  179|      0|	    error(_("arguments cannot be recycled to the same length"))
  |  |  |  |  ------------------
  |  |  |  |  |  |   88|      0|#define error Rf_error
  |  |  |  |  ------------------
  |  |  |  |               	    error(_("arguments cannot be recycled to the same length"))
  |  |  |  |  ------------------
  |  |  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  377|      0|				    }
  ------------------
  391|      0|				    outputString = R_AllocStringBuffer(nc + 1,
  392|      0|				                                       &outbuff);
  393|      0|				    strcpy(outputString, z);
  394|      0|				    R_Free(z);
  ------------------
  |  |   57|      0|#define R_Free(p)      (R_chk_free( (void *)(p) ), (p) = NULL)
  ------------------
  395|      0|				}
  396|     68|				break;
  397|      0|			    default:
  ------------------
  |  Branch (397:8): [True: 0, False: 68]
  ------------------
  398|      0|				break;
  399|     68|			    }
  400|     68|			} /* ns == 0 (first-time only) */
  401|       |
  402|     68|			if(!did_this)
  ------------------
  |  Branch (402:7): [True: 68, False: 0]
  ------------------
  403|     68|			    CHECK_this_length;
  ------------------
  |  |  318|     68|			do {						\
  |  |  319|     68|			    PROTECT(_this);				\
  |  |  ------------------
  |  |  |  |  357|     68|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  320|     68|			    thislen = length(_this);			\
  |  |  ------------------
  |  |  |  |  987|     68|#define length(x)		Rf_length(x)
  |  |  ------------------
  |  |  321|     68|			    if(thislen == 0)				\
  |  |  ------------------
  |  |  |  Branch (321:11): [True: 0, False: 68]
  |  |  ------------------
  |  |  322|     68|				error(_("coercion has changed vector length to 0")); \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               				error(_("coercion has changed vector length to 0")); \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  323|     68|			} while (0)
  |  |  ------------------
  |  |  |  Branch (323:13): [Folded, False: 68]
  |  |  ------------------
  ------------------
  404|       |
  405|     68|			switch(TYPEOF(_this)) {
  406|      0|			case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (406:4): [True: 0, False: 68]
  ------------------
  407|      0|			    {
  408|      0|				int x = LOGICAL(_this)[ns % thislen];
  409|      0|				if (checkfmt(fmtp, "di"))
  ------------------
  |  Branch (409:9): [True: 0, False: 0]
  ------------------
  410|      0|				    error(_("invalid format '%s'; %s"), fmtp,
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              				    error(_("invalid format '%s'; %s"), fmtp,
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  411|      0|					  _("use format %d or %i for logical objects"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  412|      0|				if (x == NA_LOGICAL) {
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (412:9): [True: 0, False: 0]
  ------------------
  413|      0|				    fmtp[strlen(fmtp)-1] = 's';
  414|      0|				    _my_sprintf("NA")
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  415|      0|				} else {
  416|      0|				    _my_sprintf(x)
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  417|      0|				}
  418|      0|				break;
  419|      0|			    }
  420|      0|			case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (420:4): [True: 0, False: 68]
  ------------------
  421|      0|			    {
  422|      0|				int x = INTEGER(_this)[ns % thislen];
  423|      0|				if (checkfmt(fmtp, "dioxX"))
  ------------------
  |  Branch (423:9): [True: 0, False: 0]
  ------------------
  424|      0|				    error(_("invalid format '%s'; %s"), fmtp,
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              				    error(_("invalid format '%s'; %s"), fmtp,
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  425|      0|					  _("use format %d, %i, %o, %x or %X for integer objects"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  426|      0|				if (x == NA_INTEGER) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (426:9): [True: 0, False: 0]
  ------------------
  427|      0|				    fmtp[strlen(fmtp)-1] = 's';
  428|      0|				    _my_sprintf("NA")
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  429|      0|				} else {
  430|      0|				    _my_sprintf(x)
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  431|      0|				}
  432|      0|				break;
  433|      0|			    }
  434|      0|			case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (434:4): [True: 0, False: 68]
  ------------------
  435|      0|			    {
  436|      0|				double x = REAL(_this)[ns % thislen];
  437|      0|				if (checkfmt(fmtp, "aAfeEgG"))
  ------------------
  |  Branch (437:9): [True: 0, False: 0]
  ------------------
  438|      0|				    error(_("invalid format '%s'; %s"), fmtp,
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              				    error(_("invalid format '%s'; %s"), fmtp,
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  439|      0|					  _("use format %f, %e, %g or %a for numeric objects"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  440|      0|				if (R_FINITE(x)) {
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (440:9): [True: 0, False: 0]
  ------------------
  441|      0|				    _my_sprintf(x)
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  442|      0|				} else {
  443|      0|				    char *p = Rf_strchr(fmtp, '.');
  444|      0|				    if (p) {
  ------------------
  |  Branch (444:13): [True: 0, False: 0]
  ------------------
  445|      0|					*p++ = 's'; *p ='\0';
  446|      0|				    } else
  447|      0|					fmtp[strlen(fmtp)-1] = 's';
  448|      0|				    if (ISNA(x)) {
  ------------------
  |  |   64|      0|#define ISNA(x)	       R_IsNA(x)
  |  |  ------------------
  |  |  |  Branch (64:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  449|      0|					if (strcspn(fmtp, " ") < strlen(fmtp))
  ------------------
  |  Branch (449:10): [True: 0, False: 0]
  ------------------
  450|      0|					    _my_sprintf(" NA")
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  451|      0|					else
  452|      0|					    _my_sprintf("NA")
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  453|      0|				    } else if (ISNAN(x)) {
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  454|      0|					if (strcspn(fmtp, " ") < strlen(fmtp))
  ------------------
  |  Branch (454:10): [True: 0, False: 0]
  ------------------
  455|      0|					    _my_sprintf(" NaN")
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  456|      0|					else
  457|      0|					    _my_sprintf("NaN")
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  458|      0|				    } else if (x == R_PosInf) {
  ------------------
  |  Branch (458:20): [True: 0, False: 0]
  ------------------
  459|      0|					if (strcspn(fmtp, "+") < strlen(fmtp))
  ------------------
  |  Branch (459:10): [True: 0, False: 0]
  ------------------
  460|      0|					    _my_sprintf("+Inf")
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  461|      0|					else if (strcspn(fmtp, " ") < strlen(fmtp))
  ------------------
  |  Branch (461:15): [True: 0, False: 0]
  ------------------
  462|      0|					    _my_sprintf(" Inf")
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  463|      0|					else
  464|      0|					    _my_sprintf("Inf")
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  465|      0|				    } else if (x == R_NegInf)
  ------------------
  |  Branch (465:20): [True: 0, False: 0]
  ------------------
  466|      0|					_my_sprintf("-Inf")
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  467|      0|				}
  468|      0|				break;
  469|      0|			    }
  470|     68|			case STRSXP:
  ------------------
  |  |  126|     68|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (470:4): [True: 68, False: 0]
  ------------------
  471|       |			    /* NA_STRING will be printed as 'NA' */
  472|     68|			    if (checkfmt(fmtp, "s"))
  ------------------
  |  Branch (472:12): [True: 0, False: 68]
  ------------------
  473|      0|				error(_("invalid format '%s'; %s"), fmtp,
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              				error(_("invalid format '%s'; %s"), fmtp,
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  474|      0|				      _("use format %s for character objects"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  475|       |
  476|     68|			    ss = TRANSLATE_CHAR(_this, ns % thislen);
  ------------------
  |  |  119|     68|   ((use_UTF8) ? translateCharUTF8(STRING_ELT(_STR_, _i_))  \
  |  |  ------------------
  |  |  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  |  |  ------------------
  |  |  |  Branch (119:5): [True: 0, False: 68]
  |  |  ------------------
  |  |  120|     68|    : translateChar(STRING_ELT(_STR_, _i_)))
  |  |  ------------------
  |  |  |  | 1037|     68|#define translateChar		Rf_translateChar
  |  |  ------------------
  ------------------
  477|     68|			    if(fmtp[1] != 's') {
  ------------------
  |  Branch (477:11): [True: 0, False: 68]
  ------------------
  478|      0|				if(strlen(ss) > MAXLINE)
  ------------------
  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  ------------------
  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  ------------------
  ------------------
  |  Branch (478:8): [True: 0, False: 0]
  ------------------
  479|      0|				    warning(_("likely truncation of character string to %d characters"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              				    warning(_("likely truncation of character string to %d characters"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  480|      0|					    MAXLINE-1);
  ------------------
  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  ------------------
  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  ------------------
  ------------------
  481|      0|				_my_sprintf(ss)
  ------------------
  |  |  140|      0|    {									\
  |  |  141|      0|	boundspec(fmtp);						\
  |  |  142|      0|	int nc = snprintf(bit, MAXLINE+1, fmtp, _X_);			\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  143|      0|	if (nc > MAXLINE)						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (143:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  144|      0|	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	    error(_("required resulting string length %d is greater than maximal %d"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  145|      0|		  nc, MAXLINE);						\
  |  |  ------------------
  |  |  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  |  |  ------------------
  |  |  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  146|      0|    }
  ------------------
  482|      0|				bit[MAXLINE] = '\0';
  ------------------
  |  |   34|      0|#define MAXLINE MAXELTSIZE
  |  |  ------------------
  |  |  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  |  |  ------------------
  ------------------
  483|      0|				ss = NULL;
  484|      0|			    }
  485|     68|			    break;
  486|       |
  487|      0|			default:
  ------------------
  |  Branch (487:4): [True: 0, False: 68]
  ------------------
  488|      0|			    error(_("unsupported type"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              			    error(_("unsupported type"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  489|      0|			    break;
  490|     68|			}
  491|       |
  492|     68|			UNPROTECT(1);
  ------------------
  |  |  358|     68|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  493|     68|		    }
  494|     68|		}
  495|     68|	    }
  496|    108|	    else { /* not '%' : handle string part */
  497|    108|		const char *ch = use_UTF8 ? strchr(curFormat, '%')
  ------------------
  |  Branch (497:20): [True: 0, False: 108]
  ------------------
  498|       |				    /* MBCS-aware version used */
  499|    108|		                    : Rf_strchr_const(curFormat, '%');
  500|    108|		chunk = (ch) ? (size_t) (ch - curFormat) : strlen(curFormat);
  ------------------
  |  Branch (500:11): [True: 68, False: 40]
  ------------------
  501|    108|		strncpy(bit, curFormat, chunk);
  502|    108|		bit[chunk] = '\0';
  503|    108|	    }
  504|    176|	    if(ss) {
  ------------------
  |  Branch (504:9): [True: 68, False: 108]
  ------------------
  505|     68|		outputString = R_AllocStringBuffer(strlen(outputString) +
  506|     68|						   strlen(ss) + 1, &outbuff);
  507|     68|		strcat(outputString, ss);
  508|    108|	    } else {
  509|    108|		outputString = R_AllocStringBuffer(strlen(outputString) +
  510|    108|						   strlen(bit) + 1, &outbuff);
  511|    108|		strcat(outputString, bit);
  512|    108|	    }
  513|    176|	}  /* end for ( each chunk ) */
  514|       |
  515|     68|	if(ns == 0) { /* may have adjusted maxlen now ... */
  ------------------
  |  Branch (515:5): [True: 68, False: 0]
  ------------------
  516|     68|	    PROTECT(ans = allocVector(STRSXP, maxlen));
  ------------------
  |  |  357|     68|#define PROTECT(s)	Rf_protect(s)
  ------------------
  517|     68|	    nprotect++;
  518|     68|	}
  519|     68|	SET_STRING_ELT(ans, ns, mkCharCE(outputString,
  ------------------
  |  |  999|     68|#define mkCharCE		Rf_mkCharCE
  ------------------
  520|     68|					 use_UTF8 ? CE_UTF8 : CE_NATIVE));
  ------------------
  |  Branch (520:7): [True: 0, False: 68]
  ------------------
  521|     68|    } /* end for(ns ...) */
  522|       |
  523|     68|    nunused = 0;
  524|    136|    for(i = 0; i < nargs; i++)
  ------------------
  |  Branch (524:16): [True: 68, False: 68]
  ------------------
  525|     68|	if (!used[i]) nunused++;
  ------------------
  |  Branch (525:6): [True: 0, False: 68]
  ------------------
  526|     68|    if (nunused > 0) {
  ------------------
  |  Branch (526:9): [True: 0, False: 68]
  ------------------
  527|      0|	if (nfmt == 1) {
  ------------------
  |  Branch (527:6): [True: 0, False: 0]
  ------------------
  528|      0|	    const char *f = translateChar(STRING_ELT(format, 0));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  529|      0|	    if (nunused == 1)
  ------------------
  |  Branch (529:10): [True: 0, False: 0]
  ------------------
  530|      0|		warning(_("one argument not used by format '%s'"), f);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		warning(_("one argument not used by format '%s'"), f);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  531|      0|	    else if (nunused > 1)
  ------------------
  |  Branch (531:15): [True: 0, False: 0]
  ------------------
  532|      0|		warning(_("%d arguments not used by format '%s'"), nunused, f);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		warning(_("%d arguments not used by format '%s'"), nunused, f);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  533|      0|	} else {
  534|      0|	    if (nunused == 1)
  ------------------
  |  Branch (534:10): [True: 0, False: 0]
  ------------------
  535|      0|		warning(_("one argument not used by format"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		warning(_("one argument not used by format"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  536|      0|	    else if (nunused > 1)
  ------------------
  |  Branch (536:15): [True: 0, False: 0]
  ------------------
  537|      0|		warning(_("%d arguments not used by format"), nunused);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              		warning(_("%d arguments not used by format"), nunused);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  538|      0|	}
  539|      0|    }
  540|       |
  541|     68|    UNPROTECT(nprotect);
  ------------------
  |  |  358|     68|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  542|     68|    R_FreeStringBufferL(&outbuff);
  543|     68|    return ans;
  544|     68|}
sprintf.c:findspec:
   45|    136|{
   46|       |    /* This is not strict about checking where '.' is allowed.
   47|       |       It should allow  - + ' ' # 0 as flags
   48|       |       m m. .n n.m as width/precision
   49|       |    */
   50|    136|    const char *p = str;
   51|       |
   52|    136|    if(*p != '%') return p;
  ------------------
  |  Branch (52:8): [True: 0, False: 136]
  ------------------
   53|    136|    for(p++; ; p++) {
   54|    136|	if(*p == '-' || *p == '+' || *p == ' ' || *p == '#' || *p == '.' ) continue;
  ------------------
  |  Branch (54:5): [True: 0, False: 136]
  |  Branch (54:18): [True: 0, False: 136]
  |  Branch (54:31): [True: 0, False: 136]
  |  Branch (54:44): [True: 0, False: 136]
  |  Branch (54:57): [True: 0, False: 136]
  ------------------
   55|       |	/* '*' will currently have got substituted before this */
   56|    136|	if(*p == '*' || (*p >= '0' && *p <= '9')) continue;
  ------------------
  |  Branch (56:5): [True: 0, False: 136]
  |  Branch (56:19): [True: 136, False: 0]
  |  Branch (56:32): [True: 0, False: 136]
  ------------------
   57|    136|	break;
   58|    136|    }
   59|    136|    return p;
   60|    136|}
sprintf.c:checkfmt:
   65|     68|{
   66|     68|    const char *p =fmt;
   67|       |
   68|     68|    if(*p != '%') return true;
  ------------------
  |  Branch (68:8): [True: 0, False: 68]
  ------------------
   69|     68|    p = findspec(fmt);
   70|     68|    return strcspn(p, pattern) ? true : false;
  ------------------
  |  Branch (70:12): [True: 0, False: 68]
  ------------------
   71|     68|}

R_InitialData:
   64|      2|{
   65|      2|    R_RestoreGlobalEnv();
   66|      2|}
R_OpenLibraryFile:
   71|      2|{
   72|      2|    char *buf = NULL;
   73|      2|    FILE *fp = NULL;
   74|       |
   75|      2|    Rasprintf_malloc(&buf, "%s/library/base/R/%s", R_Home, file);
   76|      2|    if (buf) {
  ------------------
  |  Branch (76:9): [True: 2, False: 0]
  ------------------
   77|      2|	fp = R_fopen(buf, "r");
   78|      2|	free(buf);
   79|      2|    }
   80|      2|    return fp;
   81|      2|}
R_OpenSysInitFile:
   93|      2|{
   94|      2|    char *buf = NULL;
   95|      2|    FILE *fp = NULL;
   96|       |
   97|      2|    Rasprintf_malloc(&buf, "%s/library/base/R/Rprofile", R_Home);
   98|      2|    if (buf) {
  ------------------
  |  Branch (98:9): [True: 2, False: 0]
  ------------------
   99|      2|	fp = R_fopen(buf, "r");
  100|      2|	free(buf);
  101|      2|    }
  102|      2|    return fp;
  103|      2|}
R_OpenSiteFile:
  107|      2|{
  108|      2|    char *buf = NULL;
  109|      2|    FILE *fp = NULL;
  110|       |
  111|      2|    fp = NULL;
  112|      2|    if (LoadSiteFile) {
  ------------------
  |  Branch (112:9): [True: 0, False: 2]
  ------------------
  113|      0|	char *p = getenv("R_PROFILE");
  114|      0|	if (p) {
  ------------------
  |  Branch (114:6): [True: 0, False: 0]
  ------------------
  115|      0|	    if (*p) return R_fopen(R_ExpandFileName(p), "r");
  ------------------
  |  Branch (115:10): [True: 0, False: 0]
  ------------------
  116|      0|	    else return NULL;
  117|      0|	}
  118|      0|#ifdef R_ARCH
  119|      0|	Rasprintf_malloc(&buf, "%s/etc/%s/Rprofile.site", R_Home, R_ARCH);
  ------------------
  |  | 1085|      0|#define R_ARCH ""
  ------------------
  120|      0|	if (buf) {
  ------------------
  |  Branch (120:6): [True: 0, False: 0]
  ------------------
  121|      0|	    fp = R_fopen(buf, "r");
  122|      0|	    free(buf);
  123|      0|	    if (fp) return fp;
  ------------------
  |  Branch (123:10): [True: 0, False: 0]
  ------------------
  124|      0|	    buf = NULL;
  125|      0|	}
  126|      0|#endif
  127|      0|	Rasprintf_malloc(&buf, "%s/etc/Rprofile.site", R_Home);
  128|      0|	if (buf) {
  ------------------
  |  Branch (128:6): [True: 0, False: 0]
  ------------------
  129|      0|	    fp = R_fopen(buf, "r");
  130|      0|	    free(buf);
  131|      0|	}
  132|      0|    }
  133|      2|    return fp;
  134|      2|}
R_RestoreGlobalEnv:
  173|      2|{
  174|      2|    if(RestoreAction == SA_RESTORE) {
  ------------------
  |  Branch (174:8): [True: 0, False: 2]
  ------------------
  175|      0|	R_RestoreGlobalEnvFromFile(workspace_name, R_Quiet);
  176|      0|    }
  177|      2|}
R_DefParamsEx:
  193|      2|{
  194|      2|    Rp->RstartVersion = RstartVersion;
  195|      2|    if (RstartVersion < 0) return -1;
  ------------------
  |  Branch (195:9): [True: 0, False: 2]
  ------------------
  196|      2|    if (RstartVersion > 1) return 1;
  ------------------
  |  Branch (196:9): [True: 0, False: 2]
  ------------------
  197|       |    
  198|      2|    Rp->R_Quiet = FALSE;
  199|      2|    Rp->R_NoEcho = FALSE;
  200|      2|    Rp->R_Interactive = TRUE;
  201|      2|    Rp->R_Verbose = FALSE;
  202|      2|    Rp->RestoreAction = SA_RESTORE;
  203|      2|    Rp->SaveAction = SA_SAVEASK;
  204|      2|    Rp->LoadSiteFile = TRUE;
  205|      2|    Rp->LoadInitFile = TRUE;
  206|      2|    Rp->DebugInitFile = FALSE;
  207|      2|    Rp->vsize = R_VSIZE;
  ------------------
  |  | 1066|      2|#define	R_VSIZE		67108864L
  ------------------
  208|      2|    Rp->nsize = R_NSIZE;
  ------------------
  |  | 1063|      2|#define	R_NSIZE		350000L
  ------------------
  209|      2|    Rp->max_vsize = R_SIZE_T_MAX;
  ------------------
  |  | 1044|      2|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  210|      2|    Rp->max_nsize = R_SIZE_T_MAX;
  ------------------
  |  | 1044|      2|# define R_SIZE_T_MAX SIZE_MAX
  ------------------
  211|      2|    Rp->ppsize = R_PPSSIZE;
  ------------------
  |  | 1060|      2|#define	R_PPSSIZE	50000L
  ------------------
  212|      2|    Rp->nconnections = 128;
  213|      2|    Rp->NoRenviron = FALSE;
  214|      2|    R_SizeFromEnv(Rp);
  215|       |
  216|      2|    if (RstartVersion > 0) {
  ------------------
  |  Branch (216:9): [True: 2, False: 0]
  ------------------
  217|       |#ifdef Win32
  218|       |	Rp->EmitEmbeddedUTF8 = FALSE;
  219|       |	R_DefCallbacks(Rp, RstartVersion);
  220|       |#endif
  221|      2|    }
  222|      2|    return 0;
  223|      2|}
R_SizeFromEnv:
  238|      2|{
  239|      2|    int ierr;
  240|      2|    R_size_t value;
  241|      2|    char *p, msg[256];
  242|       |
  243|      2|    if ((p = getenv("R_MAX_VSIZE"))) {
  ------------------
  |  Branch (243:9): [True: 2, False: 0]
  ------------------
  244|      2|	value = R_Decode2Long(p, &ierr);
  245|      2|	if(ierr != 0 || value > Max_Vsize)
  ------------------
  |  |  231|      2|#define Max_Vsize R_SIZE_T_MAX	/* unlimited */
  |  |  ------------------
  |  |  |  | 1044|      2|# define R_SIZE_T_MAX SIZE_MAX
  |  |  ------------------
  ------------------
  |  Branch (245:5): [True: 0, False: 2]
  |  Branch (245:18): [True: 0, False: 2]
  ------------------
  246|      0|	    R_ShowMessage("WARNING: invalid R_MAX_VSIZE ignored\n");
  247|      2|	else if(value < Min_Vsize) {
  ------------------
  |  |  235|      2|#define Min_Vsize 262144 // = (Mega/4)
  ------------------
  |  Branch (247:10): [True: 0, False: 2]
  ------------------
  248|      0|	    snprintf(msg, 256,
  249|      0|		     "WARNING: R_MAX_VSIZE smaller than Min_Vsize = %lu is ignored\n",
  250|      0|		     (unsigned long) Min_Vsize);
  ------------------
  |  |  235|      0|#define Min_Vsize 262144 // = (Mega/4)
  ------------------
  251|      0|	    R_ShowMessage(msg);
  252|      0|	}
  253|      2|	else
  254|      2|	    Rp->max_vsize = value;
  255|      2|    }
  256|       |#if defined(__APPLE__) && defined(_SC_PHYS_PAGES) && defined(_SC_PAGE_SIZE) \
  257|       |    && (SIZEOF_SIZE_T > 4)
  258|       |    /* For now only on macOS place a default limit on the vector heap
  259|       |       size to avoid having R killed due to memory overcommit.
  260|       |       Setting the limit at the maximum of 16Gb and available physical
  261|       |       memory seems reasonable, but there may be better options. LT */
  262|       |    else {
  263|       |	R_size_t pages = sysconf(_SC_PHYS_PAGES);
  264|       |	R_size_t page_size = sysconf(_SC_PAGE_SIZE);
  265|       |	R_size_t sysmem = pages * page_size;
  266|       |	R_size_t MinMaxVSize = 17179869184; /* 16 Gb */
  267|       |	Rp->max_vsize = sysmem > MinMaxVSize ? sysmem : MinMaxVSize;
  268|       |    }
  269|       |#elif defined(__APPLE__) && (SIZEOF_SIZE_T > 4)
  270|       |    else {
  271|       |	R_size_t sysmem = 0;
  272|       |	R_size_t len = sizeof(sysmem);
  273|       |	if (!sysctlbyname("hw.memsize", &sysmem, &len, NULL, 0)
  274|       |	    && len == sizeof(sysmem)) {
  275|       |
  276|       |	    R_size_t MinMaxVSize = 17179869184; /* 16 Gb */
  277|       |	    Rp->max_vsize = sysmem > MinMaxVSize ? sysmem : MinMaxVSize;
  278|       |	}
  279|       |    }
  280|       |#endif
  281|      2|    if((p = getenv("R_VSIZE"))) {
  ------------------
  |  Branch (281:8): [True: 0, False: 2]
  ------------------
  282|      0|	value = R_Decode2Long(p, &ierr);
  283|      0|	if(ierr != 0 || value > Max_Vsize)
  ------------------
  |  |  231|      0|#define Max_Vsize R_SIZE_T_MAX	/* unlimited */
  |  |  ------------------
  |  |  |  | 1044|      0|# define R_SIZE_T_MAX SIZE_MAX
  |  |  ------------------
  ------------------
  |  Branch (283:5): [True: 0, False: 0]
  |  Branch (283:18): [True: 0, False: 0]
  ------------------
  284|      0|	    R_ShowMessage("WARNING: invalid R_VSIZE ignored\n");
  285|      0|	else if(value < Min_Vsize) {
  ------------------
  |  |  235|      0|#define Min_Vsize 262144 // = (Mega/4)
  ------------------
  |  Branch (285:10): [True: 0, False: 0]
  ------------------
  286|      0|	    snprintf(msg, 256,
  287|      0|		     "WARNING: R_VSIZE smaller than Min_Vsize = %lu is ignored\n",
  288|      0|		     (unsigned long) Min_Vsize);
  ------------------
  |  |  235|      0|#define Min_Vsize 262144 // = (Mega/4)
  ------------------
  289|      0|	    R_ShowMessage(msg);
  290|      0|	}
  291|      0|	else
  292|      0|	    Rp->vsize = value;
  293|      0|    }
  294|      2|    if((p = getenv("R_NSIZE"))) {
  ------------------
  |  Branch (294:8): [True: 0, False: 2]
  ------------------
  295|      0|	value = R_Decode2Long(p, &ierr);
  296|      0|	if(ierr != 0 || value > Max_Nsize)
  ------------------
  |  |  230|      0|#define Max_Nsize 50000000	/* about 1.4Gb 32-bit, 2.8Gb 64-bit */
  ------------------
  |  Branch (296:5): [True: 0, False: 0]
  |  Branch (296:18): [True: 0, False: 0]
  ------------------
  297|      0|	    R_ShowMessage("WARNING: invalid R_NSIZE ignored\n");
  298|      0|	else if(value < Min_Nsize) {
  ------------------
  |  |  234|      0|#define Min_Nsize 50000
  ------------------
  |  Branch (298:10): [True: 0, False: 0]
  ------------------
  299|      0|	    snprintf(msg, 256,
  300|      0|		     "WARNING: R_NSIZE smaller than Min_Nsize = %lu is ignored\n",
  301|      0|		     (unsigned long) Min_Nsize);
  ------------------
  |  |  234|      0|#define Min_Nsize 50000
  ------------------
  302|      0|	    R_ShowMessage(msg);
  303|      0|	}
  304|      0|	else
  305|      0|	    Rp->nsize = value;
  306|      0|    }
  307|      2|}
R_SetParams:
  371|      2|{
  372|      2|    R_Quiet = checkBool(Rp->R_Quiet, "R_Quiet");
  373|      2|    R_NoEcho = (Rboolean) checkBool(Rp->R_NoEcho, "R_NoEcho");
  374|      2|    R_Interactive = (Rboolean)  checkBool(Rp->R_Interactive, "R_Interactive");
  375|      2|    R_Verbose = checkBool(Rp->R_Verbose, "R_Verbose");
  376|      2|    LoadSiteFile = checkBool(Rp->LoadSiteFile, "R_LoadSitefile");
  377|      2|    LoadInitFile = checkBool(Rp->LoadInitFile, "R_LoadInitFile");
  378|       |//    DebugInitFile = checkBool(Rp->DebugInitFile, "R_DebugInitFile"); // unused
  379|      2|    RestoreAction = Rp->RestoreAction;
  380|      2|    SaveAction = Rp->SaveAction;
  381|      2|    SetSize(Rp->vsize, Rp->nsize);
  382|      2|    SetMaxSize(Rp->max_vsize, Rp->max_nsize);
  383|      2|    R_SetPPSize(Rp->ppsize);
  384|      2|    R_SetNconn(Rp->nconnections);
  385|       |#ifdef Win32
  386|       |    R_SetWin32(Rp);
  387|       |#endif
  388|      2|}
startup.c:checkBool:
  362|     12|{
  363|     12|    if(in != 0 && in != 1) {
  ------------------
  |  Branch (363:8): [True: 6, False: 6]
  |  Branch (363:19): [True: 0, False: 6]
  ------------------
  364|      0|	warning("At startup: value %d of Rp->%s taken as true", in, name);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
  365|      0|	in = 1;
  366|      0|    }
  367|     12|    return (bool)(in != 0);
  368|     12|}
startup.c:SetSize:
  310|      2|{
  311|      2|    char msg[1024];
  312|      2|    bool sml;
  313|       |    /* vsize > 0 to catch long->int overflow */
  314|      2|    if (vsize < 1000 && vsize > 0) {
  ------------------
  |  Branch (314:9): [True: 0, False: 2]
  |  Branch (314:25): [True: 0, False: 0]
  ------------------
  315|      0|	R_ShowMessage("WARNING: vsize ridiculously low, Megabytes assumed\n");
  316|      0|	vsize *= (R_size_t) Mega;
  ------------------
  |  | 1050|      0|#define Mega 1048576.    /* Misnomer !! 1 MiB (mebibyte) := 2^20 (= 1048576) Bytes */
  ------------------
  317|      0|    }
  318|      2|    if((sml = vsize < Min_Vsize) || vsize > Max_Vsize) {
  ------------------
  |  |  235|      2|#define Min_Vsize 262144 // = (Mega/4)
  ------------------
                  if((sml = vsize < Min_Vsize) || vsize > Max_Vsize) {
  ------------------
  |  |  231|      2|#define Max_Vsize R_SIZE_T_MAX	/* unlimited */
  |  |  ------------------
  |  |  |  | 1044|      2|# define R_SIZE_T_MAX SIZE_MAX
  |  |  ------------------
  ------------------
  |  Branch (318:8): [True: 0, False: 2]
  |  Branch (318:37): [True: 0, False: 2]
  ------------------
  319|      0|	snprintf(msg, 1024,
  320|      0|		 "WARNING: %s v(ector heap)size '%lu' ignored,"
  321|      0|		 " using default = %gM\n",
  322|      0|		 sml ? "too small" : "too large",
  ------------------
  |  Branch (322:4): [True: 0, False: 0]
  ------------------
  323|      0|		 (unsigned long) vsize, R_VSIZE / Mega);
  ------------------
  |  | 1066|      0|#define	R_VSIZE		67108864L
  ------------------
              		 (unsigned long) vsize, R_VSIZE / Mega);
  ------------------
  |  | 1050|      0|#define Mega 1048576.    /* Misnomer !! 1 MiB (mebibyte) := 2^20 (= 1048576) Bytes */
  ------------------
  324|      0|	R_ShowMessage(msg);
  325|      0|	R_VSize = R_VSIZE;
  ------------------
  |  | 1066|      0|#define	R_VSIZE		67108864L
  ------------------
  326|      0|    } else
  327|      2|	R_VSize = vsize;
  328|      2|    if((sml = nsize < Min_Nsize) || nsize > Max_Nsize) {
  ------------------
  |  |  234|      2|#define Min_Nsize 50000
  ------------------
                  if((sml = nsize < Min_Nsize) || nsize > Max_Nsize) {
  ------------------
  |  |  230|      2|#define Max_Nsize 50000000	/* about 1.4Gb 32-bit, 2.8Gb 64-bit */
  ------------------
  |  Branch (328:8): [True: 0, False: 2]
  |  Branch (328:37): [True: 0, False: 2]
  ------------------
  329|      0|	snprintf(msg, 1024,
  330|      0|		 "WARNING: %s language heap (n)size '%lu' ignored,"
  331|      0|		 " using default = %ld\n",
  332|      0|		 sml ? "too small" : "too large", (unsigned long) nsize, R_NSIZE);
  ------------------
  |  | 1063|      0|#define	R_NSIZE		350000L
  ------------------
  |  Branch (332:4): [True: 0, False: 0]
  ------------------
  333|      0|	R_ShowMessage(msg);
  334|      0|	R_NSize = R_NSIZE;
  ------------------
  |  | 1063|      0|#define	R_NSIZE		350000L
  ------------------
  335|      0|    } else
  336|      2|	R_NSize = nsize;
  337|      2|}
startup.c:SetMaxSize:
  340|      2|{
  341|      2|    char msg[1024];
  342|       |
  343|      2|    if (!R_SetMaxVSize(vsize)) {
  ------------------
  |  Branch (343:9): [True: 0, False: 2]
  ------------------
  344|       |	/* vsfac is still 1 */
  345|      0|	snprintf(msg, 1024,
  346|      0|		 "WARNING: too small maximum for v(ector heap)size '%lu' ignored,"
  347|      0|		 " the current usage %gM is already larger\n",
  348|      0|		 (unsigned long) vsize, R_VSize / Mega);
  ------------------
  |  | 1050|      0|#define Mega 1048576.    /* Misnomer !! 1 MiB (mebibyte) := 2^20 (= 1048576) Bytes */
  ------------------
  349|      0|	R_ShowMessage(msg);
  350|      0|    }
  351|       |
  352|      2|    if (!R_SetMaxNSize(nsize)) {
  ------------------
  |  Branch (352:9): [True: 0, False: 2]
  ------------------
  353|      0|	snprintf(msg, 1024,
  354|      0|		 "WARNING: too small maximum for language heap (n)size '%lu' ignored,"
  355|      0|		 " the current usage '%lu' is already larger\n",
  356|      0|		 (unsigned long) nsize, (unsigned long) R_NSize);
  357|      0|	R_ShowMessage(msg);
  358|      0|    }
  359|      2|}

do_subassign_dflt:
 1621|    271|{
 1622|    271|    PROTECT(args);
  ------------------
  |  |  357|    271|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1623|       |
 1624|    271|    SEXP subs, x, y;
 1625|    271|    int nsubs = SubAssignArgs(args, &x, &subs, &y);
 1626|    271|    PROTECT(y); /* gets cut loose in SubAssignArgs */
  ------------------
  |  |  357|    271|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1627|       |
 1628|       |    /* make sure the LHS is duplicated if it matches one of the indices */
 1629|       |    /* otherwise this gets the wrong answer:
 1630|       |          permute <- structure(c(3L, 1L, 2L), dim = c(3, 1))
 1631|       |	  permute[permute, 1] <- 1:3
 1632|       |	  as.vector(permute)
 1633|       |    */
 1634|    550|    for (SEXP s = subs; s != R_NilValue; s = CDR(s)) {
  ------------------
  |  Branch (1634:25): [True: 279, False: 271]
  ------------------
 1635|    279|	SEXP idx = CAR(s);
 1636|    279|	if (x == idx)
  ------------------
  |  Branch (1636:6): [True: 0, False: 279]
  ------------------
 1637|      0|	    MARK_NOT_MUTABLE(x);
 1638|    279|    }
 1639|       |
 1640|       |    /* If there are multiple references to an object we must */
 1641|       |    /* duplicate it so that only the local version is mutated. */
 1642|       |    /* This will duplicate more often than necessary, but saves */
 1643|       |    /* over always duplicating. */
 1644|       |
 1645|    271|    if (MAYBE_SHARED(CAR(args)) ||
  ------------------
  |  Branch (1645:9): [True: 0, False: 271]
  ------------------
 1646|    271|	((! IS_ASSIGNMENT_CALL(call)) && MAYBE_REFERENCED(CAR(args))))
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1646:3): [True: 0, False: 271]
  ------------------
 1647|      0|	x = SETCAR(args, shallow_duplicate(CAR(args)));
  ------------------
  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 1648|       |
 1649|    271|    bool S4 = IS_S4_OBJECT(x); // {before it is changed}
 1650|    271|    int oldtype = 0;
 1651|    271|    if (TYPEOF(x) == LISTSXP || TYPEOF(x) == LANGSXP) {
  ------------------
  |  |  113|    542|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
                  if (TYPEOF(x) == LISTSXP || TYPEOF(x) == LANGSXP) {
  ------------------
  |  |  117|    271|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (1651:9): [True: 0, False: 271]
  |  Branch (1651:33): [True: 0, False: 271]
  ------------------
 1652|      0|	oldtype = TYPEOF(x);
 1653|      0|	x = PairToVectorList(x);
  ------------------
  |  | 1010|      0|#define PairToVectorList	Rf_PairToVectorList
  ------------------
 1654|      0|    }
 1655|    271|    else if (xlength(x) == 0) {
  ------------------
  |  | 1049|    271|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (1655:14): [True: 0, False: 271]
  ------------------
 1656|      0|	if (xlength(y) == 0 && (isNull(x) || TYPEOF(x) == TYPEOF(y) ||
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
              	if (xlength(y) == 0 && (isNull(x) || TYPEOF(x) == TYPEOF(y) ||
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (1656:6): [True: 0, False: 0]
  |  Branch (1656:26): [True: 0, False: 0]
  |  Branch (1656:39): [True: 0, False: 0]
  ------------------
 1657|       |				// isVectorList(y):
 1658|      0|				TYPEOF(y) == VECSXP || TYPEOF(y) == EXPRSXP)) {
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
              				TYPEOF(y) == VECSXP || TYPEOF(y) == EXPRSXP)) {
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1658:5): [True: 0, False: 0]
  |  Branch (1658:28): [True: 0, False: 0]
  ------------------
 1659|      0|	    UNPROTECT(2);  /* args, y */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1660|      0|	    return(x);
 1661|      0|	}
 1662|      0|	else {
 1663|       |	    /* bug PR#2590 coerce only if null */
 1664|      0|	    if(isNull(x)) x = coerceVector(x, TYPEOF(y));
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
              	    if(isNull(x)) x = coerceVector(x, TYPEOF(y));
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
  |  Branch (1664:9): [True: 0, False: 0]
  ------------------
 1665|      0|	}
 1666|      0|    }
 1667|    271|    PROTECT(x);
  ------------------
  |  |  357|    271|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1668|       |
 1669|    271|    switch (TYPEOF(x)) {
 1670|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1670:5): [True: 0, False: 271]
  ------------------
 1671|     90|    case INTSXP:
  ------------------
  |  |  123|     90|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1671:5): [True: 90, False: 181]
  ------------------
 1672|     90|    case REALSXP:
  ------------------
  |  |  124|     90|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1672:5): [True: 0, False: 271]
  ------------------
 1673|     90|    case CPLXSXP:
  ------------------
  |  |  125|     90|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1673:5): [True: 0, False: 271]
  ------------------
 1674|    106|    case STRSXP:
  ------------------
  |  |  126|    106|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1674:5): [True: 16, False: 255]
  ------------------
 1675|    106|    case EXPRSXP:
  ------------------
  |  |  132|    106|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1675:5): [True: 0, False: 271]
  ------------------
 1676|    271|    case VECSXP:
  ------------------
  |  |  131|    271|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1676:5): [True: 165, False: 106]
  ------------------
 1677|    271|    case RAWSXP:
  ------------------
  |  |  136|    271|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1677:5): [True: 0, False: 271]
  ------------------
 1678|    271|	switch (nsubs) {
 1679|      0|	case 0:
  ------------------
  |  Branch (1679:2): [True: 0, False: 271]
  ------------------
 1680|      0|	    x = VectorAssign(call, rho, x, R_MissingArg, y);
 1681|      0|	    break;
 1682|    263|	case 1:
  ------------------
  |  Branch (1682:2): [True: 263, False: 8]
  ------------------
 1683|    263|	    x = VectorAssign(call, rho, x, CAR(subs), y);
 1684|    263|	    break;
 1685|      8|	case 2:
  ------------------
  |  Branch (1685:2): [True: 8, False: 263]
  ------------------
 1686|      8|	    x = MatrixAssign(call, rho, x, subs, y);
 1687|      8|	    break;
 1688|      0|	default:
  ------------------
  |  Branch (1688:2): [True: 0, False: 271]
  ------------------
 1689|      0|	    x = ArrayAssign(call, rho, x, subs, y);
 1690|      0|	    break;
 1691|    271|	}
 1692|    271|	break;
 1693|    271|    default:
  ------------------
  |  Branch (1693:5): [True: 0, False: 271]
  ------------------
 1694|      0|	errorNotSubsettable(x);
 1695|      0|	break;
 1696|    271|    }
 1697|       |
 1698|    271|    if (oldtype == LANGSXP) {
  ------------------
  |  |  117|    271|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (1698:9): [True: 0, False: 271]
  ------------------
 1699|      0|	if(length(x)) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  |  |  ------------------
  |  |  |  Branch (987:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1700|      0|	    x = VectorToPairList(x);
  ------------------
  |  | 1046|      0|#define VectorToPairList	Rf_VectorToPairList
  ------------------
 1701|      0|	    SET_TYPEOF(x, LANGSXP);
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
 1702|      0|	} else
 1703|      0|	    error(_("result is zero-length and so cannot be a language object"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("result is zero-length and so cannot be a language object"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1704|      0|    }
 1705|       |
 1706|       |    /* Note the setting of NAMED(x) to zero here.  This means */
 1707|       |    /* that the following assignment will not duplicate the value. */
 1708|       |    /* This works because at this point, x is guaranteed to have */
 1709|       |    /* at most one symbol bound to it.  It does mean that there */
 1710|       |    /* will be multiple reference problems if "[<-" is used */
 1711|       |    /* in a naked fashion. */
 1712|       |
 1713|    271|    UNPROTECT(3); /* args, x, y */
  ------------------
  |  |  358|    271|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1714|    271|    SETTER_CLEAR_NAMED(x);
 1715|    271|    if(S4) SET_S4_OBJECT(x);
  ------------------
  |  Branch (1715:8): [True: 0, False: 271]
  ------------------
 1716|    271|    return x;
 1717|    271|}
do_subassign2:
 1754|     16|{
 1755|     16|    SEXP ans;
 1756|       |
 1757|       |    /* DispatchOrEval internal generic: [[<- */
 1758|     16|    if(R_DispatchOrEvalSP(call, op, "[[<-", args, rho, &ans))
  ------------------
  |  Branch (1758:8): [True: 0, False: 16]
  ------------------
 1759|       |/*     if(DispatchAnyOrEval(call, op, "[[<-", args, rho, &ans, 0, 0)) */
 1760|      0|      return(ans);
 1761|       |
 1762|     16|    return do_subassign2_dflt(call, op, ans, rho);
 1763|     16|}
do_subassign2_dflt:
 1776|  1.42k|{
 1777|  1.42k|    SEXP dims, indx, names, newname, subs, x, xtop, xup, y, thesub = R_NilValue, xOrig = R_NilValue;
 1778|  1.42k|    int i, ndims, which, len = 0 /* -Wall */;
 1779|  1.42k|    R_xlen_t  stretch, offset, off = -1; /* -Wall */
 1780|       |
 1781|  1.42k|    PROTECT(args);
  ------------------
  |  |  357|  1.42k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1782|       |
 1783|  1.42k|    int nsubs = SubAssignArgs(args, &x, &subs, &y);
 1784|  1.42k|    PROTECT(y); /* gets cut loose in SubAssignArgs */
  ------------------
  |  |  357|  1.42k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1785|       |
 1786|       |    /* Handle NULL left-hand sides.  If the right-hand side */
 1787|       |    /* is NULL, just return the left-hand size otherwise, */
 1788|       |    /* convert to a zero length list (VECSXP). */
 1789|       |
 1790|  1.42k|    if (isNull(x)) {
  ------------------
  |  |  956|  1.42k|#define isNull			Rf_isNull
  ------------------
  |  Branch (1790:9): [True: 0, False: 1.42k]
  ------------------
 1791|      0|	if (isNull(y)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (1791:6): [True: 0, False: 0]
  ------------------
 1792|      0|	    UNPROTECT(2); /* args, y */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1793|      0|	    return x;
 1794|      0|	}
 1795|       |#ifdef NO_LONGER_IN_R_4_x_y
 1796|       |	if (length(y) == 1)
 1797|       |	    x = allocVector(TYPEOF(y), 0);
 1798|       |	else
 1799|       |#endif
 1800|      0|	    x = allocVector(VECSXP, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	    x = allocVector(VECSXP, 0);
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
 1801|      0|    }
 1802|       |
 1803|       |    /* Ensure that the LHS is a local variable. */
 1804|       |    /* If it is not, then make a local copy. */
 1805|       |
 1806|  1.42k|    if (MAYBE_SHARED(x) ||
  ------------------
  |  Branch (1806:9): [True: 1.39k, False: 29]
  ------------------
 1807|     29|	((! IS_ASSIGNMENT_CALL(call)) && MAYBE_REFERENCED(x)))
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1807:3): [True: 0, False: 29]
  ------------------
 1808|  1.39k|	SETCAR(args, x = shallow_duplicate(x));
  ------------------
  |  | 1030|  1.39k|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 1809|       |
 1810|       |    /* code to allow classes to extend ENVSXP */
 1811|  1.42k|    bool S4 = IS_S4_OBJECT(x);
 1812|  1.42k|    if(S4 && TYPEOF(x) == OBJSXP) {
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (1812:8): [True: 0, False: 1.42k]
  |  Branch (1812:14): [True: 0, False: 0]
  ------------------
 1813|      0|	xOrig = x; /* will be an S4 object */
 1814|      0|	x = R_getS4DataSlot(x, ANYSXP);
  ------------------
  |  |  128|      0|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
 1815|      0|	if(TYPEOF(x) != ENVSXP)
  ------------------
  |  |  115|      0|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (1815:5): [True: 0, False: 0]
  ------------------
 1816|      0|	  errorcall(call, _("[[<- defined for objects of type \"S4\" only for subclasses of environment"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	  errorcall(call, _("[[<- defined for objects of type \"S4\" only for subclasses of environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1817|      0|    }
 1818|       |
 1819|  1.42k|    PROTECT(x);
  ------------------
  |  |  357|  1.42k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1820|  1.42k|    xtop = xup = x; /* x will be the element which is assigned to */
 1821|       |
 1822|  1.42k|    dims = getAttrib(x, R_DimSymbol);
  ------------------
  |  |  924|  1.42k|#define getAttrib		Rf_getAttrib
  ------------------
 1823|  1.42k|    ndims = length(dims);
  ------------------
  |  |  987|  1.42k|#define length(x)		Rf_length(x)
  ------------------
 1824|       |
 1825|  1.42k|    int *pdims = NULL;
 1826|  1.42k|    if (ndims > 0) {
  ------------------
  |  Branch (1826:9): [True: 0, False: 1.42k]
  ------------------
 1827|      0|	if (TYPEOF(dims) == INTSXP)
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1827:6): [True: 0, False: 0]
  ------------------
 1828|      0|	    pdims = INTEGER(dims);
 1829|      0|	else
 1830|      0|	    error(_("improper dimensions"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("improper dimensions"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1831|      0|    }
 1832|       |
 1833|       |    /* ENVSXP special case first */
 1834|  1.42k|    if( TYPEOF(x) == ENVSXP) {
  ------------------
  |  |  115|  1.42k|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (1834:9): [True: 1.39k, False: 29]
  ------------------
 1835|  1.39k|	if( nsubs!=1 || !isString(CAR(subs)) || length(CAR(subs)) != 1 )
  ------------------
  |  |  966|  1.39k|#define isString		Rf_isString
  ------------------
              	if( nsubs!=1 || !isString(CAR(subs)) || length(CAR(subs)) != 1 )
  ------------------
  |  |  987|  1.39k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1835:6): [True: 0, False: 1.39k]
  |  Branch (1835:18): [True: 0, False: 1.39k]
  |  Branch (1835:42): [True: 0, False: 1.39k]
  ------------------
 1836|      0|	    error(_("wrong args for environment subassignment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("wrong args for environment subassignment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1837|  1.39k|	defineVar(installTrChar(STRING_ELT(CAR(subs), 0)), y, x);
  ------------------
  |  |  905|  1.39k|#define defineVar		Rf_defineVar
  ------------------
              	defineVar(installTrChar(STRING_ELT(CAR(subs), 0)), y, x);
  ------------------
  |  |  937|  1.39k|#define installTrChar		Rf_installTrChar
  ------------------
 1838|  1.39k|	UNPROTECT(3); /* x, args, y */
  ------------------
  |  |  358|  1.39k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1839|  1.39k|	return(S4 ? xOrig : x);
  ------------------
  |  Branch (1839:9): [True: 0, False: 1.39k]
  ------------------
 1840|  1.39k|    }
 1841|       |
 1842|       |    /* new case in 1.7.0, one vector index for a list,
 1843|       |       more general as of 2.10.0 */
 1844|     29|    bool recursed = false;
 1845|     29|    if (nsubs == 1) {
  ------------------
  |  Branch (1845:9): [True: 29, False: 0]
  ------------------
 1846|     29|	thesub = CAR(subs);
 1847|     29|	len = length(thesub); /* depth of recursion, small */
  ------------------
  |  |  987|     29|#define length(x)		Rf_length(x)
  ------------------
 1848|     29|	if (len > 1) {
  ------------------
  |  Branch (1848:6): [True: 0, False: 29]
  ------------------
 1849|      0|	    xup = vectorIndex(x, thesub, 0, len-2, /*partial ok*/TRUE, call,
  ------------------
  |  | 2012|      0|# define vectorIndex		Rf_vectorIndex
  ------------------
 1850|      0|			      true);
 1851|       |	    /* OneIndex sets newname, but it will be overwritten before being used. */
 1852|      0|	    PROTECT(xup);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1853|      0|	    off = OneIndex(xup, thesub, xlength(xup), 0, &newname, len-2, R_NilValue);
  ------------------
  |  | 1962|      0|# define OneIndex		Rf_OneIndex
  ------------------
              	    off = OneIndex(xup, thesub, xlength(xup), 0, &newname, len-2, R_NilValue);
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
 1854|      0|	    x = vectorIndex(xup, thesub, len-2, len-1, true, call, true);
  ------------------
  |  | 2012|      0|# define vectorIndex		Rf_vectorIndex
  ------------------
 1855|      0|	    UNPROTECT(2); /* xup, x */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1856|      0|	    PROTECT(x);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1857|      0|	    recursed = true;
 1858|      0|	}
 1859|     29|    }
 1860|     29|    PROTECT(xup);
  ------------------
  |  |  357|     29|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1861|       |
 1862|     29|    stretch = 0;
 1863|     29|    if (isVector(x)) {
  ------------------
  |  |  974|     29|#define isVector		Rf_isVector
  ------------------
  |  Branch (1863:9): [True: 29, False: 0]
  ------------------
 1864|     29|	if (!isVectorList(x) && LENGTH(y) == 0)
  ------------------
  |  |  977|     29|#define isVectorList		Rf_isVectorList
  ------------------
  |  Branch (1864:6): [True: 0, False: 29]
  |  Branch (1864:26): [True: 0, False: 0]
  ------------------
 1865|      0|	    error(_("replacement has length zero"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("replacement has length zero"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1866|     29|	if (!isVectorList(x) && LENGTH(y) > 1)
  ------------------
  |  |  977|     29|#define isVectorList		Rf_isVectorList
  ------------------
  |  Branch (1866:6): [True: 0, False: 29]
  |  Branch (1866:26): [True: 0, False: 0]
  ------------------
 1867|      0|	    error(_("more elements supplied than there are to replace"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("more elements supplied than there are to replace"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1868|     29|	if (nsubs == 0 || CAR(subs) == R_MissingArg)
  ------------------
  |  Branch (1868:6): [True: 0, False: 29]
  |  Branch (1868:20): [True: 0, False: 29]
  ------------------
 1869|      0|	    errorMissingSubscript(x);
 1870|     29|	if (nsubs == 1) {
  ------------------
  |  Branch (1870:6): [True: 29, False: 0]
  ------------------
 1871|     29|	    offset = OneIndex(x, thesub, xlength(x), 0, &newname,
  ------------------
  |  | 1962|     29|# define OneIndex		Rf_OneIndex
  ------------------
              	    offset = OneIndex(x, thesub, xlength(x), 0, &newname,
  ------------------
  |  | 1049|     29|#define xlength(x)		Rf_xlength(x)
  ------------------
 1872|     29|			      recursed ? len-1 : -1, R_NilValue);
  ------------------
  |  Branch (1872:10): [True: 0, False: 29]
  ------------------
 1873|     29|	    if (isVectorList(x) && isNull(y)) {
  ------------------
  |  |  977|     29|#define isVectorList		Rf_isVectorList
  ------------------
              	    if (isVectorList(x) && isNull(y)) {
  ------------------
  |  |  956|     29|#define isNull			Rf_isNull
  ------------------
  |  Branch (1873:10): [True: 29, False: 0]
  |  Branch (1873:29): [True: 0, False: 29]
  ------------------
 1874|      0|		SEXP old_x = x;
 1875|      0|		x = DeleteOneVectorListItem(x, offset);
 1876|      0|		if(recursed) {
  ------------------
  |  Branch (1876:6): [True: 0, False: 0]
  ------------------
 1877|      0|		    if(isVectorList(xup)) SET_VECTOR_ELT(xup, off, x);
  ------------------
  |  |  977|      0|#define isVectorList		Rf_isVectorList
  ------------------
  |  Branch (1877:10): [True: 0, False: 0]
  ------------------
 1878|      0|		    else {
 1879|      0|			PROTECT(x);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1880|      0|			xup = SimpleListAssign(call, xup, subs, x, len-2,
 1881|      0|					       false);
 1882|      0|			UNPROTECT(1); /* x */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1883|      0|		    }
 1884|      0|		} else {
 1885|      0|		    xtop = x;
 1886|      0|		    if (old_x != x)
  ------------------
  |  Branch (1886:11): [True: 0, False: 0]
  ------------------
 1887|      0|			CLEAR_VECTOR(old_x);
  ------------------
  |  |  108|      0|# define CLEAR_VECTOR(x) do {					\
  |  |  109|      0|	if (TYPEOF(x) == EXPRSXP || TYPEOF(x) == VECSXP) {	\
  |  |  ------------------
  |  |  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  ------------------
  |  |               	if (TYPEOF(x) == EXPRSXP || TYPEOF(x) == VECSXP) {	\
  |  |  ------------------
  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (109:6): [True: 0, False: 0]
  |  |  |  Branch (109:30): [True: 0, False: 0]
  |  |  ------------------
  |  |  110|      0|	    R_xlen_t len = XLENGTH(x);				\
  |  |  111|      0|	    for (R_xlen_t i = 0; i < len; i++)			\
  |  |  ------------------
  |  |  |  Branch (111:27): [True: 0, False: 0]
  |  |  ------------------
  |  |  112|      0|		SET_VECTOR_ELT(x, i, R_NilValue);		\
  |  |  113|      0|	}							\
  |  |  114|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (114:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1888|      0|		}
 1889|      0|		UNPROTECT(4); /* xup, x, args, y */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1890|      0|		return xtop;
 1891|      0|	    }
 1892|     29|	    if (offset < 0)
  ------------------
  |  Branch (1892:10): [True: 0, False: 29]
  ------------------
 1893|      0|		errorOutOfBoundsSEXP(x, -1, thesub);
 1894|     29|	    if (offset >= XLENGTH(x))
  ------------------
  |  Branch (1894:10): [True: 29, False: 0]
  ------------------
 1895|     29|		stretch = offset + 1;
 1896|     29|	}
 1897|      0|	else {
 1898|      0|	    if (ndims != nsubs)
  ------------------
  |  Branch (1898:10): [True: 0, False: 0]
  ------------------
 1899|      0|		error(_("[[ ]] improper number of subscripts"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("[[ ]] improper number of subscripts"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1900|      0|	    PROTECT(indx = allocVector(INTSXP, ndims));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1901|      0|	    int *pindx = INTEGER0(indx);
 1902|      0|	    names = getAttrib(x, R_DimNamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 1903|      0|	    for (i = 0; i < ndims; i++) {
  ------------------
  |  Branch (1903:18): [True: 0, False: 0]
  ------------------
 1904|      0|		SEXP thesub = CAR(subs);
 1905|      0|		pindx[i] = (int)
 1906|      0|		    get1index(thesub, isNull(names) ?
  ------------------
  |  | 1906|      0|# define get1index		Rf_get1index
  ------------------
              		    get1index(thesub, isNull(names) ?
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (1906:25): [True: 0, False: 0]
  ------------------
 1907|      0|			      R_NilValue : VECTOR_ELT(names, i),
 1908|      0|			      pdims[i],
 1909|      0|			      /*partial ok*/FALSE, -1, call);
 1910|      0|		subs = CDR(subs);
 1911|      0|		if (pindx[i] < 0 ||
  ------------------
  |  Branch (1911:7): [True: 0, False: 0]
  ------------------
 1912|      0|		    pindx[i] >= pdims[i])
  ------------------
  |  Branch (1912:7): [True: 0, False: 0]
  ------------------
 1913|      0|		    errorOutOfBoundsSEXP(x, i, thesub);
 1914|      0|	    }
 1915|      0|	    offset = 0;
 1916|      0|	    for (i = (ndims - 1); i > 0; i--)
  ------------------
  |  Branch (1916:28): [True: 0, False: 0]
  ------------------
 1917|      0|		offset = (offset + pindx[i]) * pdims[i - 1];
 1918|      0|	    offset += pindx[0];
 1919|      0|	    UNPROTECT(1); /* indx */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1920|      0|	}
 1921|       |
 1922|     29|	SEXP old_x = x;
 1923|     29|	which = SubassignTypeFix(&x, &y, stretch, 2, call, rho);
 1924|       |
 1925|     29|	PROTECT(x);
  ------------------
  |  |  357|     29|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1926|     29|	PROTECT(y);
  ------------------
  |  |  357|     29|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1927|       |
 1928|     29|	switch (which) {
 1929|       |	    /* as from 2.3.0 'which' is after conversion */
 1930|       |
 1931|      0|	case 1010:	/* logical   <- logical	  */
  ------------------
  |  Branch (1931:2): [True: 0, False: 29]
  ------------------
 1932|      0|	case 1310:	/* integer   <- logical	  */
  ------------------
  |  Branch (1932:2): [True: 0, False: 29]
  ------------------
 1933|       |	/* case 1013:	   logical   <- integer	  */
 1934|      0|	case 1313:	/* integer   <- integer	  */
  ------------------
  |  Branch (1934:2): [True: 0, False: 29]
  ------------------
 1935|       |
 1936|      0|	    INTEGER(x)[offset] = INTEGER_ELT(y, 0);
 1937|      0|	    break;
 1938|       |
 1939|      0|	case 1410:	/* real	     <- logical	  */
  ------------------
  |  Branch (1939:2): [True: 0, False: 29]
  ------------------
 1940|      0|	case 1413:	/* real	     <- integer	  */
  ------------------
  |  Branch (1940:2): [True: 0, False: 29]
  ------------------
 1941|       |
 1942|      0|	    if (INTEGER_ELT(y, 0) == NA_INTEGER)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1942:10): [True: 0, False: 0]
  ------------------
 1943|      0|		REAL(x)[offset] = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
 1944|      0|	    else
 1945|      0|		REAL(x)[offset] = INTEGER_ELT(y, 0);
 1946|      0|	    break;
 1947|       |	/* case 1014:	   logical   <- real	  */
 1948|       |	/* case 1314:	   integer   <- real	  */
 1949|      0|	case 1414:	/* real	     <- real	  */
  ------------------
  |  Branch (1949:2): [True: 0, False: 29]
  ------------------
 1950|       |
 1951|      0|	    REAL(x)[offset] = REAL(y)[0];
 1952|      0|	    break;
 1953|       |
 1954|      0|	case 1510:	/* complex   <- logical	  */
  ------------------
  |  Branch (1954:2): [True: 0, False: 29]
  ------------------
 1955|      0|	case 1513:	/* complex   <- integer	  */
  ------------------
  |  Branch (1955:2): [True: 0, False: 29]
  ------------------
 1956|       |
 1957|      0|	    if (INTEGER_ELT(y, 0) == NA_INTEGER) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1957:10): [True: 0, False: 0]
  ------------------
 1958|      0|		COMPLEX(x)[offset].r = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
 1959|      0|		COMPLEX(x)[offset].i = 0.0;
 1960|      0|	    }
 1961|      0|	    else {
 1962|      0|		COMPLEX(x)[offset].r = INTEGER_ELT(y, 0);
 1963|      0|		COMPLEX(x)[offset].i = 0.0;
 1964|      0|	    }
 1965|      0|	    break;
 1966|       |
 1967|      0|	case 1514:	/* complex   <- real	  */
  ------------------
  |  Branch (1967:2): [True: 0, False: 29]
  ------------------
 1968|       |
 1969|      0|	    if (ISNA(REAL_ELT(y, 0))) {
  ------------------
  |  |   64|      0|#define ISNA(x)	       R_IsNA(x)
  |  |  ------------------
  |  |  |  Branch (64:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1970|      0|		COMPLEX(x)[offset].r = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
 1971|      0|		COMPLEX(x)[offset].i = 0.0;
 1972|      0|	    }
 1973|      0|	    else {
 1974|      0|		COMPLEX(x)[offset].r = REAL_ELT(y, 0);
 1975|      0|		COMPLEX(x)[offset].i = 0.0;
 1976|      0|	    }
 1977|      0|	    break;
 1978|       |
 1979|       |	/* case 1015:	   logical   <- complex	  */
 1980|       |	/* case 1315:	   integer   <- complex	  */
 1981|       |	/* case 1415:	   real	     <- complex	  */
 1982|      0|	case 1515:	/* complex   <- complex	  */
  ------------------
  |  Branch (1982:2): [True: 0, False: 29]
  ------------------
 1983|       |
 1984|      0|	    COMPLEX(x)[offset] = COMPLEX_ELT(y, 0);
 1985|      0|	    break;
 1986|       |
 1987|      0|	case 1610:	/* character <- logical	  */
  ------------------
  |  Branch (1987:2): [True: 0, False: 29]
  ------------------
 1988|      0|	case 1613:	/* character <- integer	  */
  ------------------
  |  Branch (1988:2): [True: 0, False: 29]
  ------------------
 1989|      0|	case 1614:	/* character <- real	  */
  ------------------
  |  Branch (1989:2): [True: 0, False: 29]
  ------------------
 1990|      0|	case 1615:	/* character <- complex	  */
  ------------------
  |  Branch (1990:2): [True: 0, False: 29]
  ------------------
 1991|      0|	case 1616:	/* character <- character */
  ------------------
  |  Branch (1991:2): [True: 0, False: 29]
  ------------------
 1992|       |	/* case 1016:	   logical   <- character */
 1993|       |	/* case 1316:	   integer   <- character */
 1994|       |	/* case 1416:	   real	     <- character */
 1995|       |	/* case 1516:	   complex   <- character */
 1996|       |
 1997|      0|	    SET_STRING_ELT(x, offset, STRING_ELT(y, 0));
 1998|      0|	    break;
 1999|       |
 2000|      0|	case 1019:      /* logical    <- vector     */
  ------------------
  |  Branch (2000:2): [True: 0, False: 29]
  ------------------
 2001|      0|	case 1319:      /* integer    <- vector     */
  ------------------
  |  Branch (2001:2): [True: 0, False: 29]
  ------------------
 2002|      0|	case 1419:      /* real       <- vector     */
  ------------------
  |  Branch (2002:2): [True: 0, False: 29]
  ------------------
 2003|      0|	case 1519:      /* complex    <- vector     */
  ------------------
  |  Branch (2003:2): [True: 0, False: 29]
  ------------------
 2004|      0|	case 1619:      /* character  <- vector     */
  ------------------
  |  Branch (2004:2): [True: 0, False: 29]
  ------------------
 2005|       |
 2006|      0|	case 1901:  /* vector     <- symbol     */
  ------------------
  |  Branch (2006:2): [True: 0, False: 29]
  ------------------
 2007|      0|	case 1902:  /* vector	  <- pairlist   */
  ------------------
  |  Branch (2007:2): [True: 0, False: 29]
  ------------------
 2008|      0|	case 1904:  /* vector     <- environment*/
  ------------------
  |  Branch (2008:2): [True: 0, False: 29]
  ------------------
 2009|      0|	case 1905:  /* vector     <- promise    */
  ------------------
  |  Branch (2009:2): [True: 0, False: 29]
  ------------------
 2010|      0|	case 1906:  /* vector     <- language   */
  ------------------
  |  Branch (2010:2): [True: 0, False: 29]
  ------------------
 2011|      0|	case 1910:  /* vector     <- logical    */
  ------------------
  |  Branch (2011:2): [True: 0, False: 29]
  ------------------
 2012|      0|	case 1913:  /* vector     <- integer    */
  ------------------
  |  Branch (2012:2): [True: 0, False: 29]
  ------------------
 2013|      9|	case 1914:  /* vector     <- real       */
  ------------------
  |  Branch (2013:2): [True: 9, False: 20]
  ------------------
 2014|      9|	case 1915:  /* vector     <- complex    */
  ------------------
  |  Branch (2014:2): [True: 0, False: 29]
  ------------------
 2015|     19|	case 1916:  /* vector     <- character  */
  ------------------
  |  Branch (2015:2): [True: 10, False: 19]
  ------------------
 2016|     19|	case 1920:  /* vector     <- expression */
  ------------------
  |  Branch (2016:2): [True: 0, False: 29]
  ------------------
 2017|     19|	case 1921:  /* vector     <- bytecode   */
  ------------------
  |  Branch (2017:2): [True: 0, False: 29]
  ------------------
 2018|     19|	case 1922:  /* vector     <- external pointer */
  ------------------
  |  Branch (2018:2): [True: 0, False: 29]
  ------------------
 2019|     19|	case 1923:  /* vector     <- weak reference */
  ------------------
  |  Branch (2019:2): [True: 0, False: 29]
  ------------------
 2020|     19|	case 1924:  /* vector     <- raw */
  ------------------
  |  Branch (2020:2): [True: 0, False: 29]
  ------------------
 2021|     19|	case 1925:  /* vector     <- S4 */
  ------------------
  |  Branch (2021:2): [True: 0, False: 29]
  ------------------
 2022|     19|	case 1903: case 1907: case 1908: case 1999: /* functions */
  ------------------
  |  Branch (2022:2): [True: 0, False: 29]
  |  Branch (2022:13): [True: 0, False: 29]
  |  Branch (2022:24): [True: 0, False: 29]
  |  Branch (2022:35): [True: 0, False: 29]
  ------------------
 2023|       |
 2024|       |	    /* drop through: vectors and expressions are treated the same */
 2025|       |
 2026|     19|	case 2001:	/* expression <- symbol	    */
  ------------------
  |  Branch (2026:2): [True: 0, False: 29]
  ------------------
 2027|     19|	case 2002:	/* expression <- pairlist   */
  ------------------
  |  Branch (2027:2): [True: 0, False: 29]
  ------------------
 2028|     19|	case 2006:	/* expression <- language   */
  ------------------
  |  Branch (2028:2): [True: 0, False: 29]
  ------------------
 2029|     19|	case 2010:	/* expression <- logical    */
  ------------------
  |  Branch (2029:2): [True: 0, False: 29]
  ------------------
 2030|     19|	case 2013:	/* expression <- integer    */
  ------------------
  |  Branch (2030:2): [True: 0, False: 29]
  ------------------
 2031|     19|	case 2014:	/* expression <- real	    */
  ------------------
  |  Branch (2031:2): [True: 0, False: 29]
  ------------------
 2032|     19|	case 2015:	/* expression <- complex    */
  ------------------
  |  Branch (2032:2): [True: 0, False: 29]
  ------------------
 2033|     19|	case 2016:	/* expression <- character  */
  ------------------
  |  Branch (2033:2): [True: 0, False: 29]
  ------------------
 2034|     19|	case 2024:	/* expression     <- raw */
  ------------------
  |  Branch (2034:2): [True: 0, False: 29]
  ------------------
 2035|     19|	case 2025:	/* expression     <- S4 */
  ------------------
  |  Branch (2035:2): [True: 0, False: 29]
  ------------------
 2036|     29|	case 1919:      /* vector     <- vector     */
  ------------------
  |  Branch (2036:2): [True: 10, False: 19]
  ------------------
 2037|     29|	case 2020:	/* expression <- expression */
  ------------------
  |  Branch (2037:2): [True: 0, False: 29]
  ------------------
 2038|       |
 2039|     29|	    if (MAYBE_REFERENCED(y) && VECTOR_ELT(x, offset) != y)
  ------------------
  |  |  251|     58|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 29, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (2039:33): [True: 29, False: 0]
  ------------------
 2040|     29|		y = R_FixupRHS(x, y);
 2041|     29|	    SET_VECTOR_ELT(x, offset, y);
 2042|     29|	    break;
 2043|       |
 2044|      0|	case 2424:      /* raw <- raw */
  ------------------
  |  Branch (2044:2): [True: 0, False: 29]
  ------------------
 2045|       |
 2046|      0|	    RAW(x)[offset] = RAW_ELT(y, 0);
 2047|      0|	    break;
 2048|       |
 2049|      0|	default:
  ------------------
  |  Branch (2049:2): [True: 0, False: 29]
  ------------------
 2050|      0|	    error(_("incompatible types (from %s to %s) in [[ assignment"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("incompatible types (from %s to %s) in [[ assignment"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2051|      0|		  R_typeToChar(x), R_typeToChar(y));
 2052|     29|	}
 2053|       |	/* If we stretched, we may have a new name. */
 2054|       |	/* In this case we must create a names attribute */
 2055|       |	/* (if it doesn't already exist) and set the new */
 2056|       |	/* value in the names attribute. */
 2057|     29|	if (stretch && newname != R_NilValue) {
  ------------------
  |  Branch (2057:6): [True: 29, False: 0]
  |  Branch (2057:17): [True: 29, False: 0]
  ------------------
 2058|     29|	    names = getAttrib(x, R_NamesSymbol);
  ------------------
  |  |  924|     29|#define getAttrib		Rf_getAttrib
  ------------------
 2059|     29|	    if (names == R_NilValue) {
  ------------------
  |  Branch (2059:10): [True: 23, False: 6]
  ------------------
 2060|     23|		PROTECT(names = allocVector(STRSXP, length(x)));
  ------------------
  |  |  357|     23|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2061|     23|		SET_STRING_ELT(names, offset, newname);
 2062|     23|		setAttrib(x, R_NamesSymbol, names);
  ------------------
  |  | 1027|     23|#define setAttrib		Rf_setAttrib
  ------------------
 2063|     23|		UNPROTECT(1); /* names */
  ------------------
  |  |  358|     23|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2064|     23|	    }
 2065|      6|	    else
 2066|      6|		SET_STRING_ELT(names, offset, newname);
 2067|     29|	}
 2068|     29|	if (old_x != x && ! recursed)
  ------------------
  |  Branch (2068:6): [True: 29, False: 0]
  |  Branch (2068:20): [True: 29, False: 0]
  ------------------
 2069|       |	    // might be safe even if recursed is TRUE, but avoid for now
 2070|     29|	    CLEAR_VECTOR(old_x);
  ------------------
  |  |  108|     29|# define CLEAR_VECTOR(x) do {					\
  |  |  109|     29|	if (TYPEOF(x) == EXPRSXP || TYPEOF(x) == VECSXP) {	\
  |  |  ------------------
  |  |  |  |  132|     58|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  ------------------
  |  |               	if (TYPEOF(x) == EXPRSXP || TYPEOF(x) == VECSXP) {	\
  |  |  ------------------
  |  |  |  |  131|     29|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (109:6): [True: 0, False: 29]
  |  |  |  Branch (109:30): [True: 29, False: 0]
  |  |  ------------------
  |  |  110|     29|	    R_xlen_t len = XLENGTH(x);				\
  |  |  111|     42|	    for (R_xlen_t i = 0; i < len; i++)			\
  |  |  ------------------
  |  |  |  Branch (111:27): [True: 13, False: 29]
  |  |  ------------------
  |  |  112|     29|		SET_VECTOR_ELT(x, i, R_NilValue);		\
  |  |  113|     29|	}							\
  |  |  114|     29|    } while (0)
  |  |  ------------------
  |  |  |  Branch (114:14): [Folded, False: 29]
  |  |  ------------------
  ------------------
 2071|     29|	UNPROTECT(4); /* y, x, xup, x */
  ------------------
  |  |  358|     29|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2072|     29|	PROTECT(x);
  ------------------
  |  |  357|     29|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2073|     29|	PROTECT(xup);
  ------------------
  |  |  357|     29|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2074|     29|    }
 2075|      0|    else if (isPairList(x)) {
  ------------------
  |  |  961|      0|#define isPairList		Rf_isPairList
  ------------------
  |  Branch (2075:14): [True: 0, False: 0]
  ------------------
 2076|      0|	PROTECT(y);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2077|      0|	if (nsubs == 1) {
  ------------------
  |  Branch (2077:6): [True: 0, False: 0]
  ------------------
 2078|      0|	    if (isNull(y)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (2078:10): [True: 0, False: 0]
  ------------------
 2079|      0|		x = listRemove(x, CAR(subs), len-1);
 2080|      0|	    }
 2081|      0|	    else {
 2082|      0|		x = SimpleListAssign(call, x, subs, y, len-1, true);
 2083|      0|	    }
 2084|      0|	}
 2085|      0|	else {
 2086|      0|	    if (ndims != nsubs)
  ------------------
  |  Branch (2086:10): [True: 0, False: 0]
  ------------------
 2087|      0|		error(_("[[ ]] improper number of subscripts"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("[[ ]] improper number of subscripts"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2088|      0|	    PROTECT(indx = allocVector(INTSXP, ndims));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2089|      0|	    int *pindx = INTEGER0(indx);
 2090|      0|	    names = getAttrib(x, R_DimNamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 2091|      0|	    for (i = 0; i < ndims; i++) {
  ------------------
  |  Branch (2091:18): [True: 0, False: 0]
  ------------------
 2092|      0|		SEXP thesub = CAR(subs);
 2093|      0|		pindx[i] = (int)
 2094|      0|		    get1index(thesub, VECTOR_ELT(names, i),
  ------------------
  |  | 1906|      0|# define get1index		Rf_get1index
  ------------------
 2095|      0|			      pdims[i],
 2096|      0|			      /*partial ok*/FALSE, -1, call);
 2097|      0|		subs = CDR(subs);
 2098|      0|		if (pindx[i] < 0 ||
  ------------------
  |  Branch (2098:7): [True: 0, False: 0]
  ------------------
 2099|      0|		    pindx[i] >= pdims[i])
  ------------------
  |  Branch (2099:7): [True: 0, False: 0]
  ------------------
 2100|      0|		    errorOutOfBoundsSEXP(x, i, thesub);
 2101|      0|	    }
 2102|      0|	    offset = 0;
 2103|      0|	    for (i = (ndims - 1); i > 0; i--)
  ------------------
  |  Branch (2103:28): [True: 0, False: 0]
  ------------------
 2104|      0|		offset = (offset + pindx[i]) * pdims[i - 1];
 2105|      0|	    offset += pindx[0];
 2106|      0|	    SEXP slot = nthcdr(x, (int) offset);
  ------------------
  |  | 1009|      0|#define nthcdr			Rf_nthcdr
  ------------------
 2107|      0|	    SETCAR(slot, duplicate(y));
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
 2108|       |	    /* FIXME: add name */
 2109|      0|	    UNPROTECT(1); /* indx */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2110|      0|	}
 2111|      0|	UNPROTECT(3); /* y, xup, x */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2112|      0|	PROTECT(x);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2113|      0|	PROTECT(xup);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2114|      0|    }
 2115|      0|    else errorNotSubsettable(x);
 2116|       |
 2117|     29|    if(recursed) {
  ------------------
  |  Branch (2117:8): [True: 0, False: 29]
  ------------------
 2118|      0|	if (isVectorList(xup)) {
  ------------------
  |  |  977|      0|#define isVectorList		Rf_isVectorList
  ------------------
  |  Branch (2118:6): [True: 0, False: 0]
  ------------------
 2119|      0|	    SET_VECTOR_ELT(xup, off, x);
 2120|      0|	} else {
 2121|      0|	    xup = SimpleListAssign(call, xup, subs, x, len-2, false);
 2122|      0|	}
 2123|      0|	if (len == 2)
  ------------------
  |  Branch (2123:6): [True: 0, False: 0]
  ------------------
 2124|      0|	    xtop = xup;
 2125|      0|    }
 2126|     29|    else xtop = x;
 2127|       |
 2128|     29|    UNPROTECT(4); /* xup, x, args, y */
  ------------------
  |  |  358|     29|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2129|     29|    SETTER_CLEAR_NAMED(xtop);
 2130|     29|    if(S4) SET_S4_OBJECT(xtop);
  ------------------
  |  Branch (2130:8): [True: 0, False: 29]
  ------------------
 2131|     29|    return xtop;
 2132|     29|}
R_subassign3_dflt:
 2162|   770k|{
 2163|   770k|    SEXP t;
 2164|   770k|    PROTECT_INDEX pvalidx, pxidx;
 2165|   770k|    bool S4; SEXP xS4 = R_NilValue;
 2166|   770k|    int nprotect = 0;
 2167|       |
 2168|   770k|    PROTECT_WITH_INDEX(x, &pxidx);
  ------------------
  |  |  366|   770k|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
 2169|   770k|    PROTECT_WITH_INDEX(val, &pvalidx);
  ------------------
  |  |  366|   770k|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
 2170|   770k|    nprotect += 2;
 2171|   770k|    S4 = IS_S4_OBJECT(x);
 2172|       |
 2173|   770k|    if (MAYBE_SHARED(x) ||
  ------------------
  |  Branch (2173:9): [True: 28, False: 770k]
  ------------------
 2174|   770k|	((! IS_ASSIGNMENT_CALL(call)) && MAYBE_REFERENCED(x)))
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (2174:3): [True: 0, False: 770k]
  ------------------
 2175|     28|	REPROTECT(x = shallow_duplicate(x), pxidx);
  ------------------
  |  |  367|     28|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 2176|       |
 2177|       |    /* code to allow classes to extend ENVSXP */
 2178|   770k|    if(TYPEOF(x) == OBJSXP) {
  ------------------
  |  |  137|   770k|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (2178:8): [True: 0, False: 770k]
  ------------------
 2179|      0|	xS4 = x;
 2180|      0|	REPROTECT(x = R_getS4DataSlot(x, ANYSXP), pxidx);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 2181|      0|	if(x == R_NilValue)
  ------------------
  |  Branch (2181:5): [True: 0, False: 0]
  ------------------
 2182|      0|	  errorcall(call, _("no method for assigning subsets of this S4 class"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	  errorcall(call, _("no method for assigning subsets of this S4 class"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2183|      0|    }
 2184|       |
 2185|   770k|    if ((isList(x) || isLanguage(x)) && !isNull(x)) {
  ------------------
  |  |  951|   770k|#define isList			Rf_isList
  ------------------
                  if ((isList(x) || isLanguage(x)) && !isNull(x)) {
  ------------------
  |  |  950|   770k|#define isLanguage		Rf_isLanguage
  ------------------
                  if ((isList(x) || isLanguage(x)) && !isNull(x)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (2185:10): [True: 0, False: 770k]
  |  Branch (2185:23): [True: 0, False: 770k]
  |  Branch (2185:41): [True: 0, False: 0]
  ------------------
 2186|      0|	if (TAG(x) == nlist) {
  ------------------
  |  Branch (2186:6): [True: 0, False: 0]
  ------------------
 2187|      0|	    if (val == R_NilValue) {
  ------------------
  |  Branch (2187:10): [True: 0, False: 0]
  ------------------
 2188|      0|		SET_ATTRIB(CDR(x), ATTRIB(x));
 2189|      0|		IS_S4_OBJECT(x) ?  SET_S4_OBJECT(CDR(x)) : UNSET_S4_OBJECT(CDR(x));
  ------------------
  |  Branch (2189:3): [True: 0, False: 0]
  ------------------
 2190|      0|		SET_OBJECT(CDR(x), OBJECT(x));
 2191|      0|		RAISE_NAMED(CDR(x), NAMED(x));
 2192|      0|		SETCAR(x, R_NilValue); // decrements REFCNT
 2193|      0|		x = CDR(x);
 2194|      0|	    }
 2195|      0|	    else {
 2196|       |		/* Here we need to check for cycles*/
 2197|      0|		if (MAYBE_REFERENCED(val) && CAR(x) != val)
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (2197:32): [True: 0, False: 0]
  ------------------
 2198|      0|		    REPROTECT(val = R_FixupRHS(x, val), pvalidx);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 2199|      0|		SETCAR(x, val);
 2200|      0|	    }
 2201|      0|	}
 2202|      0|	else {
 2203|      0|	    for (t = x; t != R_NilValue; t = CDR(t))
  ------------------
  |  Branch (2203:18): [True: 0, False: 0]
  ------------------
 2204|      0|		if (TAG(CDR(t)) == nlist) {
  ------------------
  |  Branch (2204:7): [True: 0, False: 0]
  ------------------
 2205|      0|		    if (val == R_NilValue) {
  ------------------
  |  Branch (2205:11): [True: 0, False: 0]
  ------------------
 2206|      0|			SETCAR(CDR(t), R_NilValue); // decrements REFCNT
 2207|      0|			SETCDR(t, CDDR(t));
 2208|      0|		    }
 2209|      0|		    else {
 2210|       |			/* Here we need to check for cycles*/
 2211|      0|			if (MAYBE_REFERENCED(val) && CADR(t) != val)
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (2211:33): [True: 0, False: 0]
  ------------------
 2212|      0|			    REPROTECT(val = R_FixupRHS(x, val), pvalidx);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 2213|      0|			SETCAR(CDR(t), val);
 2214|      0|		    }
 2215|      0|		    break;
 2216|      0|		}
 2217|      0|		else if (CDR(t) == R_NilValue && val != R_NilValue) {
  ------------------
  |  Branch (2217:12): [True: 0, False: 0]
  |  Branch (2217:36): [True: 0, False: 0]
  ------------------
 2218|      0|		    SETCDR(t, allocSExp(LISTSXP));
  ------------------
  |  |  874|      0|#define allocSExp		Rf_allocSExp
  ------------------
              		    SETCDR(t, allocSExp(LISTSXP));
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
 2219|      0|		    SET_TAG(CDR(t), nlist);
 2220|      0|		    if (MAYBE_REFERENCED(val)) ENSURE_NAMEDMAX(val);
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2221|      0|		    SETCADR(t, val);
 2222|      0|		    break;
 2223|      0|		}
 2224|      0|	}
 2225|      0|	if (x == R_NilValue && val != R_NilValue) {
  ------------------
  |  Branch (2225:6): [True: 0, False: 0]
  |  Branch (2225:25): [True: 0, False: 0]
  ------------------
 2226|      0|	    x = allocList(1);
  ------------------
  |  |  871|      0|#define allocList		Rf_allocList
  ------------------
 2227|      0|	    if (MAYBE_REFERENCED(val)) ENSURE_NAMEDMAX(val);
  ------------------
  |  |  251|      0|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2228|      0|	    SETCAR(x, val);
 2229|      0|	    SET_TAG(x, nlist);
 2230|      0|	}
 2231|      0|    }
 2232|       |    /* cannot use isEnvironment since we do not want NULL here */
 2233|   770k|    else if( TYPEOF(x) == ENVSXP ) {
  ------------------
  |  |  115|   770k|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (2233:14): [True: 56, False: 770k]
  ------------------
 2234|     56|	defineVar(nlist, val, x);
  ------------------
  |  |  905|     56|#define defineVar		Rf_defineVar
  ------------------
 2235|     56|	INCREMENT_NAMED(val);
  ------------------
  |  |  222|     56|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  ------------------
  |  |  |  Branch (222:43): [Folded, False: 56]
  |  |  ------------------
  ------------------
 2236|     56|    }
 2237|   770k|    else if( TYPEOF(x) == SYMSXP || /* Used to 'work' in R < 2.8.0 */
  ------------------
  |  |  112|  1.54M|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (2237:14): [True: 0, False: 770k]
  ------------------
 2238|   770k|	     TYPEOF(x) == CLOSXP ||
  ------------------
  |  |  114|  1.54M|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (2238:7): [True: 0, False: 770k]
  ------------------
 2239|   770k|	     TYPEOF(x) == SPECIALSXP ||
  ------------------
  |  |  118|  1.54M|#define SPECIALSXP   7	  /* special forms */
  ------------------
  |  Branch (2239:7): [True: 0, False: 770k]
  ------------------
 2240|   770k|	     TYPEOF(x) == BUILTINSXP) {
  ------------------
  |  |  119|   770k|#define BUILTINSXP   8	  /* builtin non-special forms */
  ------------------
  |  Branch (2240:7): [True: 0, False: 770k]
  ------------------
 2241|      0|	errorNotSubsettable(x);
 2242|      0|    }
 2243|   770k|    else {
 2244|   770k|	R_xlen_t i, imatch, nx;
 2245|   770k|	SEXP names;
 2246|   770k|	int type = VECSXP;
  ------------------
  |  |  131|   770k|#define VECSXP	    19	  /* generic vectors */
  ------------------
 2247|       |
 2248|   770k|	if (isExpression(x))
  ------------------
  |  |  945|   770k|#define isExpression		Rf_isExpression
  ------------------
  |  Branch (2248:6): [True: 0, False: 770k]
  ------------------
 2249|      0|	    type = EXPRSXP;
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
 2250|   770k|	else if (!isNewList(x)) {
  ------------------
  |  |  955|   770k|#define isNewList		Rf_isNewList
  ------------------
  |  Branch (2250:11): [True: 0, False: 770k]
  ------------------
 2251|      0|	    warning(_("Coercing LHS to a list"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("Coercing LHS to a list"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2252|      0|	    REPROTECT(x = coerceVector(x, VECSXP), pxidx);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 2253|      0|	}
 2254|   770k|	names = PROTECT(getAttrib(x, R_NamesSymbol));
  ------------------
  |  |  357|   770k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2255|   770k|	nprotect++;
 2256|   770k|	nx = xlength(x);
  ------------------
  |  | 1049|   770k|#define xlength(x)		Rf_xlength(x)
  ------------------
 2257|   770k|	nlist = PRINTNAME(nlist);
 2258|   770k|	if (isNull(val)) {
  ------------------
  |  |  956|   770k|#define isNull			Rf_isNull
  ------------------
  |  Branch (2258:6): [True: 0, False: 770k]
  ------------------
 2259|       |	    /* If "val" is NULL, this is an element deletion */
 2260|       |	    /* if there is a match to "nlist" otherwise "x" */
 2261|       |	    /* is unchanged.  The attributes need adjustment. */
 2262|      0|	    if (names != R_NilValue) {
  ------------------
  |  Branch (2262:10): [True: 0, False: 0]
  ------------------
 2263|      0|		imatch = -1;
 2264|      0|		for (i = 0; i < nx; i++)
  ------------------
  |  Branch (2264:15): [True: 0, False: 0]
  ------------------
 2265|      0|		    if (NonNullStringMatch(STRING_ELT(names, i), nlist)) {
  ------------------
  |  | 1007|      0|#define NonNullStringMatch	Rf_NonNullStringMatch
  ------------------
  |  Branch (2265:11): [True: 0, False: 0]
  ------------------
 2266|      0|			imatch = i;
 2267|      0|			break;
 2268|      0|		    }
 2269|      0|		if (imatch >= 0) {
  ------------------
  |  Branch (2269:7): [True: 0, False: 0]
  ------------------
 2270|      0|		    SEXP ans, ansnames;
 2271|      0|		    int ii;
 2272|      0|		    PROTECT(ans = allocVector(type, nx - 1));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2273|      0|		    PROTECT(ansnames = allocVector(STRSXP, nx - 1));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2274|      0|		    for (i = 0, ii = 0; i < nx; i++) {
  ------------------
  |  Branch (2274:27): [True: 0, False: 0]
  ------------------
 2275|      0|			if (i != imatch) {
  ------------------
  |  Branch (2275:8): [True: 0, False: 0]
  ------------------
 2276|      0|			    SET_VECTOR_ELT(ans, ii, VECTOR_ELT(x, i));
 2277|      0|			    SET_STRING_ELT(ansnames, ii, STRING_ELT(names, i));
 2278|      0|			    ii++;
 2279|      0|			}
 2280|      0|		    }
 2281|      0|		    setAttrib(ans, R_NamesSymbol, ansnames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 2282|      0|		    copyMostAttrib(x, ans);
  ------------------
  |  |  901|      0|#define copyMostAttrib		Rf_copyMostAttrib
  ------------------
 2283|      0|		    UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2284|      0|		    CLEAR_VECTOR(x); // OK since x != ans
  ------------------
  |  |  108|      0|# define CLEAR_VECTOR(x) do {					\
  |  |  109|      0|	if (TYPEOF(x) == EXPRSXP || TYPEOF(x) == VECSXP) {	\
  |  |  ------------------
  |  |  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  ------------------
  |  |               	if (TYPEOF(x) == EXPRSXP || TYPEOF(x) == VECSXP) {	\
  |  |  ------------------
  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (109:6): [True: 0, False: 0]
  |  |  |  Branch (109:30): [True: 0, False: 0]
  |  |  ------------------
  |  |  110|      0|	    R_xlen_t len = XLENGTH(x);				\
  |  |  111|      0|	    for (R_xlen_t i = 0; i < len; i++)			\
  |  |  ------------------
  |  |  |  Branch (111:27): [True: 0, False: 0]
  |  |  ------------------
  |  |  112|      0|		SET_VECTOR_ELT(x, i, R_NilValue);		\
  |  |  113|      0|	}							\
  |  |  114|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (114:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2285|      0|		    x = ans;
 2286|      0|		}
 2287|       |		/* else x is unchanged */
 2288|      0|	    }
 2289|      0|	}
 2290|   770k|	else {
 2291|       |	    /* If "val" is non-NULL, we are either replacing */
 2292|       |	    /* an existing list element or we are adding a new */
 2293|       |	    /* element. */
 2294|   770k|	    imatch = -1;
 2295|   770k|	    if (!isNull(names)) {
  ------------------
  |  |  956|   770k|#define isNull			Rf_isNull
  ------------------
  |  Branch (2295:10): [True: 770k, False: 0]
  ------------------
 2296|  1.15M|		for (i = 0; i < nx; i++)
  ------------------
  |  Branch (2296:15): [True: 1.15M, False: 54]
  ------------------
 2297|  1.15M|		    if (NonNullStringMatch(STRING_ELT(names, i), nlist)) {
  ------------------
  |  | 1007|  1.15M|#define NonNullStringMatch	Rf_NonNullStringMatch
  ------------------
  |  Branch (2297:11): [True: 770k, False: 385k]
  ------------------
 2298|   770k|			imatch = i;
 2299|   770k|			break;
 2300|   770k|		    }
 2301|   770k|	    }
 2302|   770k|	    if (imatch >= 0) {
  ------------------
  |  Branch (2302:10): [True: 770k, False: 54]
  ------------------
 2303|       |		/* We are just replacing an element */
 2304|       |		/* Here we need to check for cycles*/
 2305|   770k|		if (MAYBE_REFERENCED(val) && VECTOR_ELT(x, imatch) != val)
  ------------------
  |  |  251|  1.54M|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 385k, False: 385k]
  |  |  ------------------
  ------------------
  |  Branch (2305:32): [True: 385k, False: 40]
  ------------------
 2306|   385k|		    REPROTECT(val = R_FixupRHS(x, val), pvalidx);
  ------------------
  |  |  367|   385k|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 2307|   770k|		SET_VECTOR_ELT(x, imatch, val);
 2308|   770k|	    }
 2309|     54|	    else {
 2310|       |		/* We are introducing a new element (=> *no* duplication) */
 2311|       |		/* Enlarge the list, add the new element */
 2312|       |		/* and finally, adjust the attributes. */
 2313|     54|		SEXP ans, ansnames;
 2314|     54|		PROTECT(ans = allocVector(VECSXP, nx + 1));
  ------------------
  |  |  357|     54|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2315|     54|		PROTECT(ansnames = allocVector(STRSXP, nx + 1));
  ------------------
  |  |  357|     54|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2316|    297|		for (i = 0; i < nx; i++)
  ------------------
  |  Branch (2316:15): [True: 243, False: 54]
  ------------------
 2317|    243|		    SET_VECTOR_ELT(ans, i, VECTOR_ELT(x, i));
 2318|     54|		if (isNull(names)) {
  ------------------
  |  |  956|     54|#define isNull			Rf_isNull
  ------------------
  |  Branch (2318:7): [True: 0, False: 54]
  ------------------
 2319|      0|		    for (i = 0; i < nx; i++)
  ------------------
  |  Branch (2319:19): [True: 0, False: 0]
  ------------------
 2320|      0|			SET_STRING_ELT(ansnames, i, R_BlankString);
 2321|      0|		}
 2322|     54|		else {
 2323|    297|		    for (i = 0; i < nx; i++)
  ------------------
  |  Branch (2323:19): [True: 243, False: 54]
  ------------------
 2324|    243|			SET_STRING_ELT(ansnames, i, STRING_ELT(names, i));
 2325|     54|		}
 2326|     54|		if (MAYBE_REFERENCED(val)) ENSURE_NAMEDMAX(val);
  ------------------
  |  |  251|     54|#define MAYBE_REFERENCED(x) (! NO_REFERENCES(x))
  |  |  ------------------
  |  |  |  Branch (251:29): [True: 54, False: 0]
  |  |  ------------------
  ------------------
 2327|     54|		SET_VECTOR_ELT(ans, nx, val);
 2328|     54|		SET_STRING_ELT(ansnames, nx,  nlist);
 2329|     54|		setAttrib(ans, R_NamesSymbol, ansnames);
  ------------------
  |  | 1027|     54|#define setAttrib		Rf_setAttrib
  ------------------
 2330|     54|		copyMostAttrib(x, ans);
  ------------------
  |  |  901|     54|#define copyMostAttrib		Rf_copyMostAttrib
  ------------------
 2331|     54|		UNPROTECT(2);
  ------------------
  |  |  358|     54|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2332|     54|		CLEAR_VECTOR(x); // OK since x != ans
  ------------------
  |  |  108|     54|# define CLEAR_VECTOR(x) do {					\
  |  |  109|     54|	if (TYPEOF(x) == EXPRSXP || TYPEOF(x) == VECSXP) {	\
  |  |  ------------------
  |  |  |  |  132|    108|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  ------------------
  |  |               	if (TYPEOF(x) == EXPRSXP || TYPEOF(x) == VECSXP) {	\
  |  |  ------------------
  |  |  |  |  131|     54|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (109:6): [True: 0, False: 54]
  |  |  |  Branch (109:30): [True: 54, False: 0]
  |  |  ------------------
  |  |  110|     54|	    R_xlen_t len = XLENGTH(x);				\
  |  |  111|    297|	    for (R_xlen_t i = 0; i < len; i++)			\
  |  |  ------------------
  |  |  |  Branch (111:27): [True: 243, False: 54]
  |  |  ------------------
  |  |  112|    243|		SET_VECTOR_ELT(x, i, R_NilValue);		\
  |  |  113|     54|	}							\
  |  |  114|     54|    } while (0)
  |  |  ------------------
  |  |  |  Branch (114:14): [Folded, False: 54]
  |  |  ------------------
  ------------------
 2333|     54|		x = ans;
 2334|     54|	    }
 2335|   770k|	}
 2336|   770k|    }
 2337|   770k|    UNPROTECT(nprotect);
  ------------------
  |  |  358|   770k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2338|   770k|    if(xS4 != R_NilValue)
  ------------------
  |  Branch (2338:8): [True: 0, False: 770k]
  ------------------
 2339|      0|	x = xS4; /* x was an env't, the data slot of xS4 */
 2340|   770k|    SETTER_CLEAR_NAMED(x);
 2341|   770k|    if(S4) SET_S4_OBJECT(x);
  ------------------
  |  Branch (2341:8): [True: 0, False: 770k]
  ------------------
 2342|   770k|    return x;
 2343|   770k|}
subassign.c:R_DispatchOrEvalSP:
 1555|     16|{
 1556|     16|    SEXP prom = NULL;
 1557|     16|    if (args != R_NilValue && CAR(args) != R_DotsSymbol) {
  ------------------
  |  Branch (1557:9): [True: 16, False: 0]
  |  Branch (1557:31): [True: 16, False: 0]
  ------------------
 1558|     16|	SEXP x = eval(CAR(args), rho);
  ------------------
  |  |  913|     16|#define eval			Rf_eval
  ------------------
 1559|     16|	PROTECT(x);
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1560|     16|	INCREMENT_LINKS(x);
  ------------------
  |  |  540|     16|#define INCREMENT_LINKS(x) do {			\
  |  |  541|     16|	SEXP il__x__ = (x);			\
  |  |  542|     16|	INCREMENT_NAMED(il__x__);		\
  |  |  ------------------
  |  |  |  |  222|     16|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 16]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  543|     16|	INCREMENT_REFCNT(il__x__);		\
  |  |  544|     16|    } while (0)
  |  |  ------------------
  |  |  |  Branch (544:14): [Folded, False: 16]
  |  |  ------------------
  ------------------
 1561|     16|	if (! OBJECT(x)) {
  ------------------
  |  Branch (1561:6): [True: 16, False: 0]
  ------------------
 1562|     16|	    *ans = CONS_NR(x, evalListKeepMissing(CDR(args), rho));
  ------------------
  |  | 1899|     16|# define evalListKeepMissing	Rf_evalListKeepMissing
  ------------------
 1563|     16|	    DECREMENT_LINKS(x);
  ------------------
  |  |  545|     16|#define DECREMENT_LINKS(x) do {			\
  |  |  546|     16|	SEXP dl__x__ = (x);			\
  |  |  547|     16|	DECREMENT_NAMED(dl__x__);		\
  |  |  ------------------
  |  |  |  |  223|     16|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (223:43): [Folded, False: 16]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  548|     16|	DECREMENT_REFCNT(dl__x__);		\
  |  |  549|     16|    } while (0)
  |  |  ------------------
  |  |  |  Branch (549:14): [Folded, False: 16]
  |  |  ------------------
  ------------------
 1564|     16|	    UNPROTECT(1);
  ------------------
  |  |  358|     16|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1565|     16|	    return false;
 1566|     16|	}
 1567|      0|	prom = R_mkEVPROMISE_NR(CAR(args), x);
 1568|      0|	args = CONS(prom, CDR(args));
  ------------------
  |  |  309|      0|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
 1569|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1570|      0|    }
 1571|      0|    PROTECT(args);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1572|      0|    int disp = DispatchOrEval(call, op, generic, args, rho, ans, 0, 0);
  ------------------
  |  | 1887|      0|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
 1573|      0|    if (prom) DECREMENT_LINKS(PRVALUE(prom));
  ------------------
  |  |  545|      0|#define DECREMENT_LINKS(x) do {			\
  |  |  546|      0|	SEXP dl__x__ = (x);			\
  |  |  547|      0|	DECREMENT_NAMED(dl__x__);		\
  |  |  ------------------
  |  |  |  |  223|      0|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (223:43): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  548|      0|	DECREMENT_REFCNT(dl__x__);		\
  |  |  549|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (549:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (1573:9): [True: 0, False: 0]
  ------------------
 1574|      0|    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1575|      0|    return disp;
 1576|     16|}
subassign.c:SubAssignArgs:
 1527|  1.69k|{
 1528|  1.69k|    if (CDR(args) == R_NilValue)
  ------------------
  |  Branch (1528:9): [True: 0, False: 1.69k]
  ------------------
 1529|      0|	error(_("SubAssignArgs: invalid number of arguments"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("SubAssignArgs: invalid number of arguments"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1530|  1.69k|    *x = CAR(args);
 1531|  1.69k|    if (CDDR(args) == R_NilValue) {
  ------------------
  |  Branch (1531:9): [True: 0, False: 1.69k]
  ------------------
 1532|      0|	*s = R_NilValue;
 1533|      0|	*y = CADR(args);
 1534|      0|	return 0;
 1535|      0|    }
 1536|  1.69k|    else {
 1537|  1.69k|	int nsubs = 1;
 1538|  1.69k|	SEXP p;
 1539|  1.69k|	*s = p = CDR(args);
 1540|  1.70k|	while (CDDR(p) != R_NilValue) {
  ------------------
  |  Branch (1540:9): [True: 8, False: 1.69k]
  ------------------
 1541|      8|	    p = CDR(p);
 1542|      8|	    nsubs++;
 1543|      8|	}
 1544|  1.69k|	*y = CADR(p);
 1545|  1.69k|	SETCDR(p, R_NilValue);
 1546|  1.69k|	return nsubs;
 1547|  1.69k|    }
 1548|  1.69k|}
subassign.c:VectorAssign:
  623|    263|{
  624|       |    /* try for quick return for simple scalar case */
  625|    263|    if (ATTRIB(s) == R_NilValue) {
  ------------------
  |  Branch (625:9): [True: 263, False: 0]
  ------------------
  626|    263|	if (TYPEOF(x) == REALSXP && IS_SCALAR(y, REALSXP)) {
  ------------------
  |  |  124|    526|#define REALSXP	    14	  /* real variables */
  ------------------
              	if (TYPEOF(x) == REALSXP && IS_SCALAR(y, REALSXP)) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (626:6): [True: 0, False: 263]
  |  Branch (626:30): [True: 0, False: 0]
  ------------------
  627|      0|	    if (IS_SCALAR(s, INTSXP)) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (627:10): [True: 0, False: 0]
  ------------------
  628|      0|		R_xlen_t ival = SCALAR_IVAL(s);
  629|      0|		if (1 <= ival && ival <= XLENGTH(x)) {
  ------------------
  |  Branch (629:7): [True: 0, False: 0]
  |  Branch (629:20): [True: 0, False: 0]
  ------------------
  630|      0|		    REAL(x)[ival - 1] = SCALAR_DVAL(y);
  631|      0|		    return x;
  632|      0|		}
  633|      0|	    }
  634|      0|	    else if (IS_SCALAR(s, REALSXP)) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (634:15): [True: 0, False: 0]
  ------------------
  635|      0|		double dval = SCALAR_DVAL(s);
  636|      0|		if (R_FINITE(dval)) {
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (636:7): [True: 0, False: 0]
  ------------------
  637|      0|		    R_xlen_t ival = (R_xlen_t) dval;
  638|      0|		    if (1 <= ival && ival <= XLENGTH(x)) {
  ------------------
  |  Branch (638:11): [True: 0, False: 0]
  |  Branch (638:24): [True: 0, False: 0]
  ------------------
  639|      0|			REAL(x)[ival - 1] = SCALAR_DVAL(y);
  640|      0|			return x;
  641|      0|		    }
  642|      0|		}
  643|      0|	    }
  644|      0|	}
  645|    263|    }
  646|       |
  647|    263|    if (isNull(x) && isNull(y)) {
  ------------------
  |  |  956|    263|#define isNull			Rf_isNull
  ------------------
                  if (isNull(x) && isNull(y)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (647:9): [True: 0, False: 263]
  |  Branch (647:22): [True: 0, False: 0]
  ------------------
  648|      0|	return R_NilValue;
  649|      0|    }
  650|       |
  651|       |    /* Check to see if we have special matrix subscripting. */
  652|       |    /* If so, we manufacture a real subscript vector. */
  653|    263|    PROTECT(s);
  ------------------
  |  |  357|    263|#define PROTECT(s)	Rf_protect(s)
  ------------------
  654|    263|    if (ATTRIB(s) != R_NilValue) { /* pretest to speed up simple case */
  ------------------
  |  Branch (654:9): [True: 0, False: 263]
  ------------------
  655|      0|	SEXP dim = getAttrib(x, R_DimSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  656|      0|	if (isMatrix(s) && isArray(x) && ncols(s) == length(dim)) {
  ------------------
  |  |  954|      0|#define isMatrix		Rf_isMatrix
  ------------------
              	if (isMatrix(s) && isArray(x) && ncols(s) == length(dim)) {
  ------------------
  |  |  940|      0|#define isArray			Rf_isArray
  ------------------
              	if (isMatrix(s) && isArray(x) && ncols(s) == length(dim)) {
  ------------------
  |  | 1005|      0|#define ncols			Rf_ncols
  ------------------
              	if (isMatrix(s) && isArray(x) && ncols(s) == length(dim)) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (656:6): [True: 0, False: 0]
  |  Branch (656:21): [True: 0, False: 0]
  |  Branch (656:35): [True: 0, False: 0]
  ------------------
  657|      0|	    if (isString(s)) {
  ------------------
  |  |  966|      0|#define isString		Rf_isString
  ------------------
  |  Branch (657:10): [True: 0, False: 0]
  ------------------
  658|      0|		SEXP dnames = PROTECT(GetArrayDimnames(x));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  659|      0|		s = strmat2intmat(s, dnames, call, x);
  ------------------
  |  | 1995|      0|# define strmat2intmat		Rf_strmat2intmat
  ------------------
  660|      0|		UNPROTECT(2); /* dnames, s */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  661|      0|		PROTECT(s);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  662|      0|	    }
  663|      0|	    if (isInteger(s) || isReal(s)) {
  ------------------
  |  |  949|      0|#define isInteger		Rf_isInteger
  ------------------
              	    if (isInteger(s) || isReal(s)) {
  ------------------
  |  |  963|      0|#define isReal			Rf_isReal
  ------------------
  |  Branch (663:10): [True: 0, False: 0]
  |  Branch (663:26): [True: 0, False: 0]
  ------------------
  664|      0|		s = mat2indsub(dim, s, R_NilValue, x);
  ------------------
  |  | 1943|      0|# define mat2indsub		Rf_mat2indsub
  ------------------
  665|       |		//                     .......... or call, as in VectorSubset() [subset.c]?
  666|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  667|      0|		PROTECT(s);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  668|      0|	    }
  669|      0|	}
  670|      0|    }
  671|       |
  672|    263|    R_xlen_t stretch = 1;
  673|    263|    SEXP indx = PROTECT(makeSubscript(x, s, &stretch, R_NilValue));
  ------------------
  |  |  357|    263|#define PROTECT(s)	Rf_protect(s)
  ------------------
  674|    263|    R_xlen_t i, ii, n = xlength(indx);
  ------------------
  |  | 1049|    263|#define xlength(x)		Rf_xlength(x)
  ------------------
  675|    263|    if(xlength(y) > 1)
  ------------------
  |  | 1049|    263|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (675:8): [True: 94, False: 169]
  ------------------
  676|    309|	for(i = 0; i < n; i++)
  ------------------
  |  Branch (676:13): [True: 215, False: 94]
  ------------------
  677|    215|	    if(gi(indx, i) == NA_INTEGER)
  ------------------
  |  |   56|    215|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (677:9): [True: 0, False: 215]
  ------------------
  678|      0|		error(_("NAs are not allowed in subscripted assignments"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("NAs are not allowed in subscripted assignments"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  679|       |
  680|       |    /* Here we make sure that the LHS has */
  681|       |    /* been coerced into a form which can */
  682|       |    /* accept elements from the RHS. */
  683|    263|    SEXP old_x = x;
  684|    263|    int which = SubassignTypeFix(&x, &y, stretch, 1, call, rho);
  685|       |    /* = 100 * TYPEOF(x) + TYPEOF(y);*/
  686|    263|    if (n == 0) {
  ------------------
  |  Branch (686:9): [True: 4, False: 259]
  ------------------
  687|      4|	UNPROTECT(2);
  ------------------
  |  |  358|      4|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  688|      4|	return x;
  689|      4|    }
  690|    259|    R_xlen_t
  691|    259|	ny = xlength(y),
  ------------------
  |  | 1049|    259|#define xlength(x)		Rf_xlength(x)
  ------------------
  692|    259|	nx = xlength(x), iny;
  ------------------
  |  | 1049|    259|#define xlength(x)		Rf_xlength(x)
  ------------------
  693|       |
  694|    259|    PROTECT(x);
  ------------------
  |  |  357|    259|#define PROTECT(s)	Rf_protect(s)
  ------------------
  695|       |
  696|    259|    if ((TYPEOF(x) != VECSXP && TYPEOF(x) != EXPRSXP) || y != R_NilValue) {
  ------------------
  |  |  131|    518|#define VECSXP	    19	  /* generic vectors */
  ------------------
                  if ((TYPEOF(x) != VECSXP && TYPEOF(x) != EXPRSXP) || y != R_NilValue) {
  ------------------
  |  |  132|     96|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (696:10): [True: 96, False: 163]
  |  Branch (696:33): [True: 96, False: 0]
  |  Branch (696:58): [True: 163, False: 0]
  ------------------
  697|    259|	PROTECT(y);
  ------------------
  |  |  357|    259|#define PROTECT(s)	Rf_protect(s)
  ------------------
  698|    259|	if (n > 0 && ny == 0)
  ------------------
  |  Branch (698:6): [True: 259, False: 0]
  |  Branch (698:15): [True: 0, False: 259]
  ------------------
  699|      0|	    error(_("replacement has length zero"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("replacement has length zero"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  700|    259|	if (n > 0 && n % ny)
  ------------------
  |  Branch (700:6): [True: 259, False: 0]
  |  Branch (700:15): [True: 0, False: 259]
  ------------------
  701|      0|	    warning(_("number of items to replace is not a multiple of replacement length"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("number of items to replace is not a multiple of replacement length"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  702|    259|	UNPROTECT(1);
  ------------------
  |  |  358|    259|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  703|    259|    }
  704|       |
  705|       |
  706|       |    /* When array elements are being permuted the RHS */
  707|       |    /* must be duplicated or the elements get trashed. */
  708|       |    /* FIXME : this should be a shallow copy for list */
  709|       |    /* objects.  A full duplication is wasteful. */
  710|       |
  711|    259|    if (x == y)
  ------------------
  |  Branch (711:9): [True: 0, False: 259]
  ------------------
  712|      0|	PROTECT(y = shallow_duplicate(y));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  713|    259|    else
  714|    259|	PROTECT(y);
  ------------------
  |  |  357|    259|#define PROTECT(s)	Rf_protect(s)
  ------------------
  715|       |
  716|       |    /* Note that we are now committed. */
  717|       |    /* Since we are mutating existing objects, */
  718|       |    /* any changes we make now are (likely to be) permanent.  Beware! */
  719|       |
  720|    259|    switch(which) {
  721|       |	/* because we have called SubassignTypeFix the commented
  722|       |	   values cannot occur (and would be unsafe) */
  723|       |
  724|      0|    case 1010:	/* logical   <- logical	  */
  ------------------
  |  Branch (724:5): [True: 0, False: 259]
  ------------------
  725|      0|    case 1310:	/* integer   <- logical	  */
  ------------------
  |  Branch (725:5): [True: 0, False: 259]
  ------------------
  726|       |    /* case 1013:  logical   <- integer	  */
  727|     90|    case 1313:	/* integer   <- integer	  */
  ------------------
  |  Branch (727:5): [True: 90, False: 169]
  ------------------
  728|       |
  729|     90|	{
  730|     90|	    int *px = INTEGER(x);
  731|     90|	    VECTOR_ASSIGN_LOOP(px[ii] = INTEGER_ELT(y, iny););
  ------------------
  |  |  600|     90|#define VECTOR_ASSIGN_LOOP(CODE) do {			\
  |  |  601|     90|	if (TYPEOF(indx) == INTSXP) {			\
  |  |  ------------------
  |  |  |  |  123|     90|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (601:6): [True: 90, False: 0]
  |  |  ------------------
  |  |  602|     90|	    const int *pindx = INTEGER_RO(indx);	\
  |  |  603|     90|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|     90|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|     90|	i = i1 = 0;					\
  |  |  |  |   69|     90|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|     90|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|    279|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 189, False: 90]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|    189|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 189, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|    189|		 ++i) {							\
  |  |  |  |  |  |   63|    567|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 189]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 189]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    189|		}							\
  |  |  |  |  |  |   65|     90|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 90]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|     90|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 90]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  604|     90|		    ii = pindx[i];			\
  |  |  605|     90|		    if (ii == NA_INTEGER) continue;	\
  |  |  606|     90|		    ii = ii - 1;			\
  |  |  607|     90|		    do { CODE } while (0);		\
  |  |  608|     90|		});					\
  |  |  609|     90|	}						\
  |  |  610|     90|	else /* could specialize this to REALSXP case */\
  |  |  611|     90|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  612|     90|		    ii = gi(indx, i);			\
  |  |  613|     90|		    if (ii == NA_INTEGER) continue;	\
  |  |  614|     90|		    ii = ii - 1;			\
  |  |  615|     90|		    do { CODE } while (0);		\
  |  |  616|     90|		});					\
  |  |  617|     90|    } while (0)
  |  |  ------------------
  |  |  |  Branch (617:14): [Folded, False: 90]
  |  |  ------------------
  ------------------
  732|     90|	}
  733|     90|	break;
  734|       |
  735|      0|    case 1410:	/* real	     <- logical	  */
  ------------------
  |  Branch (735:5): [True: 0, False: 259]
  ------------------
  736|      0|    case 1413:	/* real	     <- integer	  */
  ------------------
  |  Branch (736:5): [True: 0, False: 259]
  ------------------
  737|       |
  738|      0|	{
  739|      0|	    double *px = REAL(x);
  740|      0|	    VECTOR_ASSIGN_LOOP({
  ------------------
  |  |  600|      0|#define VECTOR_ASSIGN_LOOP(CODE) do {			\
  |  |  601|      0|	if (TYPEOF(indx) == INTSXP) {			\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (601:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  602|      0|	    const int *pindx = INTEGER_RO(indx);	\
  |  |  603|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  604|      0|		    ii = pindx[i];			\
  |  |  605|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  606|      0|		    ii = ii - 1;			\
  |  |  607|      0|		    do { CODE } while (0);		\
  |  |  608|      0|		});					\
  |  |  609|      0|	}						\
  |  |  610|      0|	else /* could specialize this to REALSXP case */\
  |  |  611|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  612|      0|		    ii = gi(indx, i);			\
  |  |  613|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  614|      0|		    ii = ii - 1;			\
  |  |  615|      0|		    do { CODE } while (0);		\
  |  |  616|      0|		});					\
  |  |  617|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (617:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  741|      0|		    int iy = INTEGER_ELT(y, iny);
  742|      0|		    if (iy == NA_INTEGER)
  743|      0|			px[ii] = NA_REAL;
  744|      0|		    else
  745|      0|			px[ii] = iy;
  746|      0|		});
  747|      0|	}
  748|      0|	break;
  749|       |
  750|       |    /* case 1014:  logical   <- real	  */
  751|       |    /* case 1314:  integer   <- real	  */
  752|      0|    case 1414:	/* real	     <- real	  */
  ------------------
  |  Branch (752:5): [True: 0, False: 259]
  ------------------
  753|       |
  754|      0|	{
  755|      0|	    double *px = REAL(x);
  756|      0|	    VECTOR_ASSIGN_LOOP(px[ii] = REAL_ELT(y, iny););
  ------------------
  |  |  600|      0|#define VECTOR_ASSIGN_LOOP(CODE) do {			\
  |  |  601|      0|	if (TYPEOF(indx) == INTSXP) {			\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (601:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  602|      0|	    const int *pindx = INTEGER_RO(indx);	\
  |  |  603|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  604|      0|		    ii = pindx[i];			\
  |  |  605|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  606|      0|		    ii = ii - 1;			\
  |  |  607|      0|		    do { CODE } while (0);		\
  |  |  608|      0|		});					\
  |  |  609|      0|	}						\
  |  |  610|      0|	else /* could specialize this to REALSXP case */\
  |  |  611|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  612|      0|		    ii = gi(indx, i);			\
  |  |  613|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  614|      0|		    ii = ii - 1;			\
  |  |  615|      0|		    do { CODE } while (0);		\
  |  |  616|      0|		});					\
  |  |  617|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (617:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  757|      0|	}
  758|      0|	break;
  759|       |
  760|      0|    case 1510:	/* complex   <- logical	  */
  ------------------
  |  Branch (760:5): [True: 0, False: 259]
  ------------------
  761|      0|    case 1513:	/* complex   <- integer	  */
  ------------------
  |  Branch (761:5): [True: 0, False: 259]
  ------------------
  762|       |
  763|      0|	{
  764|      0|	    Rcomplex *px = COMPLEX(x);
  765|      0|	    VECTOR_ASSIGN_LOOP({
  ------------------
  |  |  600|      0|#define VECTOR_ASSIGN_LOOP(CODE) do {			\
  |  |  601|      0|	if (TYPEOF(indx) == INTSXP) {			\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (601:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  602|      0|	    const int *pindx = INTEGER_RO(indx);	\
  |  |  603|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  604|      0|		    ii = pindx[i];			\
  |  |  605|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  606|      0|		    ii = ii - 1;			\
  |  |  607|      0|		    do { CODE } while (0);		\
  |  |  608|      0|		});					\
  |  |  609|      0|	}						\
  |  |  610|      0|	else /* could specialize this to REALSXP case */\
  |  |  611|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  612|      0|		    ii = gi(indx, i);			\
  |  |  613|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  614|      0|		    ii = ii - 1;			\
  |  |  615|      0|		    do { CODE } while (0);		\
  |  |  616|      0|		});					\
  |  |  617|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (617:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  766|      0|		    int iy = INTEGER_ELT(y, iny);
  767|      0|		    if (iy == NA_INTEGER) {
  768|      0|			px[ii].r = NA_REAL;
  769|      0|			px[ii].i = 0.0;
  770|      0|		    }
  771|      0|		    else {
  772|      0|			px[ii].r = iy;
  773|      0|			px[ii].i = 0.0;
  774|      0|		    }
  775|      0|		});
  776|      0|	}
  777|      0|	break;
  778|       |
  779|      0|    case 1514:	/* complex   <- real	  */
  ------------------
  |  Branch (779:5): [True: 0, False: 259]
  ------------------
  780|       |
  781|      0|	{
  782|      0|	    Rcomplex *px = COMPLEX(x);
  783|      0|	    VECTOR_ASSIGN_LOOP({
  ------------------
  |  |  600|      0|#define VECTOR_ASSIGN_LOOP(CODE) do {			\
  |  |  601|      0|	if (TYPEOF(indx) == INTSXP) {			\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (601:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  602|      0|	    const int *pindx = INTEGER_RO(indx);	\
  |  |  603|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  604|      0|		    ii = pindx[i];			\
  |  |  605|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  606|      0|		    ii = ii - 1;			\
  |  |  607|      0|		    do { CODE } while (0);		\
  |  |  608|      0|		});					\
  |  |  609|      0|	}						\
  |  |  610|      0|	else /* could specialize this to REALSXP case */\
  |  |  611|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  612|      0|		    ii = gi(indx, i);			\
  |  |  613|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  614|      0|		    ii = ii - 1;			\
  |  |  615|      0|		    do { CODE } while (0);		\
  |  |  616|      0|		});					\
  |  |  617|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (617:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  784|      0|		    double ry = REAL_ELT(y, iny);
  785|      0|		    if (ISNA(ry)) {
  786|      0|			px[ii].r = NA_REAL;
  787|      0|			px[ii].i = 0.0;
  788|      0|		    }
  789|      0|		    else {
  790|      0|			px[ii].r = ry;
  791|      0|			px[ii].i = 0.0;
  792|      0|		    }
  793|      0|		});
  794|      0|	}
  795|      0|	break;
  796|       |
  797|       |    /* case 1015:  logical   <- complex	  */
  798|       |    /* case 1315:  integer   <- complex	  */
  799|       |    /* case 1415:  real	     <- complex	  */
  800|      0|    case 1515:	/* complex   <- complex	  */
  ------------------
  |  Branch (800:5): [True: 0, False: 259]
  ------------------
  801|       |
  802|      0|	{
  803|      0|	    Rcomplex *px = COMPLEX(x);
  804|      0|	    VECTOR_ASSIGN_LOOP(px[ii] = COMPLEX_ELT(y, iny););
  ------------------
  |  |  600|      0|#define VECTOR_ASSIGN_LOOP(CODE) do {			\
  |  |  601|      0|	if (TYPEOF(indx) == INTSXP) {			\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (601:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  602|      0|	    const int *pindx = INTEGER_RO(indx);	\
  |  |  603|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  604|      0|		    ii = pindx[i];			\
  |  |  605|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  606|      0|		    ii = ii - 1;			\
  |  |  607|      0|		    do { CODE } while (0);		\
  |  |  608|      0|		});					\
  |  |  609|      0|	}						\
  |  |  610|      0|	else /* could specialize this to REALSXP case */\
  |  |  611|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  612|      0|		    ii = gi(indx, i);			\
  |  |  613|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  614|      0|		    ii = ii - 1;			\
  |  |  615|      0|		    do { CODE } while (0);		\
  |  |  616|      0|		});					\
  |  |  617|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (617:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  805|      0|	}
  806|      0|	break;
  807|       |
  808|      0|    case 1610:	/* character <- logical	  */
  ------------------
  |  Branch (808:5): [True: 0, False: 259]
  ------------------
  809|      0|    case 1613:	/* character <- integer	  */
  ------------------
  |  Branch (809:5): [True: 0, False: 259]
  ------------------
  810|      0|    case 1614:	/* character <- real	  */
  ------------------
  |  Branch (810:5): [True: 0, False: 259]
  ------------------
  811|      0|    case 1615:	/* character <- complex	  */
  ------------------
  |  Branch (811:5): [True: 0, False: 259]
  ------------------
  812|      6|    case 1616:	/* character <- character */
  ------------------
  |  Branch (812:5): [True: 6, False: 253]
  ------------------
  813|       |    /* case 1016:  logical   <- character */
  814|       |    /* case 1316:  integer   <- character */
  815|       |    /* case 1416:  real	     <- character */
  816|       |    /* case 1516:  complex   <- character */
  817|       |
  818|      6|	VECTOR_ASSIGN_LOOP(SET_STRING_ELT(x, ii, STRING_ELT(y, iny)););
  ------------------
  |  |  600|      6|#define VECTOR_ASSIGN_LOOP(CODE) do {			\
  |  |  601|      6|	if (TYPEOF(indx) == INTSXP) {			\
  |  |  ------------------
  |  |  |  |  123|      6|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (601:6): [True: 6, False: 0]
  |  |  ------------------
  |  |  602|      6|	    const int *pindx = INTEGER_RO(indx);	\
  |  |  603|      6|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      6|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      6|	i = i1 = 0;					\
  |  |  |  |   69|      6|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      6|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|     22|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 16, False: 6]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|     16|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 6, False: 10]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|     16|		 ++i) {							\
  |  |  |  |  |  |   63|     48|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 16]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 16]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|     16|		}							\
  |  |  |  |  |  |   65|      6|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 6]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      6|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 6]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  604|      6|		    ii = pindx[i];			\
  |  |  605|      6|		    if (ii == NA_INTEGER) continue;	\
  |  |  606|      6|		    ii = ii - 1;			\
  |  |  607|      6|		    do { CODE } while (0);		\
  |  |  608|      6|		});					\
  |  |  609|      6|	}						\
  |  |  610|      6|	else /* could specialize this to REALSXP case */\
  |  |  611|      6|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  612|      6|		    ii = gi(indx, i);			\
  |  |  613|      6|		    if (ii == NA_INTEGER) continue;	\
  |  |  614|      6|		    ii = ii - 1;			\
  |  |  615|      6|		    do { CODE } while (0);		\
  |  |  616|      6|		});					\
  |  |  617|      6|    } while (0)
  |  |  ------------------
  |  |  |  Branch (617:14): [Folded, False: 6]
  |  |  ------------------
  ------------------
  819|      6|	break;
  820|       |
  821|       |    /* case 1019:  logial     <- vector   */
  822|       |    /* case 1319:  integer    <- vector   */
  823|       |    /* case 1419:  real       <- vector   */
  824|       |    /* case 1519:  complex    <- vector   */
  825|       |    /* case 1619:  character  <- vector   */
  826|       |
  827|       |    /* case 1910:  vector     <- logical    */
  828|       |    /* case 1913:  vector     <- integer    */
  829|       |    /* case 1914:  vector     <- real       */
  830|       |    /* case 1915:  vector     <- complex    */
  831|       |    /* case 1916:  vector     <- character  */
  832|       |
  833|    163|    case 1919:  /* vector     <- vector     */
  ------------------
  |  Branch (833:5): [True: 163, False: 96]
  ------------------
  834|       |
  835|    163|	VECTOR_ASSIGN_LOOP({
  ------------------
  |  |  600|    163|#define VECTOR_ASSIGN_LOOP(CODE) do {			\
  |  |  601|    163|	if (TYPEOF(indx) == INTSXP) {			\
  |  |  ------------------
  |  |  |  |  123|    163|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (601:6): [True: 163, False: 0]
  |  |  ------------------
  |  |  602|    163|	    const int *pindx = INTEGER_RO(indx);	\
  |  |  603|    163|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|    163|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|    163|	i = i1 = 0;					\
  |  |  |  |   69|    163|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|    163|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|    437|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 274, False: 163]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|    274|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 163, False: 111]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|    274|		 ++i) {							\
  |  |  |  |  |  |   63|  1.09k|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 274]
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 274]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 274]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|    274|		}							\
  |  |  |  |  |  |   65|    163|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 163]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|    163|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 163]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  604|    163|		    ii = pindx[i];			\
  |  |  605|    163|		    if (ii == NA_INTEGER) continue;	\
  |  |  606|    163|		    ii = ii - 1;			\
  |  |  607|    163|		    do { CODE } while (0);		\
  |  |  608|    163|		});					\
  |  |  609|    163|	}						\
  |  |  610|    163|	else /* could specialize this to REALSXP case */\
  |  |  611|    163|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  612|    163|		    ii = gi(indx, i);			\
  |  |  613|    163|		    if (ii == NA_INTEGER) continue;	\
  |  |  614|    163|		    ii = ii - 1;			\
  |  |  615|    163|		    do { CODE } while (0);		\
  |  |  616|    163|		});					\
  |  |  617|    163|    } while (0)
  |  |  ------------------
  |  |  |  Branch (617:14): [Folded, False: 163]
  |  |  ------------------
  ------------------
  836|       |
  837|       |		/* set NAMED on RHS value to NAMEDMAX if used more than once
  838|       |		   (PR15098) */
  839|    163|		if (i >= ny)
  840|    163|		    ENSURE_NAMEDMAX(VECTOR_ELT(y, iny));
  841|       |
  842|    163|		SET_VECTOR_ELT(x, ii, VECTOR_ELT_FIX_NAMED(y, iny));
  843|    163|	    });
  844|    163|	break;
  845|       |
  846|       |    /* case 2001: */
  847|       |    /* case 2006:  expression <- language   */
  848|       |    /* case 2010:  expression <- logical    */
  849|       |    /* case 2013:  expression <- integer    */
  850|       |    /* case 2014:  expression <- real	    */
  851|       |    /* case 2015:  expression <- complex    */
  852|       |    /* case 2016:  expression <- character  */
  853|      0|    case 2019:	/* expression <- vector, needed if we have promoted a
  ------------------
  |  Branch (853:5): [True: 0, False: 259]
  ------------------
  854|       |		   RHS  to a list */
  855|      0|    case 2020:	/* expression <- expression */
  ------------------
  |  Branch (855:5): [True: 0, False: 259]
  ------------------
  856|       |
  857|      0|	VECTOR_ASSIGN_LOOP(SET_VECTOR_ELT(x, ii, VECTOR_ELT(y, iny)););
  ------------------
  |  |  600|      0|#define VECTOR_ASSIGN_LOOP(CODE) do {			\
  |  |  601|      0|	if (TYPEOF(indx) == INTSXP) {			\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (601:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  602|      0|	    const int *pindx = INTEGER_RO(indx);	\
  |  |  603|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  604|      0|		    ii = pindx[i];			\
  |  |  605|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  606|      0|		    ii = ii - 1;			\
  |  |  607|      0|		    do { CODE } while (0);		\
  |  |  608|      0|		});					\
  |  |  609|      0|	}						\
  |  |  610|      0|	else /* could specialize this to REALSXP case */\
  |  |  611|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  612|      0|		    ii = gi(indx, i);			\
  |  |  613|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  614|      0|		    ii = ii - 1;			\
  |  |  615|      0|		    do { CODE } while (0);		\
  |  |  616|      0|		});					\
  |  |  617|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (617:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  858|      0|	break;
  859|       |
  860|      0|    case 1900:  /* vector     <- null       */
  ------------------
  |  Branch (860:5): [True: 0, False: 259]
  ------------------
  861|      0|    case 2000:  /* expression <- null       */
  ------------------
  |  Branch (861:5): [True: 0, False: 259]
  ------------------
  862|       |
  863|      0|	x = DeleteListElements(x, indx);
  864|      0|	UNPROTECT(4);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  865|      0|	return x;
  866|      0|	break;
  867|       |
  868|      0|    case 2424:	/* raw   <- raw	  */
  ------------------
  |  Branch (868:5): [True: 0, False: 259]
  ------------------
  869|       |
  870|      0|	{
  871|      0|	    Rbyte *px = RAW(x);
  872|      0|	    VECTOR_ASSIGN_LOOP(px[ii] = RAW_ELT(y, iny););
  ------------------
  |  |  600|      0|#define VECTOR_ASSIGN_LOOP(CODE) do {			\
  |  |  601|      0|	if (TYPEOF(indx) == INTSXP) {			\
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (601:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  602|      0|	    const int *pindx = INTEGER_RO(indx);	\
  |  |  603|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  604|      0|		    ii = pindx[i];			\
  |  |  605|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  606|      0|		    ii = ii - 1;			\
  |  |  607|      0|		    do { CODE } while (0);		\
  |  |  608|      0|		});					\
  |  |  609|      0|	}						\
  |  |  610|      0|	else /* could specialize this to REALSXP case */\
  |  |  611|      0|	    MOD_ITERATE1(n, ny, i, iny, {		\
  |  |  ------------------
  |  |  |  |   67|      0|#define MOD_ITERATE1(n, n1, i, i1, loop_body) do {	\
  |  |  |  |   68|      0|	i = i1 = 0;					\
  |  |  |  |   69|      0|	MOD_ITERATE1_CORE(n, n1, i, i1, loop_body);	\
  |  |  |  |  ------------------
  |  |  |  |  |  |   59|      0|#define MOD_ITERATE1_CORE(n, n1, i, i1, loop_body) do {	\
  |  |  |  |  |  |   60|      0|	for (; i < n;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (60:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   61|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (61:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   62|      0|		 ++i) {							\
  |  |  |  |  |  |   63|      0|	    loop_body							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (63:6): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|      0|		}							\
  |  |  |  |  |  |   65|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (65:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   70|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (70:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  612|      0|		    ii = gi(indx, i);			\
  |  |  613|      0|		    if (ii == NA_INTEGER) continue;	\
  |  |  614|      0|		    ii = ii - 1;			\
  |  |  615|      0|		    do { CODE } while (0);		\
  |  |  616|      0|		});					\
  |  |  617|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (617:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  873|      0|	}
  874|      0|	break;
  875|       |
  876|      0|    default:
  ------------------
  |  Branch (876:5): [True: 0, False: 259]
  ------------------
  877|      0|	warningcall(call, "sub assignment (*[*] <- *) not done; __bug?__");
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
  878|    259|    }
  879|       |    /* Check for additional named elements. */
  880|       |    /* Note makeSubscript passes the additional names back as the use.names
  881|       |       attribute (a vector list) of the generated subscript vector */
  882|    259|    SEXP newnames = getAttrib(indx, R_UseNamesSymbol);
  ------------------
  |  |  924|    259|#define getAttrib		Rf_getAttrib
  ------------------
  883|    259|    if (newnames != R_NilValue) {
  ------------------
  |  Branch (883:9): [True: 0, False: 259]
  ------------------
  884|      0|	SEXP oldnames = getAttrib(x, R_NamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  885|      0|	if (oldnames != R_NilValue) {
  ------------------
  |  Branch (885:6): [True: 0, False: 0]
  ------------------
  886|      0|	    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (886:18): [True: 0, False: 0]
  ------------------
  887|      0|		if (VECTOR_ELT(newnames, i) != R_NilValue) {
  ------------------
  |  Branch (887:7): [True: 0, False: 0]
  ------------------
  888|      0|		    ii = gi(indx, i);
  889|      0|		    if (ii == NA_INTEGER) continue;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (889:11): [True: 0, False: 0]
  ------------------
  890|      0|		    ii = ii - 1;
  891|      0|		    SET_STRING_ELT(oldnames, ii, VECTOR_ELT(newnames, i));
  892|      0|		}
  893|      0|	    }
  894|      0|	}
  895|      0|	else {
  896|      0|	    PROTECT(oldnames = allocVector(STRSXP, nx));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  897|      0|	    for (i = 0; i < nx; i++)
  ------------------
  |  Branch (897:18): [True: 0, False: 0]
  ------------------
  898|      0|		SET_STRING_ELT(oldnames, i, R_BlankString);
  899|      0|	    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (899:18): [True: 0, False: 0]
  ------------------
  900|      0|		if (VECTOR_ELT(newnames, i) != R_NilValue) {
  ------------------
  |  Branch (900:7): [True: 0, False: 0]
  ------------------
  901|      0|		    ii = gi(indx, i);
  902|      0|		    if (ii == NA_INTEGER) continue;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (902:11): [True: 0, False: 0]
  ------------------
  903|      0|		    ii = ii - 1;
  904|      0|		    SET_STRING_ELT(oldnames, ii, VECTOR_ELT(newnames, i));
  905|      0|		}
  906|      0|	    }
  907|      0|	    setAttrib(x, R_NamesSymbol, oldnames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  908|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  909|      0|	}
  910|      0|    }
  911|    259|    UNPROTECT(4);
  ------------------
  |  |  358|    259|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  912|    259|    if (old_x != x)
  ------------------
  |  Branch (912:9): [True: 0, False: 259]
  ------------------
  913|      0|	CLEAR_VECTOR(old_x);
  ------------------
  |  |  108|      0|# define CLEAR_VECTOR(x) do {					\
  |  |  109|      0|	if (TYPEOF(x) == EXPRSXP || TYPEOF(x) == VECSXP) {	\
  |  |  ------------------
  |  |  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  |  |  ------------------
  |  |               	if (TYPEOF(x) == EXPRSXP || TYPEOF(x) == VECSXP) {	\
  |  |  ------------------
  |  |  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  |  |  ------------------
  |  |  |  Branch (109:6): [True: 0, False: 0]
  |  |  |  Branch (109:30): [True: 0, False: 0]
  |  |  ------------------
  |  |  110|      0|	    R_xlen_t len = XLENGTH(x);				\
  |  |  111|      0|	    for (R_xlen_t i = 0; i < len; i++)			\
  |  |  ------------------
  |  |  |  Branch (111:27): [True: 0, False: 0]
  |  |  ------------------
  |  |  112|      0|		SET_VECTOR_ELT(x, i, R_NilValue);		\
  |  |  113|      0|	}							\
  |  |  114|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (114:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  914|    259|    return x;
  915|    259|}
subassign.c:gi:
  522|    215|{
  523|    215|    if (TYPEOF(indx) == REALSXP) {
  ------------------
  |  |  124|    215|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (523:9): [True: 0, False: 215]
  ------------------
  524|      0|	double d = REAL_ELT(indx, i);
  525|      0|	return R_FINITE(d) ? (R_xlen_t) d : NA_INTEGER;
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
              	return R_FINITE(d) ? (R_xlen_t) d : NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (525:9): [True: 0, False: 0]
  ------------------
  526|      0|    } else
  527|    215|	return INTEGER_ELT(indx, i);
  528|    215|}
subassign.c:VECTOR_ELT_FIX_NAMED:
  591|    274|static R_INLINE SEXP VECTOR_ELT_FIX_NAMED(SEXP y, R_xlen_t i) {
  592|       |    /* if RHS (container or element) has NAMED > 0 set NAMED = NAMEDMAX.
  593|       |       Duplicating might be safer/more consistent (PR15098) */
  594|    274|    SEXP val = VECTOR_ELT(y, i);
  595|    274|    if ((NAMED(y) || NAMED(val)))
  ------------------
  |  Branch (595:10): [True: 219, False: 55]
  |  Branch (595:22): [True: 55, False: 0]
  ------------------
  596|    274|	ENSURE_NAMEDMAX(val);
  597|    274|    return val;
  598|    274|}
subassign.c:MatrixAssign:
  954|      8|{
  955|      8|    int which;
  956|      8|    int nrs, ncs;
  957|      8|    SEXP sr, sc, dim;
  958|       |
  959|      8|    if (!isMatrix(x))
  ------------------
  |  |  954|      8|#define isMatrix		Rf_isMatrix
  ------------------
  |  Branch (959:9): [True: 0, False: 8]
  ------------------
  960|      0|	error(_("incorrect number of subscripts on matrix"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("incorrect number of subscripts on matrix"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  961|       |
  962|      8|    int nr = nrows(x);
  ------------------
  |  | 1008|      8|#define nrows			Rf_nrows
  ------------------
  963|      8|    R_xlen_t ny = XLENGTH(y);
  964|       |
  965|       |    /* Note that "s" has been protected. */
  966|       |    /* No GC problems here. */
  967|       |
  968|      8|    dim = getAttrib(x, R_DimSymbol);
  ------------------
  |  |  924|      8|#define getAttrib		Rf_getAttrib
  ------------------
  969|      8|    sr = SETCAR(s, int_arraySubscript(0, CAR(s), dim, x, call));
  970|      8|    sc = SETCADR(s, int_arraySubscript(1, CADR(s), dim, x, call));
  971|      8|    nrs = LENGTH(sr);
  972|      8|    ncs = LENGTH(sc);
  973|       |
  974|      8|    const int *psc = INTEGER_RO(sc);
  975|      8|    const int *psr = INTEGER_RO(sr);
  976|      8|    int anyIdxNA = false;
  977|  1.31k|    for(int i = 0; i < nrs; i++)
  ------------------
  |  Branch (977:20): [True: 1.30k, False: 8]
  ------------------
  978|  1.30k|	if (psr[i] == NA_INTEGER) {
  ------------------
  |  |   56|  1.30k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (978:6): [True: 0, False: 1.30k]
  ------------------
  979|      0|	    anyIdxNA = true;
  980|      0|	    break;
  981|      0|	}
  982|     16|    for(int i = 0; i < ncs; i++)
  ------------------
  |  Branch (982:20): [True: 8, False: 8]
  ------------------
  983|      8|	if (psc[i] == NA_INTEGER) {
  ------------------
  |  |   56|      8|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (983:6): [True: 0, False: 8]
  ------------------
  984|      0|	    anyIdxNA = true;
  985|      0|	    break;
  986|      0|	}
  987|      8|    if(ny > 1 && anyIdxNA)
  ------------------
  |  Branch (987:8): [True: 8, False: 0]
  |  Branch (987:18): [True: 0, False: 8]
  ------------------
  988|      0|	error(_("NAs are not allowed in subscripted assignments"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("NAs are not allowed in subscripted assignments"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  989|       |
  990|      8|    R_xlen_t n = ((R_xlen_t) nrs) * ncs;
  991|       |
  992|       |    /* <TSL> 21Oct97
  993|       |       if (length(y) == 0)
  994|       |       error("Replacement length is zero");
  995|       |       </TSL>  */
  996|       |
  997|      8|    if (n > 0 && ny == 0)
  ------------------
  |  Branch (997:9): [True: 8, False: 0]
  |  Branch (997:18): [True: 0, False: 8]
  ------------------
  998|      0|	error(_("replacement has length zero"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("replacement has length zero"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  999|      8|    if (n > 0 && n % ny)
  ------------------
  |  Branch (999:9): [True: 8, False: 0]
  |  Branch (999:18): [True: 0, False: 8]
  ------------------
 1000|      0|	error(_("number of items to replace is not a multiple of replacement length"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("number of items to replace is not a multiple of replacement length"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1001|       |
 1002|      8|    which = SubassignTypeFix(&x, &y, 0, 1, call, rho);
 1003|      8|    if (n == 0) return x;
  ------------------
  |  Branch (1003:9): [True: 0, False: 8]
  ------------------
 1004|       |
 1005|      8|    PROTECT(x);
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1006|       |
 1007|       |    /* When array elements are being permuted the RHS */
 1008|       |    /* must be duplicated or the elements get trashed. */
 1009|       |    /* FIXME : this should be a shallow copy for list */
 1010|       |    /* objects.  A full duplication is wasteful. */
 1011|       |
 1012|      8|    if (x == y)
  ------------------
  |  Branch (1012:9): [True: 0, False: 8]
  ------------------
 1013|      0|	PROTECT(y = shallow_duplicate(y));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1014|      8|    else
 1015|      8|	PROTECT(y);
  ------------------
  |  |  357|      8|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1016|       |
 1017|       |    /* Note that we are now committed.  Since we are mutating */
 1018|       |    /* existing objects any changes we make now are permanent. */
 1019|       |    /* Beware! */
 1020|       |
 1021|      8|    switch (which) {
 1022|       |	/* because we have called SubassignTypeFix the commented
 1023|       |	   values cannot occur (and would be unsafe) */
 1024|       |
 1025|      0|    case 1010:	/* logical   <- logical	  */
  ------------------
  |  Branch (1025:5): [True: 0, False: 8]
  ------------------
 1026|      0|    case 1310:	/* integer   <- logical	  */
  ------------------
  |  Branch (1026:5): [True: 0, False: 8]
  ------------------
 1027|       |    /* case 1013: logical   <- integer	  */
 1028|      0|    case 1313:	/* integer   <- integer	  */
  ------------------
  |  Branch (1028:5): [True: 0, False: 8]
  ------------------
 1029|       |
 1030|      0|	{
 1031|      0|	    int *px = INTEGER(x);
 1032|      0|	    if (ALTREP(y))
  ------------------
  |  Branch (1032:10): [True: 0, False: 0]
  ------------------
 1033|      0|		MATRIX_ASSIGN_LOOP(px[ij] = INTEGER_ELT(y, k););
  ------------------
  |  |  920|      0|#define MATRIX_ASSIGN_LOOP(CODE) do {			\
  |  |  921|      0|	R_xlen_t k = 0, NR = nr, ij;			\
  |  |  922|      0|	if (anyIdxNA)					\
  |  |  ------------------
  |  |  |  Branch (922:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  923|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (923:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  924|      0|		int jj = psc[j];			\
  |  |  925|      0|		if (jj != NA_INTEGER) {			\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (925:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  926|      0|		    jj = jj - 1;			\
  |  |  927|      0|		    R_xlen_t offset = jj * NR;		\
  |  |  928|      0|		    for (int i = 0; i < nrs; i++) {	\
  |  |  ------------------
  |  |  |  Branch (928:23): [True: 0, False: 0]
  |  |  ------------------
  |  |  929|      0|			int ii = psr[i];		\
  |  |  930|      0|			if (ii != NA_INTEGER) {		\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (930:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  931|      0|			    ij = ii + offset - 1;	\
  |  |  932|      0|			    do { CODE } while (0);	\
  |  |  ------------------
  |  |  |  Branch (932:27): [Folded, False: 0]
  |  |  ------------------
  |  |  933|      0|			    k++;			\
  |  |  934|      0|			    if (k == ny) k = 0;		\
  |  |  ------------------
  |  |  |  Branch (934:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  935|      0|			}				\
  |  |  936|      0|		    }					\
  |  |  937|      0|		}					\
  |  |  938|      0|	    }						\
  |  |  939|      0|	else						\
  |  |  940|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (940:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  941|      0|		int jj = psc[j] - 1;			\
  |  |  942|      0|		R_xlen_t offset = jj * NR;		\
  |  |  943|      0|		for (int i = 0; i < nrs; i++) {		\
  |  |  ------------------
  |  |  |  Branch (943:19): [True: 0, False: 0]
  |  |  ------------------
  |  |  944|      0|		    int ii = psr[i];			\
  |  |  945|      0|		    ij = ii + offset - 1;		\
  |  |  946|      0|		    do { CODE } while (0);		\
  |  |  ------------------
  |  |  |  Branch (946:26): [Folded, False: 0]
  |  |  ------------------
  |  |  947|      0|		    k++;				\
  |  |  948|      0|		    if (k == ny) k = 0;			\
  |  |  ------------------
  |  |  |  Branch (948:11): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|		}					\
  |  |  950|      0|	    }						\
  |  |  951|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (951:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1034|      0|	    else {
 1035|      0|		int *py = INTEGER0(y);
 1036|      0|		MATRIX_ASSIGN_LOOP(px[ij] = py[k];);
  ------------------
  |  |  920|      0|#define MATRIX_ASSIGN_LOOP(CODE) do {			\
  |  |  921|      0|	R_xlen_t k = 0, NR = nr, ij;			\
  |  |  922|      0|	if (anyIdxNA)					\
  |  |  ------------------
  |  |  |  Branch (922:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  923|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (923:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  924|      0|		int jj = psc[j];			\
  |  |  925|      0|		if (jj != NA_INTEGER) {			\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (925:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  926|      0|		    jj = jj - 1;			\
  |  |  927|      0|		    R_xlen_t offset = jj * NR;		\
  |  |  928|      0|		    for (int i = 0; i < nrs; i++) {	\
  |  |  ------------------
  |  |  |  Branch (928:23): [True: 0, False: 0]
  |  |  ------------------
  |  |  929|      0|			int ii = psr[i];		\
  |  |  930|      0|			if (ii != NA_INTEGER) {		\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (930:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  931|      0|			    ij = ii + offset - 1;	\
  |  |  932|      0|			    do { CODE } while (0);	\
  |  |  ------------------
  |  |  |  Branch (932:27): [Folded, False: 0]
  |  |  ------------------
  |  |  933|      0|			    k++;			\
  |  |  934|      0|			    if (k == ny) k = 0;		\
  |  |  ------------------
  |  |  |  Branch (934:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  935|      0|			}				\
  |  |  936|      0|		    }					\
  |  |  937|      0|		}					\
  |  |  938|      0|	    }						\
  |  |  939|      0|	else						\
  |  |  940|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (940:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  941|      0|		int jj = psc[j] - 1;			\
  |  |  942|      0|		R_xlen_t offset = jj * NR;		\
  |  |  943|      0|		for (int i = 0; i < nrs; i++) {		\
  |  |  ------------------
  |  |  |  Branch (943:19): [True: 0, False: 0]
  |  |  ------------------
  |  |  944|      0|		    int ii = psr[i];			\
  |  |  945|      0|		    ij = ii + offset - 1;		\
  |  |  946|      0|		    do { CODE } while (0);		\
  |  |  ------------------
  |  |  |  Branch (946:26): [Folded, False: 0]
  |  |  ------------------
  |  |  947|      0|		    k++;				\
  |  |  948|      0|		    if (k == ny) k = 0;			\
  |  |  ------------------
  |  |  |  Branch (948:11): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|		}					\
  |  |  950|      0|	    }						\
  |  |  951|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (951:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1037|      0|	    }
 1038|      0|	}
 1039|      0|	break;
 1040|       |
 1041|      0|    case 1410:	/* real	     <- logical	  */
  ------------------
  |  Branch (1041:5): [True: 0, False: 8]
  ------------------
 1042|      0|    case 1413:	/* real	     <- integer	  */
  ------------------
  |  Branch (1042:5): [True: 0, False: 8]
  ------------------
 1043|       |
 1044|      0|	{
 1045|      0|	    double *px = REAL(x);
 1046|      0|	    MATRIX_ASSIGN_LOOP({
  ------------------
  |  |  920|      0|#define MATRIX_ASSIGN_LOOP(CODE) do {			\
  |  |  921|      0|	R_xlen_t k = 0, NR = nr, ij;			\
  |  |  922|      0|	if (anyIdxNA)					\
  |  |  ------------------
  |  |  |  Branch (922:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  923|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (923:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  924|      0|		int jj = psc[j];			\
  |  |  925|      0|		if (jj != NA_INTEGER) {			\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (925:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  926|      0|		    jj = jj - 1;			\
  |  |  927|      0|		    R_xlen_t offset = jj * NR;		\
  |  |  928|      0|		    for (int i = 0; i < nrs; i++) {	\
  |  |  ------------------
  |  |  |  Branch (928:23): [True: 0, False: 0]
  |  |  ------------------
  |  |  929|      0|			int ii = psr[i];		\
  |  |  930|      0|			if (ii != NA_INTEGER) {		\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (930:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  931|      0|			    ij = ii + offset - 1;	\
  |  |  932|      0|			    do { CODE } while (0);	\
  |  |  ------------------
  |  |  |  Branch (932:13): [True: 0, False: 0]
  |  |  |  Branch (932:27): [Folded, False: 0]
  |  |  ------------------
  |  |  933|      0|			    k++;			\
  |  |  934|      0|			    if (k == ny) k = 0;		\
  |  |  ------------------
  |  |  |  Branch (934:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  935|      0|			}				\
  |  |  936|      0|		    }					\
  |  |  937|      0|		}					\
  |  |  938|      0|	    }						\
  |  |  939|      0|	else						\
  |  |  940|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (940:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  941|      0|		int jj = psc[j] - 1;			\
  |  |  942|      0|		R_xlen_t offset = jj * NR;		\
  |  |  943|      0|		for (int i = 0; i < nrs; i++) {		\
  |  |  ------------------
  |  |  |  Branch (943:19): [True: 0, False: 0]
  |  |  ------------------
  |  |  944|      0|		    int ii = psr[i];			\
  |  |  945|      0|		    ij = ii + offset - 1;		\
  |  |  946|      0|		    do { CODE } while (0);		\
  |  |  ------------------
  |  |  |  Branch (946:12): [True: 0, False: 0]
  |  |  |  Branch (946:26): [Folded, False: 0]
  |  |  ------------------
  |  |  947|      0|		    k++;				\
  |  |  948|      0|		    if (k == ny) k = 0;			\
  |  |  ------------------
  |  |  |  Branch (948:11): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|		}					\
  |  |  950|      0|	    }						\
  |  |  951|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (951:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1047|      0|		    int iy = INTEGER_ELT(y, k);
 1048|      0|		    if (iy == NA_INTEGER)
 1049|      0|			px[ij] = NA_REAL;
 1050|      0|		    else
 1051|      0|			px[ij] = iy;
 1052|      0|		});
 1053|      0|	}
 1054|      0|	break;
 1055|       |
 1056|       |    /* case 1014:  logical   <- real	  */
 1057|       |    /* case 1314:  integer   <- real	  */
 1058|      0|    case 1414:	/* real	     <- real	  */
  ------------------
  |  Branch (1058:5): [True: 0, False: 8]
  ------------------
 1059|       |
 1060|      0|	{
 1061|      0|	    double *px = REAL(x);
 1062|      0|	    if (ALTREP(y))
  ------------------
  |  Branch (1062:10): [True: 0, False: 0]
  ------------------
 1063|      0|		MATRIX_ASSIGN_LOOP(px[ij] = REAL_ELT(y, k););
  ------------------
  |  |  920|      0|#define MATRIX_ASSIGN_LOOP(CODE) do {			\
  |  |  921|      0|	R_xlen_t k = 0, NR = nr, ij;			\
  |  |  922|      0|	if (anyIdxNA)					\
  |  |  ------------------
  |  |  |  Branch (922:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  923|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (923:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  924|      0|		int jj = psc[j];			\
  |  |  925|      0|		if (jj != NA_INTEGER) {			\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (925:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  926|      0|		    jj = jj - 1;			\
  |  |  927|      0|		    R_xlen_t offset = jj * NR;		\
  |  |  928|      0|		    for (int i = 0; i < nrs; i++) {	\
  |  |  ------------------
  |  |  |  Branch (928:23): [True: 0, False: 0]
  |  |  ------------------
  |  |  929|      0|			int ii = psr[i];		\
  |  |  930|      0|			if (ii != NA_INTEGER) {		\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (930:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  931|      0|			    ij = ii + offset - 1;	\
  |  |  932|      0|			    do { CODE } while (0);	\
  |  |  ------------------
  |  |  |  Branch (932:27): [Folded, False: 0]
  |  |  ------------------
  |  |  933|      0|			    k++;			\
  |  |  934|      0|			    if (k == ny) k = 0;		\
  |  |  ------------------
  |  |  |  Branch (934:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  935|      0|			}				\
  |  |  936|      0|		    }					\
  |  |  937|      0|		}					\
  |  |  938|      0|	    }						\
  |  |  939|      0|	else						\
  |  |  940|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (940:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  941|      0|		int jj = psc[j] - 1;			\
  |  |  942|      0|		R_xlen_t offset = jj * NR;		\
  |  |  943|      0|		for (int i = 0; i < nrs; i++) {		\
  |  |  ------------------
  |  |  |  Branch (943:19): [True: 0, False: 0]
  |  |  ------------------
  |  |  944|      0|		    int ii = psr[i];			\
  |  |  945|      0|		    ij = ii + offset - 1;		\
  |  |  946|      0|		    do { CODE } while (0);		\
  |  |  ------------------
  |  |  |  Branch (946:26): [Folded, False: 0]
  |  |  ------------------
  |  |  947|      0|		    k++;				\
  |  |  948|      0|		    if (k == ny) k = 0;			\
  |  |  ------------------
  |  |  |  Branch (948:11): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|		}					\
  |  |  950|      0|	    }						\
  |  |  951|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (951:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1064|      0|	    else {
 1065|      0|		double *py = REAL0(y);
 1066|      0|		MATRIX_ASSIGN_LOOP(px[ij] = py[k];);
  ------------------
  |  |  920|      0|#define MATRIX_ASSIGN_LOOP(CODE) do {			\
  |  |  921|      0|	R_xlen_t k = 0, NR = nr, ij;			\
  |  |  922|      0|	if (anyIdxNA)					\
  |  |  ------------------
  |  |  |  Branch (922:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  923|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (923:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  924|      0|		int jj = psc[j];			\
  |  |  925|      0|		if (jj != NA_INTEGER) {			\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (925:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  926|      0|		    jj = jj - 1;			\
  |  |  927|      0|		    R_xlen_t offset = jj * NR;		\
  |  |  928|      0|		    for (int i = 0; i < nrs; i++) {	\
  |  |  ------------------
  |  |  |  Branch (928:23): [True: 0, False: 0]
  |  |  ------------------
  |  |  929|      0|			int ii = psr[i];		\
  |  |  930|      0|			if (ii != NA_INTEGER) {		\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (930:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  931|      0|			    ij = ii + offset - 1;	\
  |  |  932|      0|			    do { CODE } while (0);	\
  |  |  ------------------
  |  |  |  Branch (932:27): [Folded, False: 0]
  |  |  ------------------
  |  |  933|      0|			    k++;			\
  |  |  934|      0|			    if (k == ny) k = 0;		\
  |  |  ------------------
  |  |  |  Branch (934:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  935|      0|			}				\
  |  |  936|      0|		    }					\
  |  |  937|      0|		}					\
  |  |  938|      0|	    }						\
  |  |  939|      0|	else						\
  |  |  940|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (940:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  941|      0|		int jj = psc[j] - 1;			\
  |  |  942|      0|		R_xlen_t offset = jj * NR;		\
  |  |  943|      0|		for (int i = 0; i < nrs; i++) {		\
  |  |  ------------------
  |  |  |  Branch (943:19): [True: 0, False: 0]
  |  |  ------------------
  |  |  944|      0|		    int ii = psr[i];			\
  |  |  945|      0|		    ij = ii + offset - 1;		\
  |  |  946|      0|		    do { CODE } while (0);		\
  |  |  ------------------
  |  |  |  Branch (946:26): [Folded, False: 0]
  |  |  ------------------
  |  |  947|      0|		    k++;				\
  |  |  948|      0|		    if (k == ny) k = 0;			\
  |  |  ------------------
  |  |  |  Branch (948:11): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|		}					\
  |  |  950|      0|	    }						\
  |  |  951|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (951:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1067|      0|	    }
 1068|      0|	}
 1069|      0|	break;
 1070|       |
 1071|      0|    case 1510:	/* complex   <- logical	  */
  ------------------
  |  Branch (1071:5): [True: 0, False: 8]
  ------------------
 1072|      0|    case 1513:	/* complex   <- integer	  */
  ------------------
  |  Branch (1072:5): [True: 0, False: 8]
  ------------------
 1073|       |
 1074|      0|	{
 1075|      0|	    Rcomplex *px = COMPLEX(x);
 1076|      0|	    MATRIX_ASSIGN_LOOP({
  ------------------
  |  |  920|      0|#define MATRIX_ASSIGN_LOOP(CODE) do {			\
  |  |  921|      0|	R_xlen_t k = 0, NR = nr, ij;			\
  |  |  922|      0|	if (anyIdxNA)					\
  |  |  ------------------
  |  |  |  Branch (922:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  923|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (923:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  924|      0|		int jj = psc[j];			\
  |  |  925|      0|		if (jj != NA_INTEGER) {			\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (925:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  926|      0|		    jj = jj - 1;			\
  |  |  927|      0|		    R_xlen_t offset = jj * NR;		\
  |  |  928|      0|		    for (int i = 0; i < nrs; i++) {	\
  |  |  ------------------
  |  |  |  Branch (928:23): [True: 0, False: 0]
  |  |  ------------------
  |  |  929|      0|			int ii = psr[i];		\
  |  |  930|      0|			if (ii != NA_INTEGER) {		\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (930:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  931|      0|			    ij = ii + offset - 1;	\
  |  |  932|      0|			    do { CODE } while (0);	\
  |  |  ------------------
  |  |  |  Branch (932:13): [True: 0, False: 0]
  |  |  |  Branch (932:27): [Folded, False: 0]
  |  |  ------------------
  |  |  933|      0|			    k++;			\
  |  |  934|      0|			    if (k == ny) k = 0;		\
  |  |  ------------------
  |  |  |  Branch (934:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  935|      0|			}				\
  |  |  936|      0|		    }					\
  |  |  937|      0|		}					\
  |  |  938|      0|	    }						\
  |  |  939|      0|	else						\
  |  |  940|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (940:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  941|      0|		int jj = psc[j] - 1;			\
  |  |  942|      0|		R_xlen_t offset = jj * NR;		\
  |  |  943|      0|		for (int i = 0; i < nrs; i++) {		\
  |  |  ------------------
  |  |  |  Branch (943:19): [True: 0, False: 0]
  |  |  ------------------
  |  |  944|      0|		    int ii = psr[i];			\
  |  |  945|      0|		    ij = ii + offset - 1;		\
  |  |  946|      0|		    do { CODE } while (0);		\
  |  |  ------------------
  |  |  |  Branch (946:12): [True: 0, False: 0]
  |  |  |  Branch (946:26): [Folded, False: 0]
  |  |  ------------------
  |  |  947|      0|		    k++;				\
  |  |  948|      0|		    if (k == ny) k = 0;			\
  |  |  ------------------
  |  |  |  Branch (948:11): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|		}					\
  |  |  950|      0|	    }						\
  |  |  951|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (951:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1077|      0|		    int iy = INTEGER_ELT(y, k);
 1078|      0|		    if (iy == NA_INTEGER) {
 1079|      0|			px[ij].r = NA_REAL;
 1080|      0|			px[ij].i = 0.0;
 1081|      0|		    }
 1082|      0|		    else {
 1083|      0|			px[ij].r = iy;
 1084|      0|			px[ij].i = 0.0;
 1085|      0|		    }
 1086|      0|		});
 1087|      0|	}
 1088|      0|	break;
 1089|       |
 1090|      0|    case 1514:	/* complex   <- real	  */
  ------------------
  |  Branch (1090:5): [True: 0, False: 8]
  ------------------
 1091|       |
 1092|      0|	{
 1093|      0|	    Rcomplex *px = COMPLEX(x);
 1094|      0|	    MATRIX_ASSIGN_LOOP({
  ------------------
  |  |  920|      0|#define MATRIX_ASSIGN_LOOP(CODE) do {			\
  |  |  921|      0|	R_xlen_t k = 0, NR = nr, ij;			\
  |  |  922|      0|	if (anyIdxNA)					\
  |  |  ------------------
  |  |  |  Branch (922:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  923|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (923:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  924|      0|		int jj = psc[j];			\
  |  |  925|      0|		if (jj != NA_INTEGER) {			\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (925:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  926|      0|		    jj = jj - 1;			\
  |  |  927|      0|		    R_xlen_t offset = jj * NR;		\
  |  |  928|      0|		    for (int i = 0; i < nrs; i++) {	\
  |  |  ------------------
  |  |  |  Branch (928:23): [True: 0, False: 0]
  |  |  ------------------
  |  |  929|      0|			int ii = psr[i];		\
  |  |  930|      0|			if (ii != NA_INTEGER) {		\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (930:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  931|      0|			    ij = ii + offset - 1;	\
  |  |  932|      0|			    do { CODE } while (0);	\
  |  |  ------------------
  |  |  |  Branch (932:13): [True: 0, False: 0]
  |  |  |  Branch (932:27): [Folded, False: 0]
  |  |  ------------------
  |  |  933|      0|			    k++;			\
  |  |  934|      0|			    if (k == ny) k = 0;		\
  |  |  ------------------
  |  |  |  Branch (934:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  935|      0|			}				\
  |  |  936|      0|		    }					\
  |  |  937|      0|		}					\
  |  |  938|      0|	    }						\
  |  |  939|      0|	else						\
  |  |  940|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (940:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  941|      0|		int jj = psc[j] - 1;			\
  |  |  942|      0|		R_xlen_t offset = jj * NR;		\
  |  |  943|      0|		for (int i = 0; i < nrs; i++) {		\
  |  |  ------------------
  |  |  |  Branch (943:19): [True: 0, False: 0]
  |  |  ------------------
  |  |  944|      0|		    int ii = psr[i];			\
  |  |  945|      0|		    ij = ii + offset - 1;		\
  |  |  946|      0|		    do { CODE } while (0);		\
  |  |  ------------------
  |  |  |  Branch (946:12): [True: 0, False: 0]
  |  |  |  Branch (946:26): [Folded, False: 0]
  |  |  ------------------
  |  |  947|      0|		    k++;				\
  |  |  948|      0|		    if (k == ny) k = 0;			\
  |  |  ------------------
  |  |  |  Branch (948:11): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|		}					\
  |  |  950|      0|	    }						\
  |  |  951|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (951:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1095|      0|		    double ry = REAL_ELT(y, k);
 1096|      0|		    if (ISNA(ry)) {
 1097|      0|			px[ij].r = NA_REAL;
 1098|      0|			px[ij].i = 0.0;
 1099|      0|		    }
 1100|      0|		    else {
 1101|      0|			px[ij].r = ry;
 1102|      0|			px[ij].i = 0.0;
 1103|      0|		    }
 1104|      0|		});
 1105|      0|	}
 1106|      0|	break;
 1107|       |
 1108|       |    /* case 1015:  logical   <- complex	  */
 1109|       |    /* case 1315:  integer   <- complex	  */
 1110|       |    /* case 1415:  real	     <- complex	  */
 1111|      0|    case 1515:	/* complex   <- complex	  */
  ------------------
  |  Branch (1111:5): [True: 0, False: 8]
  ------------------
 1112|       |
 1113|      0|	{
 1114|      0|	    Rcomplex *px = COMPLEX(x);
 1115|      0|	    MATRIX_ASSIGN_LOOP(px[ij] = COMPLEX_ELT(y, k););
  ------------------
  |  |  920|      0|#define MATRIX_ASSIGN_LOOP(CODE) do {			\
  |  |  921|      0|	R_xlen_t k = 0, NR = nr, ij;			\
  |  |  922|      0|	if (anyIdxNA)					\
  |  |  ------------------
  |  |  |  Branch (922:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  923|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (923:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  924|      0|		int jj = psc[j];			\
  |  |  925|      0|		if (jj != NA_INTEGER) {			\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (925:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  926|      0|		    jj = jj - 1;			\
  |  |  927|      0|		    R_xlen_t offset = jj * NR;		\
  |  |  928|      0|		    for (int i = 0; i < nrs; i++) {	\
  |  |  ------------------
  |  |  |  Branch (928:23): [True: 0, False: 0]
  |  |  ------------------
  |  |  929|      0|			int ii = psr[i];		\
  |  |  930|      0|			if (ii != NA_INTEGER) {		\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (930:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  931|      0|			    ij = ii + offset - 1;	\
  |  |  932|      0|			    do { CODE } while (0);	\
  |  |  ------------------
  |  |  |  Branch (932:27): [Folded, False: 0]
  |  |  ------------------
  |  |  933|      0|			    k++;			\
  |  |  934|      0|			    if (k == ny) k = 0;		\
  |  |  ------------------
  |  |  |  Branch (934:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  935|      0|			}				\
  |  |  936|      0|		    }					\
  |  |  937|      0|		}					\
  |  |  938|      0|	    }						\
  |  |  939|      0|	else						\
  |  |  940|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (940:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  941|      0|		int jj = psc[j] - 1;			\
  |  |  942|      0|		R_xlen_t offset = jj * NR;		\
  |  |  943|      0|		for (int i = 0; i < nrs; i++) {		\
  |  |  ------------------
  |  |  |  Branch (943:19): [True: 0, False: 0]
  |  |  ------------------
  |  |  944|      0|		    int ii = psr[i];			\
  |  |  945|      0|		    ij = ii + offset - 1;		\
  |  |  946|      0|		    do { CODE } while (0);		\
  |  |  ------------------
  |  |  |  Branch (946:26): [Folded, False: 0]
  |  |  ------------------
  |  |  947|      0|		    k++;				\
  |  |  948|      0|		    if (k == ny) k = 0;			\
  |  |  ------------------
  |  |  |  Branch (948:11): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|		}					\
  |  |  950|      0|	    }						\
  |  |  951|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (951:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1116|      0|	}
 1117|      0|	break;
 1118|       |
 1119|      0|    case 1610:	/* character <- logical	  */
  ------------------
  |  Branch (1119:5): [True: 0, False: 8]
  ------------------
 1120|      0|    case 1613:	/* character <- integer	  */
  ------------------
  |  Branch (1120:5): [True: 0, False: 8]
  ------------------
 1121|      0|    case 1614:	/* character <- real	  */
  ------------------
  |  Branch (1121:5): [True: 0, False: 8]
  ------------------
 1122|      0|    case 1615:	/* character <- complex	  */
  ------------------
  |  Branch (1122:5): [True: 0, False: 8]
  ------------------
 1123|      8|    case 1616:	/* character <- character */
  ------------------
  |  Branch (1123:5): [True: 8, False: 0]
  ------------------
 1124|       |    /* case 1016:  logical   <- character */
 1125|       |    /* case 1316:  integer   <- character */
 1126|       |    /* case 1416:  real	     <- character */
 1127|       |    /* case 1516:  complex   <- character */
 1128|       |
 1129|      8|	MATRIX_ASSIGN_LOOP(SET_STRING_ELT(x, ij, STRING_ELT(y, k)););
  ------------------
  |  |  920|      8|#define MATRIX_ASSIGN_LOOP(CODE) do {			\
  |  |  921|      8|	R_xlen_t k = 0, NR = nr, ij;			\
  |  |  922|      8|	if (anyIdxNA)					\
  |  |  ------------------
  |  |  |  Branch (922:6): [True: 0, False: 8]
  |  |  ------------------
  |  |  923|      8|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (923:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  924|      0|		int jj = psc[j];			\
  |  |  925|      0|		if (jj != NA_INTEGER) {			\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (925:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  926|      0|		    jj = jj - 1;			\
  |  |  927|      0|		    R_xlen_t offset = jj * NR;		\
  |  |  928|      0|		    for (int i = 0; i < nrs; i++) {	\
  |  |  ------------------
  |  |  |  Branch (928:23): [True: 0, False: 0]
  |  |  ------------------
  |  |  929|      0|			int ii = psr[i];		\
  |  |  930|      0|			if (ii != NA_INTEGER) {		\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (930:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  931|      0|			    ij = ii + offset - 1;	\
  |  |  932|      0|			    do { CODE } while (0);	\
  |  |  ------------------
  |  |  |  Branch (932:27): [Folded, False: 0]
  |  |  ------------------
  |  |  933|      0|			    k++;			\
  |  |  934|      0|			    if (k == ny) k = 0;		\
  |  |  ------------------
  |  |  |  Branch (934:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  935|      0|			}				\
  |  |  936|      0|		    }					\
  |  |  937|      0|		}					\
  |  |  938|      0|	    }						\
  |  |  939|      8|	else						\
  |  |  940|     16|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (940:22): [True: 8, False: 8]
  |  |  ------------------
  |  |  941|      8|		int jj = psc[j] - 1;			\
  |  |  942|      8|		R_xlen_t offset = jj * NR;		\
  |  |  943|  1.31k|		for (int i = 0; i < nrs; i++) {		\
  |  |  ------------------
  |  |  |  Branch (943:19): [True: 1.30k, False: 8]
  |  |  ------------------
  |  |  944|  1.30k|		    int ii = psr[i];			\
  |  |  945|  1.30k|		    ij = ii + offset - 1;		\
  |  |  946|  1.30k|		    do { CODE } while (0);		\
  |  |  ------------------
  |  |  |  Branch (946:26): [Folded, False: 1.30k]
  |  |  ------------------
  |  |  947|  1.30k|		    k++;				\
  |  |  948|  1.30k|		    if (k == ny) k = 0;			\
  |  |  ------------------
  |  |  |  Branch (948:11): [True: 8, False: 1.29k]
  |  |  ------------------
  |  |  949|  1.30k|		}					\
  |  |  950|      8|	    }						\
  |  |  951|      8|    } while (0)
  |  |  ------------------
  |  |  |  Branch (951:14): [Folded, False: 8]
  |  |  ------------------
  ------------------
 1130|      8|	break;
 1131|       |
 1132|      0|    case 1919: /* vector <- vector */
  ------------------
  |  Branch (1132:5): [True: 0, False: 8]
  ------------------
 1133|       |
 1134|       |	/* set NAMED or RHS values to NAMEDMAX if they might be used more
 1135|       |	   than once (PR15098)*/
 1136|      0|	if (ny < ncs * nrs)
  ------------------
  |  Branch (1136:6): [True: 0, False: 0]
  ------------------
 1137|      0|	    for (R_xlen_t i = 0; i < ny; i++)
  ------------------
  |  Branch (1137:27): [True: 0, False: 0]
  ------------------
 1138|      0|		ENSURE_NAMEDMAX(VECTOR_ELT(y, i));
 1139|       |
 1140|      0|	MATRIX_ASSIGN_LOOP(SET_VECTOR_ELT(x, ij, VECTOR_ELT_FIX_NAMED(y, k)););
  ------------------
  |  |  920|      0|#define MATRIX_ASSIGN_LOOP(CODE) do {			\
  |  |  921|      0|	R_xlen_t k = 0, NR = nr, ij;			\
  |  |  922|      0|	if (anyIdxNA)					\
  |  |  ------------------
  |  |  |  Branch (922:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  923|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (923:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  924|      0|		int jj = psc[j];			\
  |  |  925|      0|		if (jj != NA_INTEGER) {			\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (925:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  926|      0|		    jj = jj - 1;			\
  |  |  927|      0|		    R_xlen_t offset = jj * NR;		\
  |  |  928|      0|		    for (int i = 0; i < nrs; i++) {	\
  |  |  ------------------
  |  |  |  Branch (928:23): [True: 0, False: 0]
  |  |  ------------------
  |  |  929|      0|			int ii = psr[i];		\
  |  |  930|      0|			if (ii != NA_INTEGER) {		\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (930:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  931|      0|			    ij = ii + offset - 1;	\
  |  |  932|      0|			    do { CODE } while (0);	\
  |  |  ------------------
  |  |  |  Branch (932:27): [Folded, False: 0]
  |  |  ------------------
  |  |  933|      0|			    k++;			\
  |  |  934|      0|			    if (k == ny) k = 0;		\
  |  |  ------------------
  |  |  |  Branch (934:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  935|      0|			}				\
  |  |  936|      0|		    }					\
  |  |  937|      0|		}					\
  |  |  938|      0|	    }						\
  |  |  939|      0|	else						\
  |  |  940|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (940:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  941|      0|		int jj = psc[j] - 1;			\
  |  |  942|      0|		R_xlen_t offset = jj * NR;		\
  |  |  943|      0|		for (int i = 0; i < nrs; i++) {		\
  |  |  ------------------
  |  |  |  Branch (943:19): [True: 0, False: 0]
  |  |  ------------------
  |  |  944|      0|		    int ii = psr[i];			\
  |  |  945|      0|		    ij = ii + offset - 1;		\
  |  |  946|      0|		    do { CODE } while (0);		\
  |  |  ------------------
  |  |  |  Branch (946:26): [Folded, False: 0]
  |  |  ------------------
  |  |  947|      0|		    k++;				\
  |  |  948|      0|		    if (k == ny) k = 0;			\
  |  |  ------------------
  |  |  |  Branch (948:11): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|		}					\
  |  |  950|      0|	    }						\
  |  |  951|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (951:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1141|      0|	break;
 1142|       |
 1143|      0|    case 2424: /* raw   <- raw   */
  ------------------
  |  Branch (1143:5): [True: 0, False: 8]
  ------------------
 1144|       |
 1145|      0|	{
 1146|      0|	    Rbyte *px = RAW(x);
 1147|      0|	    MATRIX_ASSIGN_LOOP(px[ij] = RAW_ELT(y, k););
  ------------------
  |  |  920|      0|#define MATRIX_ASSIGN_LOOP(CODE) do {			\
  |  |  921|      0|	R_xlen_t k = 0, NR = nr, ij;			\
  |  |  922|      0|	if (anyIdxNA)					\
  |  |  ------------------
  |  |  |  Branch (922:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  923|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (923:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  924|      0|		int jj = psc[j];			\
  |  |  925|      0|		if (jj != NA_INTEGER) {			\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (925:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  926|      0|		    jj = jj - 1;			\
  |  |  927|      0|		    R_xlen_t offset = jj * NR;		\
  |  |  928|      0|		    for (int i = 0; i < nrs; i++) {	\
  |  |  ------------------
  |  |  |  Branch (928:23): [True: 0, False: 0]
  |  |  ------------------
  |  |  929|      0|			int ii = psr[i];		\
  |  |  930|      0|			if (ii != NA_INTEGER) {		\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (930:8): [True: 0, False: 0]
  |  |  ------------------
  |  |  931|      0|			    ij = ii + offset - 1;	\
  |  |  932|      0|			    do { CODE } while (0);	\
  |  |  ------------------
  |  |  |  Branch (932:27): [Folded, False: 0]
  |  |  ------------------
  |  |  933|      0|			    k++;			\
  |  |  934|      0|			    if (k == ny) k = 0;		\
  |  |  ------------------
  |  |  |  Branch (934:12): [True: 0, False: 0]
  |  |  ------------------
  |  |  935|      0|			}				\
  |  |  936|      0|		    }					\
  |  |  937|      0|		}					\
  |  |  938|      0|	    }						\
  |  |  939|      0|	else						\
  |  |  940|      0|	    for (int j = 0; j < ncs; j++) {		\
  |  |  ------------------
  |  |  |  Branch (940:22): [True: 0, False: 0]
  |  |  ------------------
  |  |  941|      0|		int jj = psc[j] - 1;			\
  |  |  942|      0|		R_xlen_t offset = jj * NR;		\
  |  |  943|      0|		for (int i = 0; i < nrs; i++) {		\
  |  |  ------------------
  |  |  |  Branch (943:19): [True: 0, False: 0]
  |  |  ------------------
  |  |  944|      0|		    int ii = psr[i];			\
  |  |  945|      0|		    ij = ii + offset - 1;		\
  |  |  946|      0|		    do { CODE } while (0);		\
  |  |  ------------------
  |  |  |  Branch (946:26): [Folded, False: 0]
  |  |  ------------------
  |  |  947|      0|		    k++;				\
  |  |  948|      0|		    if (k == ny) k = 0;			\
  |  |  ------------------
  |  |  |  Branch (948:11): [True: 0, False: 0]
  |  |  ------------------
  |  |  949|      0|		}					\
  |  |  950|      0|	    }						\
  |  |  951|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (951:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1148|      0|	}
 1149|      0|	break;
 1150|       |
 1151|      0|    default:
  ------------------
  |  Branch (1151:5): [True: 0, False: 8]
  ------------------
 1152|      0|	error(_("incompatible types (from %s to %s) in matrix subset assignment"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("incompatible types (from %s to %s) in matrix subset assignment"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1153|      0|		  R_typeToChar(x), R_typeToChar(y));
 1154|      8|    }
 1155|      8|    UNPROTECT(2);
  ------------------
  |  |  358|      8|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1156|      8|    return x;
 1157|      8|}
subassign.c:SubassignTypeFix:
  331|    300|{
  332|       |    /* A rather pointless optimization, but level 2 used to be handled
  333|       |       differently */
  334|    300|    bool redo_which = true;
  335|    300|    int which = 100 * TYPEOF(*x) + TYPEOF(*y);
  336|       |    /* coercion can lose the object bit */
  337|    300|    bool x_is_object = OBJECT(*x);
  338|       |
  339|    300|    switch (which) {
  340|      0|    case 1000:	/* logical    <- null       */
  ------------------
  |  Branch (340:5): [True: 0, False: 300]
  ------------------
  341|      0|    case 1300:	/* integer    <- null       */
  ------------------
  |  Branch (341:5): [True: 0, False: 300]
  ------------------
  342|      0|    case 1400:	/* real	      <- null       */
  ------------------
  |  Branch (342:5): [True: 0, False: 300]
  ------------------
  343|      0|    case 1500:	/* complex    <- null       */
  ------------------
  |  Branch (343:5): [True: 0, False: 300]
  ------------------
  344|      0|    case 1600:	/* character  <- null       */
  ------------------
  |  Branch (344:5): [True: 0, False: 300]
  ------------------
  345|      0|    case 1900:  /* vector     <- null       */
  ------------------
  |  Branch (345:5): [True: 0, False: 300]
  ------------------
  346|      0|    case 2000:  /* expression <- null       */
  ------------------
  |  Branch (346:5): [True: 0, False: 300]
  ------------------
  347|      0|    case 2400:	/* raw        <- null       */
  ------------------
  |  Branch (347:5): [True: 0, False: 300]
  ------------------
  348|       |
  349|      0|    case 1010:	/* logical    <- logical    */
  ------------------
  |  Branch (349:5): [True: 0, False: 300]
  ------------------
  350|      0|    case 1310:	/* integer    <- logical    */
  ------------------
  |  Branch (350:5): [True: 0, False: 300]
  ------------------
  351|      0|    case 1410:	/* real	      <- logical    */
  ------------------
  |  Branch (351:5): [True: 0, False: 300]
  ------------------
  352|      0|    case 1510:	/* complex    <- logical    */
  ------------------
  |  Branch (352:5): [True: 0, False: 300]
  ------------------
  353|     90|    case 1313:	/* integer    <- integer    */
  ------------------
  |  Branch (353:5): [True: 90, False: 210]
  ------------------
  354|     90|    case 1413:	/* real	      <- integer    */
  ------------------
  |  Branch (354:5): [True: 0, False: 300]
  ------------------
  355|     90|    case 1513:	/* complex    <- integer    */
  ------------------
  |  Branch (355:5): [True: 0, False: 300]
  ------------------
  356|     90|    case 1414:	/* real	      <- real	    */
  ------------------
  |  Branch (356:5): [True: 0, False: 300]
  ------------------
  357|     90|    case 1514:	/* complex    <- real	    */
  ------------------
  |  Branch (357:5): [True: 0, False: 300]
  ------------------
  358|     90|    case 1515:	/* complex    <- complex    */
  ------------------
  |  Branch (358:5): [True: 0, False: 300]
  ------------------
  359|    106|    case 1616:	/* character  <- character  */
  ------------------
  |  Branch (359:5): [True: 16, False: 284]
  ------------------
  360|    281|    case 1919:  /* vector     <- vector     */
  ------------------
  |  Branch (360:5): [True: 175, False: 125]
  ------------------
  361|    281|    case 2020:	/* expression <- expression */
  ------------------
  |  Branch (361:5): [True: 0, False: 300]
  ------------------
  362|    281|    case 2424:	/* raw        <- raw        */
  ------------------
  |  Branch (362:5): [True: 0, False: 300]
  ------------------
  363|       |
  364|    281|	redo_which = false;
  365|    281|	break;
  366|       |
  367|      0|    case 1013:	/* logical    <- integer    */
  ------------------
  |  Branch (367:5): [True: 0, False: 300]
  ------------------
  368|       |
  369|      0|	*x = coerceVector(*x, INTSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              	*x = coerceVector(*x, INTSXP);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  370|      0|	break;
  371|       |
  372|      0|    case 1014:	/* logical    <- real	    */
  ------------------
  |  Branch (372:5): [True: 0, False: 300]
  ------------------
  373|      0|    case 1314:	/* integer    <- real	    */
  ------------------
  |  Branch (373:5): [True: 0, False: 300]
  ------------------
  374|       |
  375|      0|	*x = coerceVector(*x, REALSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              	*x = coerceVector(*x, REALSXP);
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  376|      0|	break;
  377|       |
  378|      0|    case 1015:	/* logical    <- complex    */
  ------------------
  |  Branch (378:5): [True: 0, False: 300]
  ------------------
  379|      0|    case 1315:	/* integer    <- complex    */
  ------------------
  |  Branch (379:5): [True: 0, False: 300]
  ------------------
  380|      0|    case 1415:	/* real	      <- complex    */
  ------------------
  |  Branch (380:5): [True: 0, False: 300]
  ------------------
  381|       |
  382|      0|	*x = coerceVector(*x, CPLXSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              	*x = coerceVector(*x, CPLXSXP);
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  383|      0|	break;
  384|       |
  385|      0|    case 1610:	/* character  <- logical    */
  ------------------
  |  Branch (385:5): [True: 0, False: 300]
  ------------------
  386|      0|    case 1613:	/* character  <- integer    */
  ------------------
  |  Branch (386:5): [True: 0, False: 300]
  ------------------
  387|      0|    case 1614:	/* character  <- real	    */
  ------------------
  |  Branch (387:5): [True: 0, False: 300]
  ------------------
  388|      0|    case 1615:	/* character  <- complex    */
  ------------------
  |  Branch (388:5): [True: 0, False: 300]
  ------------------
  389|       |
  390|      0|	*y = coerceVector(*y, STRSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              	*y = coerceVector(*y, STRSXP);
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  391|      0|	break;
  392|       |
  393|      0|    case 1016:	/* logical    <- character  */
  ------------------
  |  Branch (393:5): [True: 0, False: 300]
  ------------------
  394|      0|    case 1316:	/* integer    <- character  */
  ------------------
  |  Branch (394:5): [True: 0, False: 300]
  ------------------
  395|      0|    case 1416:	/* real	      <- character  */
  ------------------
  |  Branch (395:5): [True: 0, False: 300]
  ------------------
  396|      0|    case 1516:	/* complex    <- character  */
  ------------------
  |  Branch (396:5): [True: 0, False: 300]
  ------------------
  397|       |
  398|      0|	*x = coerceVector(*x, STRSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              	*x = coerceVector(*x, STRSXP);
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  399|      0|	break;
  400|       |
  401|      0|    case 1901:  /* vector     <- symbol   */
  ------------------
  |  Branch (401:5): [True: 0, False: 300]
  ------------------
  402|      0|    case 1902:	/* vector     <- pairlist */
  ------------------
  |  Branch (402:5): [True: 0, False: 300]
  ------------------
  403|      0|    case 1904:  /* vector     <- environment   */
  ------------------
  |  Branch (403:5): [True: 0, False: 300]
  ------------------
  404|      0|    case 1905:  /* vector     <- promise   */
  ------------------
  |  Branch (404:5): [True: 0, False: 300]
  ------------------
  405|      0|    case 1906:  /* vector     <- language   */
  ------------------
  |  Branch (405:5): [True: 0, False: 300]
  ------------------
  406|      0|    case 1910:  /* vector     <- logical    */
  ------------------
  |  Branch (406:5): [True: 0, False: 300]
  ------------------
  407|      0|    case 1913:  /* vector     <- integer    */
  ------------------
  |  Branch (407:5): [True: 0, False: 300]
  ------------------
  408|      9|    case 1914:  /* vector     <- real       */
  ------------------
  |  Branch (408:5): [True: 9, False: 291]
  ------------------
  409|      9|    case 1915:  /* vector     <- complex    */
  ------------------
  |  Branch (409:5): [True: 0, False: 300]
  ------------------
  410|     19|    case 1916:  /* vector     <- character  */
  ------------------
  |  Branch (410:5): [True: 10, False: 290]
  ------------------
  411|     19|    case 1920:  /* vector     <- expression  */
  ------------------
  |  Branch (411:5): [True: 0, False: 300]
  ------------------
  412|     19|    case 1921:  /* vector     <- bytecode   */
  ------------------
  |  Branch (412:5): [True: 0, False: 300]
  ------------------
  413|     19|    case 1922:  /* vector     <- external pointer */
  ------------------
  |  Branch (413:5): [True: 0, False: 300]
  ------------------
  414|     19|    case 1923:  /* vector     <- weak reference */
  ------------------
  |  Branch (414:5): [True: 0, False: 300]
  ------------------
  415|     19|    case 1924:  /* vector     <- raw */
  ------------------
  |  Branch (415:5): [True: 0, False: 300]
  ------------------
  416|     19|    case 1903: case 1907: case 1908: case 1999: /* functions */
  ------------------
  |  Branch (416:5): [True: 0, False: 300]
  |  Branch (416:16): [True: 0, False: 300]
  |  Branch (416:27): [True: 0, False: 300]
  |  Branch (416:38): [True: 0, False: 300]
  ------------------
  417|       |
  418|     19|	if (level == 1) {
  ------------------
  |  Branch (418:6): [True: 0, False: 19]
  ------------------
  419|       |	    /* Coerce the RHS into a list */
  420|      0|	    *y = coerceVector(*y, VECSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              	    *y = coerceVector(*y, VECSXP);
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  421|     19|	} else {
  422|       |	    /* Nothing to do here: duplicate when used (if needed) */
  423|     19|	    redo_which = false;
  424|     19|	}
  425|     19|	break;
  426|       |
  427|      0|    case 1925: /* vector <- S4|OBJ */
  ------------------
  |  Branch (427:5): [True: 0, False: 300]
  ------------------
  428|       |
  429|      0|	if (level == 1) {
  ------------------
  |  Branch (429:6): [True: 0, False: 0]
  ------------------
  430|       |	    /* Embed the RHS into a list */
  431|      0|	    *y = embedInVector(*y, call);
  432|      0|	} else {
  433|       |	    /* Nothing to do here: duplicate when used (if needed) */
  434|      0|	    redo_which = false;
  435|      0|	}
  436|      0|	break;
  437|       |
  438|      0|    case 1019:  /* logical    <- vector     */
  ------------------
  |  Branch (438:5): [True: 0, False: 300]
  ------------------
  439|      0|    case 1319:  /* integer    <- vector     */
  ------------------
  |  Branch (439:5): [True: 0, False: 300]
  ------------------
  440|      0|    case 1419:  /* real       <- vector     */
  ------------------
  |  Branch (440:5): [True: 0, False: 300]
  ------------------
  441|      0|    case 1519:  /* complex    <- vector     */
  ------------------
  |  Branch (441:5): [True: 0, False: 300]
  ------------------
  442|      0|    case 1619:  /* character  <- vector     */
  ------------------
  |  Branch (442:5): [True: 0, False: 300]
  ------------------
  443|      0|    case 2419:  /* raw        <- vector     */
  ------------------
  |  Branch (443:5): [True: 0, False: 300]
  ------------------
  444|      0|	*x = coerceVector(*x, VECSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              	*x = coerceVector(*x, VECSXP);
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  445|      0|	break;
  446|       |
  447|      0|    case 1020:  /* logical    <- expression */
  ------------------
  |  Branch (447:5): [True: 0, False: 300]
  ------------------
  448|      0|    case 1320:  /* integer    <- expression */
  ------------------
  |  Branch (448:5): [True: 0, False: 300]
  ------------------
  449|      0|    case 1420:  /* real       <- expression */
  ------------------
  |  Branch (449:5): [True: 0, False: 300]
  ------------------
  450|      0|    case 1520:  /* complex    <- expression */
  ------------------
  |  Branch (450:5): [True: 0, False: 300]
  ------------------
  451|      0|    case 1620:  /* character  <- expression */
  ------------------
  |  Branch (451:5): [True: 0, False: 300]
  ------------------
  452|      0|    case 2420:  /* raw        <- expression */
  ------------------
  |  Branch (452:5): [True: 0, False: 300]
  ------------------
  453|      0|	*x = coerceVector(*x, EXPRSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              	*x = coerceVector(*x, EXPRSXP);
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  454|      0|	break;
  455|       |
  456|      0|    case 2001:	/* expression <- symbol	    */
  ------------------
  |  Branch (456:5): [True: 0, False: 300]
  ------------------
  457|      0|    case 2002:  /* expression <- pairlist   */
  ------------------
  |  Branch (457:5): [True: 0, False: 300]
  ------------------
  458|      0|    case 2006:	/* expression <- language   */
  ------------------
  |  Branch (458:5): [True: 0, False: 300]
  ------------------
  459|      0|    case 2010:	/* expression <- logical    */
  ------------------
  |  Branch (459:5): [True: 0, False: 300]
  ------------------
  460|      0|    case 2013:	/* expression <- integer    */
  ------------------
  |  Branch (460:5): [True: 0, False: 300]
  ------------------
  461|      0|    case 2014:	/* expression <- real	    */
  ------------------
  |  Branch (461:5): [True: 0, False: 300]
  ------------------
  462|      0|    case 2015:	/* expression <- complex    */
  ------------------
  |  Branch (462:5): [True: 0, False: 300]
  ------------------
  463|      0|    case 2016:	/* expression <- character  */
  ------------------
  |  Branch (463:5): [True: 0, False: 300]
  ------------------
  464|      0|    case 2019:  /* expression <- vector     */
  ------------------
  |  Branch (464:5): [True: 0, False: 300]
  ------------------
  465|       |
  466|      0|	if (level == 1) {
  ------------------
  |  Branch (466:6): [True: 0, False: 0]
  ------------------
  467|       |	    /* Coerce the RHS into a list */
  468|      0|	    *y = coerceVector(*y, VECSXP);
  ------------------
  |  |  895|      0|#define coerceVector		Rf_coerceVector
  ------------------
              	    *y = coerceVector(*y, VECSXP);
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  469|      0|	} else {
  470|       |	    /* Note : No coercion is needed here. */
  471|       |	    /* We just insert the RHS into the LHS. */
  472|      0|	    redo_which = false;
  473|      0|	}
  474|      0|	break;
  475|       |
  476|      0|    case 2025: /* expression <- S4|OBJ */
  ------------------
  |  Branch (476:5): [True: 0, False: 300]
  ------------------
  477|       |
  478|      0|	if (level == 1) {
  ------------------
  |  Branch (478:6): [True: 0, False: 0]
  ------------------
  479|       |	    /* Embed the RHS into a list */
  480|      0|	    *y = embedInVector(*y, call);
  481|      0|	} else {
  482|       |	    /* Nothing to do here: duplicate when used (if needed) */
  483|      0|	    redo_which = false;
  484|      0|	}
  485|      0|	break;
  486|       |
  487|      0|    case 1025: /* logical   <- S4|OBJ */
  ------------------
  |  Branch (487:5): [True: 0, False: 300]
  ------------------
  488|      0|    case 1325: /* integer   <- S4|OBJ */
  ------------------
  |  Branch (488:5): [True: 0, False: 300]
  ------------------
  489|      0|    case 1425: /* real      <- S4|OBJ */
  ------------------
  |  Branch (489:5): [True: 0, False: 300]
  ------------------
  490|      0|    case 1525: /* complex   <- S4|OBJ */
  ------------------
  |  Branch (490:5): [True: 0, False: 300]
  ------------------
  491|      0|    case 1625: /* character <- S4|OBJ */
  ------------------
  |  Branch (491:5): [True: 0, False: 300]
  ------------------
  492|      0|    case 2425: /* raw       <- S4|OBJ */
  ------------------
  |  Branch (492:5): [True: 0, False: 300]
  ------------------
  493|      0|        if (dispatch_asvector(y, call, rho)) {
  ------------------
  |  Branch (493:13): [True: 0, False: 0]
  ------------------
  494|       |	    /*^^^^^^^^^^^^^^^ creates an unprotected *y; call below may allocate (coerceVector),
  495|       |	      so the new value has to be protected: */
  496|      0|            PROTECT(*y);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  497|      0|            which = SubassignTypeFix(x, y, stretch, level, call, rho);
  498|      0|            UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  499|      0|            return which;
  500|      0|        }
  501|       |
  502|      0|    default:
  ------------------
  |  Branch (502:5): [True: 0, False: 300]
  ------------------
  503|      0|	error(_("incompatible types (from %s to %s) in subassignment type fix"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("incompatible types (from %s to %s) in subassignment type fix"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  504|      0|	      R_typeToChar(*x), R_typeToChar(*y));
  505|    300|    } //--- end switch(which)
  506|       |
  507|    300|    if (stretch) {
  ------------------
  |  Branch (507:9): [True: 29, False: 271]
  ------------------
  508|     29|	PROTECT(*y);
  ------------------
  |  |  357|     29|#define PROTECT(s)	Rf_protect(s)
  ------------------
  509|     29|	*x = EnlargeVector(*x, stretch); // FIXME: 1d-array w/ {dim,dimnames} |--> vector w/ names
  510|     29|	UNPROTECT(1);
  ------------------
  |  |  358|     29|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  511|     29|    }
  512|    300|    SET_OBJECT(*x, x_is_object);
  513|       |
  514|    300|    if(redo_which)
  ------------------
  |  Branch (514:8): [True: 0, False: 300]
  ------------------
  515|      0|	return(100 * TYPEOF(*x) + TYPEOF(*y));
  516|    300|    else
  517|    300|	return(which);
  518|    300|} // SubassignTypeFix
subassign.c:EnlargeVector:
  141|     35|{
  142|     35|    R_xlen_t len, newtruelen;
  143|     35|    SEXP newx, names;
  144|     35|    static SEXP R_CheckBoundsSymbol = NULL;
  145|       |
  146|     35|    if (R_CheckBoundsSymbol == NULL)
  ------------------
  |  Branch (146:9): [True: 2, False: 33]
  ------------------
  147|      2|	R_CheckBoundsSymbol = install("check.bounds");
  ------------------
  |  |  934|      2|#define install			Rf_install
  ------------------
  148|       |
  149|       |    /* Sanity Checks */
  150|     35|    if (!isVector(x))
  ------------------
  |  |  974|     35|#define isVector		Rf_isVector
  ------------------
  |  Branch (150:9): [True: 0, False: 35]
  ------------------
  151|      0|	error(_("attempt to enlarge non-vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("attempt to enlarge non-vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  152|       |
  153|       |    /* Enlarge the vector itself. */
  154|     35|    len = xlength(x);
  ------------------
  |  | 1049|     35|#define xlength(x)		Rf_xlength(x)
  ------------------
  155|       |    /* x can be a fresh coercion that nothing else keeps alive (from
  156|       |       SubassignTypeFix()), and warning() and EnlargeNames() allocate. */
  157|     35|    PROTECT(x);
  ------------------
  |  |  357|     35|#define PROTECT(s)	Rf_protect(s)
  ------------------
  158|     35|    if (LOGICAL(GetOption1(R_CheckBoundsSymbol))[0])
  ------------------
  |  |  928|     35|#define GetOption1		Rf_GetOption1
  ------------------
  |  Branch (158:9): [True: 0, False: 35]
  ------------------
  159|      0|	warning(_("assignment outside vector/list limits (extending from %lld to %lld)"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("assignment outside vector/list limits (extending from %lld to %lld)"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  160|      0|		(long long)len, (long long)newlen);
  161|       |
  162|       |    /* if the vector is not shared, is growable, and has room, then
  163|       |       increase its length */
  164|     35|    if (! MAYBE_SHARED(x) &&
  ------------------
  |  Branch (164:9): [True: 29, False: 6]
  ------------------
  165|     29|	IS_GROWABLE(x) &&
  ------------------
  |  Branch (165:2): [True: 0, False: 29]
  ------------------
  166|      0|	XTRUELENGTH(x) >= newlen) {
  ------------------
  |  Branch (166:2): [True: 0, False: 0]
  ------------------
  167|      0|	SET_STDVEC_LENGTH(x, newlen);
  ------------------
  |  |   99|      0|# define SET_STDVEC_LENGTH(x, v) SETLENGTH(x, v)
  ------------------
  168|      0|	if (ATTRIB(x) != R_NilValue) {
  ------------------
  |  Branch (168:6): [True: 0, False: 0]
  ------------------
  169|      0|	    names = getNames(x);
  170|      0|	    if (!isNull(names)) {
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
  |  Branch (170:10): [True: 0, False: 0]
  ------------------
  171|      0|		SEXP newnames = EnlargeNames(names, len, newlen);
  172|      0|		if (names != newnames)
  ------------------
  |  Branch (172:7): [True: 0, False: 0]
  ------------------
  173|      0|		    setAttrib(x, R_NamesSymbol, newnames);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  174|      0|	    }
  175|      0|	    if (getAttrib(x, R_DimSymbol) != R_NilValue)
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (175:10): [True: 0, False: 0]
  ------------------
  176|      0|		setAttrib(x, R_DimSymbol, R_NilValue);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  177|      0|	    if (getAttrib(x, R_DimNamesSymbol) != R_NilValue)
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (177:10): [True: 0, False: 0]
  ------------------
  178|      0|		setAttrib(x, R_DimNamesSymbol, R_NilValue);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  179|      0|	}
  180|      0|	UNPROTECT(1); /* x */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  181|      0|	return x;
  182|      0|    }
  183|       |
  184|       |    /* over-committing by 5% seems to be reasonable, but for
  185|       |       experimenting the environment variable R_EXPAND_Frac can be
  186|       |       used to adjust this */
  187|     35|    static double expand_dflt = 1.05;
  188|     35|    static double expand = 0;
  189|     35|    if (expand == 0) {
  ------------------
  |  Branch (189:9): [True: 2, False: 33]
  ------------------
  190|      2|	char *envval = getenv("R_EXPAND_FRAC");
  191|      2|	expand = envval != NULL ? atof(envval) : expand_dflt;
  ------------------
  |  Branch (191:11): [True: 0, False: 2]
  ------------------
  192|      2|	if (expand < 1 || expand > 2) {
  ------------------
  |  Branch (192:6): [True: 0, False: 2]
  |  Branch (192:20): [True: 0, False: 2]
  ------------------
  193|      0|	    expand = expand_dflt;
  194|      0|	    error("bad expand value");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  195|      0|	}
  196|      2|    }
  197|       |
  198|     35|    if (newlen > len) {
  ------------------
  |  Branch (198:9): [True: 35, False: 0]
  ------------------
  199|     35|	double expanded_nlen = (double)newlen * expand;
  200|     35|	if (expanded_nlen <= R_XLEN_T_MAX)
  ------------------
  |  |   76|     35|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (200:6): [True: 35, False: 0]
  ------------------
  201|     35|	    newtruelen = (R_xlen_t) expanded_nlen;
  202|      0|	else
  203|      0|	    newtruelen = newlen;
  204|     35|    }
  205|      0|    else
  206|       |	/* sometimes this is called when no expansion is needed */
  207|      0|	newtruelen = newlen;
  208|       |
  209|       |    /**** for now, don't cross the long vector boundary; drop when
  210|       |	  ALTREP is merged */
  211|       |/*
  212|       |#ifdef ALTREP
  213|       |#error drop the limitation to short vectors
  214|       |#endif
  215|       |
  216|       |    if (newtruelen > R_LEN_T_MAX) newtruelen = newlen;
  217|       |*/
  218|     35|    PROTECT(newx = allocVector(TYPEOF(x), newtruelen));
  ------------------
  |  |  357|     35|#define PROTECT(s)	Rf_protect(s)
  ------------------
  219|       |
  220|       |    /* Copy the elements into place. */
  221|     35|    switch(TYPEOF(x)) {
  222|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (222:5): [True: 0, False: 35]
  ------------------
  223|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (223:5): [True: 0, False: 35]
  ------------------
  224|      0|	for (R_xlen_t i = 0; i < len; i++)
  ------------------
  |  Branch (224:23): [True: 0, False: 0]
  ------------------
  225|      0|	    INTEGER0(newx)[i] = INTEGER_ELT(x, i);
  226|      0|	for (R_xlen_t i = len; i < newtruelen; i++)
  ------------------
  |  Branch (226:25): [True: 0, False: 0]
  ------------------
  227|      0|	    INTEGER0(newx)[i] = NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  228|      0|	break;
  229|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (229:5): [True: 0, False: 35]
  ------------------
  230|      0|	for (R_xlen_t i = 0; i < len; i++)
  ------------------
  |  Branch (230:23): [True: 0, False: 0]
  ------------------
  231|      0|	    REAL0(newx)[i] = REAL_ELT(x, i);
  232|      0|	for (R_xlen_t i = len; i < newtruelen; i++)
  ------------------
  |  Branch (232:25): [True: 0, False: 0]
  ------------------
  233|      0|	    REAL0(newx)[i] = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  234|      0|	break;
  235|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (235:5): [True: 0, False: 35]
  ------------------
  236|      0|	for (R_xlen_t i = 0; i < len; i++)
  ------------------
  |  Branch (236:23): [True: 0, False: 0]
  ------------------
  237|      0|	    COMPLEX0(newx)[i] = COMPLEX_ELT(x, i);
  238|      0|	for (R_xlen_t i = len; i < newtruelen; i++) {
  ------------------
  |  Branch (238:25): [True: 0, False: 0]
  ------------------
  239|      0|	    COMPLEX0(newx)[i].r = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  240|      0|	    COMPLEX0(newx)[i].i = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  241|      0|	}
  242|      0|	break;
  243|      6|    case STRSXP:
  ------------------
  |  |  126|      6|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (243:5): [True: 6, False: 29]
  ------------------
  244|     19|	for (R_xlen_t i = 0; i < len; i++)
  ------------------
  |  Branch (244:23): [True: 13, False: 6]
  ------------------
  245|     13|	    SET_STRING_ELT(newx, i, STRING_ELT(x, i));
  246|     12|	for (R_xlen_t i = len; i < newtruelen; i++)
  ------------------
  |  Branch (246:25): [True: 6, False: 6]
  ------------------
  247|      6|	    SET_STRING_ELT(newx, i, NA_STRING); /* was R_BlankString  < 1.6.0 */
  ------------------
  |  |  433|      6|#define NA_STRING	R_NaString
  ------------------
  248|      6|	break;
  249|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (249:5): [True: 0, False: 35]
  ------------------
  250|     29|    case VECSXP:
  ------------------
  |  |  131|     29|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (250:5): [True: 29, False: 6]
  ------------------
  251|     42|	for (R_xlen_t i = 0; i < len; i++)
  ------------------
  |  Branch (251:23): [True: 13, False: 29]
  ------------------
  252|     13|	    SET_VECTOR_ELT(newx, i, VECTOR_ELT(x, i));
  253|     58|	for (R_xlen_t i = len; i < newtruelen; i++)
  ------------------
  |  Branch (253:25): [True: 29, False: 29]
  ------------------
  254|     29|	    SET_VECTOR_ELT(newx, i, R_NilValue);
  255|     29|	break;
  256|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (256:5): [True: 0, False: 35]
  ------------------
  257|      0|	for (R_xlen_t i = 0; i < len; i++)
  ------------------
  |  Branch (257:23): [True: 0, False: 0]
  ------------------
  258|      0|	    RAW0(newx)[i] = RAW_ELT(x, i);
  259|      0|	for (R_xlen_t i = len; i < newtruelen; i++)
  ------------------
  |  Branch (259:25): [True: 0, False: 0]
  ------------------
  260|      0|	    RAW0(newx)[i] = (Rbyte) 0;
  261|      0|	break;
  262|      0|    default:
  ------------------
  |  Branch (262:5): [True: 0, False: 35]
  ------------------
  263|      0|	UNIMPLEMENTED_TYPE("EnlargeVector", x);
  264|     35|    }
  265|     35|    if (newlen < newtruelen) {
  ------------------
  |  Branch (265:9): [True: 0, False: 35]
  ------------------
  266|      0|	SET_GROWABLE_BIT(newx);
  267|      0|	SET_TRUELENGTH(newx, newtruelen);
  268|      0|	SET_STDVEC_LENGTH(newx, newlen);
  ------------------
  |  |   99|      0|# define SET_STDVEC_LENGTH(x, v) SETLENGTH(x, v)
  ------------------
  269|      0|    }
  270|       |
  271|       |    /* Adjust the attribute list. */
  272|     35|    names = getNames(x);
  273|     35|    if (!isNull(names))
  ------------------
  |  |  956|     35|#define isNull			Rf_isNull
  ------------------
  |  Branch (273:9): [True: 6, False: 29]
  ------------------
  274|      6|	setAttrib(newx, R_NamesSymbol, EnlargeNames(names, len, newlen));
  ------------------
  |  | 1027|      6|#define setAttrib		Rf_setAttrib
  ------------------
  275|     35|    copyMostAttrib(x, newx);
  ------------------
  |  |  901|     35|#define copyMostAttrib		Rf_copyMostAttrib
  ------------------
  276|     35|    UNPROTECT(2);
  ------------------
  |  |  358|     35|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  277|     35|    return newx;
  278|     35|}
subassign.c:getNames:
  120|     35|{
  121|       |    /* defer to getAttrib if a 'dim' attribute is present */
  122|     41|    for (SEXP attr = ATTRIB(x); attr != R_NilValue; attr = CDR(attr))
  ------------------
  |  Branch (122:33): [True: 6, False: 35]
  ------------------
  123|      6|	if (TAG(attr) == R_DimSymbol)
  ------------------
  |  Branch (123:6): [True: 0, False: 6]
  ------------------
  124|      0|	    return getAttrib(x, R_NamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  125|       |
  126|       |    /* don't use getAttrib since that would mark as immutable */
  127|     35|    for (SEXP attr = ATTRIB(x); attr != R_NilValue; attr = CDR(attr))
  ------------------
  |  Branch (127:33): [True: 6, False: 29]
  ------------------
  128|      6|	if (TAG(attr) == R_NamesSymbol)
  ------------------
  |  Branch (128:6): [True: 6, False: 0]
  ------------------
  129|      6|	    return CAR(attr);
  130|       |
  131|     29|    return R_NilValue;
  132|     35|}
subassign.c:EnlargeNames:
  281|      6|{
  282|      6|    if (TYPEOF(names) != STRSXP || XLENGTH(names) != len)
  ------------------
  |  |  126|     12|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (282:9): [True: 0, False: 6]
  |  Branch (282:36): [True: 0, False: 6]
  ------------------
  283|      0|	error(_("bad names attribute"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("bad names attribute"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  284|      6|    SEXP newnames = PROTECT(EnlargeVector(names, newlen));
  ------------------
  |  |  357|      6|#define PROTECT(s)	Rf_protect(s)
  ------------------
  285|     12|    for (R_xlen_t i = len; i < newlen; i++)
  ------------------
  |  Branch (285:28): [True: 6, False: 6]
  ------------------
  286|      6|	SET_STRING_ELT(newnames, i, R_BlankString);
  287|      6|    UNPROTECT(1);
  ------------------
  |  |  358|      6|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  288|      6|    return newnames;
  289|      6|}

Rf_OneIndex:
  110|     29|{
  111|     29|    SEXP names;
  112|     29|    R_xlen_t i, indx;
  113|     29|    const void *vmax;
  114|       |
  115|     29|    if (pos < 0 && length(s) > 1) {
  ------------------
  |  |  987|     29|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (115:9): [True: 29, False: 0]
  |  Branch (115:20): [True: 0, False: 29]
  ------------------
  116|      0|	ECALL3(call, _("attempt to select more than one element in %s"), "OneIndex");
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  117|      0|    }
  118|     29|    if (pos < 0 && length(s) < 1) {
  ------------------
  |  |  987|     29|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (118:9): [True: 29, False: 0]
  |  Branch (118:20): [True: 0, False: 29]
  ------------------
  119|      0|	ECALL3(call, _("attempt to select less than one element in %s"), "OneIndex");
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  120|      0|    }
  121|       |
  122|     29|    if(pos < 0) pos = 0;
  ------------------
  |  Branch (122:8): [True: 29, False: 0]
  ------------------
  123|       |
  124|     29|    indx = -1;
  125|     29|    *newname = R_NilValue;
  126|     29|    switch(TYPEOF(s)) {
  127|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (127:5): [True: 0, False: 29]
  ------------------
  128|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (128:5): [True: 0, False: 29]
  ------------------
  129|      0|	indx = integerOneIndex(INTEGER_ELT(s, pos), nx, call);
  130|      0|	break;
  131|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (131:5): [True: 0, False: 29]
  ------------------
  132|      0|    {
  133|      0|	double dblind = REAL_ELT(s, pos);
  134|      0|	if(!ISNAN(dblind)) {
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  ------------------
  |  Branch (134:5): [True: 0, False: 0]
  ------------------
  135|       |	    /* see comment above integerOneIndex */
  136|      0|	    if (dblind >= 1) indx = (R_xlen_t)(dblind - 1);
  ------------------
  |  Branch (136:10): [True: 0, False: 0]
  ------------------
  137|      0|	    else if (dblind > -1 || nx < 2) {
  ------------------
  |  Branch (137:15): [True: 0, False: 0]
  |  Branch (137:30): [True: 0, False: 0]
  ------------------
  138|      0|		ECALL3(call, _("attempt to select less than one element in %s"), "OneIndex <real>");
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  139|      0|	    } else if (nx == 2 && dblind > -3)
  ------------------
  |  Branch (139:17): [True: 0, False: 0]
  |  Branch (139:28): [True: 0, False: 0]
  ------------------
  140|      0|		indx = 2 + (R_xlen_t) dblind;
  141|      0|	    else {
  142|      0|		ECALL3(call, _("attempt to select more than one element in %s"), "OneIndex <real>");
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  143|      0|	    }
  144|      0|	}
  145|      0|	break;
  146|      0|    }
  147|     29|    case STRSXP:
  ------------------
  |  |  126|     29|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (147:5): [True: 29, False: 0]
  ------------------
  148|     29|	vmax = vmaxget();
  149|     29|	names = getAttrib(x, R_NamesSymbol);
  ------------------
  |  |  924|     29|#define getAttrib		Rf_getAttrib
  ------------------
  150|     29|	if (names != R_NilValue) {
  ------------------
  |  Branch (150:6): [True: 6, False: 23]
  ------------------
  151|      6|	    PROTECT(names);
  ------------------
  |  |  357|      6|#define PROTECT(s)	Rf_protect(s)
  ------------------
  152|       |	    /* Try for exact match */
  153|     19|	    for (i = 0; i < nx; i++) {
  ------------------
  |  Branch (153:18): [True: 13, False: 6]
  ------------------
  154|     13|		const char *tmp = translateChar(STRING_ELT(names, i));
  ------------------
  |  | 1037|     13|#define translateChar		Rf_translateChar
  ------------------
  155|     13|		if (!tmp[0]) continue;
  ------------------
  |  Branch (155:7): [True: 0, False: 13]
  ------------------
  156|     13|		if (streql(tmp, translateChar(STRING_ELT(s, pos)))) {
  ------------------
  |  | 1498|     13|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 13]
  |  |  ------------------
  ------------------
  157|      0|		    indx = i;
  158|      0|		    break;
  159|      0|		}
  160|     13|	    }
  161|       |	    // Try for partial match -- not ever used in current R (partial is 0)
  162|      6|	    if (partial && indx < 0) {
  ------------------
  |  Branch (162:10): [True: 0, False: 6]
  |  Branch (162:21): [True: 0, False: 0]
  ------------------
  163|      0|		size_t l = strlen(translateChar(STRING_ELT(s, pos)));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  164|      0|		for(i = 0; i < nx; i++) {
  ------------------
  |  Branch (164:14): [True: 0, False: 0]
  ------------------
  165|      0|		    const char *tmp = translateChar(STRING_ELT(names, i));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  166|      0|		    if (!tmp[0]) continue;
  ------------------
  |  Branch (166:11): [True: 0, False: 0]
  ------------------
  167|      0|		    if(!strncmp(tmp, translateChar(STRING_ELT(s, pos)), l)) {
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  |  Branch (167:10): [True: 0, False: 0]
  ------------------
  168|      0|			if(indx == -1 )
  ------------------
  |  Branch (168:7): [True: 0, False: 0]
  ------------------
  169|      0|			    indx = i;
  170|      0|			else
  171|      0|			    indx = -2;
  172|      0|		    }
  173|      0|		}
  174|      0|	    }
  175|      6|	    UNPROTECT(1); /* names */
  ------------------
  |  |  358|      6|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  176|      6|	}
  177|     29|	if (indx == -1)
  ------------------
  |  Branch (177:6): [True: 29, False: 0]
  ------------------
  178|     29|	    indx = nx;
  179|     29|	*newname = STRING_ELT(s, pos);
  180|     29|	vmaxset(vmax);
  181|     29|	break;
  182|      0|    case SYMSXP:
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (182:5): [True: 0, False: 29]
  ------------------
  183|      0|	vmax = vmaxget();
  184|      0|	names = getAttrib(x, R_NamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  185|      0|	if (names != R_NilValue) {
  ------------------
  |  Branch (185:6): [True: 0, False: 0]
  ------------------
  186|      0|	    PROTECT(names);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  187|      0|	    for (i = 0; i < nx; i++)
  ------------------
  |  Branch (187:18): [True: 0, False: 0]
  ------------------
  188|      0|		if (streql(translateChar(STRING_ELT(names, i)),
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  189|      0|			   CHAR(PRINTNAME(s)))) {
  190|      0|		    indx = i;
  191|      0|		    break;
  192|      0|		}
  193|      0|	    UNPROTECT(1); /* names */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  194|      0|	}
  195|      0|	if (indx == -1)
  ------------------
  |  Branch (195:6): [True: 0, False: 0]
  ------------------
  196|      0|	    indx = nx;
  197|      0|	*newname = PRINTNAME(s);
  198|      0|	vmaxset(vmax);
  199|      0|	break;
  200|      0|    default:
  ------------------
  |  Branch (200:5): [True: 0, False: 29]
  ------------------
  201|      0|	ECALL3(call, _("invalid subscript type '%s'"), R_typeToChar(s));
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  202|     29|    }
  203|     29|    return indx;
  204|     29|}
Rf_get1index:
  209|   775k|{
  210|       |/* Get a single index for the [[ and [[<- operators.
  211|       |   Checks that only one index is being selected.
  212|       |   Returns -1 for no match.
  213|       |
  214|       |   s is the subscript
  215|       |   len is the length of the object or dimension, with names its (dim)names.
  216|       |   pos is len-1 or -1 for [[, -1 for [[<-
  217|       |     -1 means use the only element of length-1 s.
  218|       |   pok : is "partial ok" ?
  219|       |	 if pok is -1, warn if partial matching occurs, but allow.
  220|       |*/
  221|   775k|    const char *ss, *cur_name;
  222|   775k|    const void *vmax;
  223|       |
  224|   775k|    int warn_pok = (pok == -1);
  225|   775k|    if (warn_pok)
  ------------------
  |  Branch (225:9): [True: 0, False: 775k]
  ------------------
  226|      0|	pok = 1;
  227|       |
  228|   775k|    if (pos < 0 && length(s) != 1) {
  ------------------
  |  |  987|   775k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (228:9): [True: 775k, False: 0]
  |  Branch (228:20): [True: 0, False: 775k]
  ------------------
  229|      0|	if (length(s) > 1) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (229:6): [True: 0, False: 0]
  ------------------
  230|      0|	    ECALL3(call, _("attempt to select more than one element in %s"), "get1index");
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  231|      0|	} else {
  232|      0|	    ECALL3(call, _("attempt to select less than one element in %s"), "get1index");
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  233|      0|	}
  234|   775k|    } else if(pos >= length(s)) {
  ------------------
  |  |  987|   775k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (234:15): [True: 0, False: 775k]
  ------------------
  235|      0|	ECALL(call, _("internal error in use of recursive indexing"));
  ------------------
  |  |   46|      0|#define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (46:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  236|      0|    }
  237|   775k|    if(pos < 0) pos = 0;
  ------------------
  |  Branch (237:8): [True: 775k, False: 0]
  ------------------
  238|   775k|    R_xlen_t indx = -1;
  239|   775k|    switch (TYPEOF(s)) {
  240|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (240:5): [True: 0, False: 775k]
  ------------------
  241|  2.18k|    case INTSXP:
  ------------------
  |  |  123|  2.18k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (241:5): [True: 2.18k, False: 773k]
  ------------------
  242|  2.18k|    {
  243|  2.18k|	int i = INTEGER_ELT(s, pos);
  244|  2.18k|	if (i != NA_INTEGER)
  ------------------
  |  |   56|  2.18k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (244:6): [True: 2.18k, False: 0]
  ------------------
  245|  2.18k|	    indx = integerOneIndex(i, len, call);
  246|  2.18k|	break;
  247|      0|    }
  248|    278|    case REALSXP:
  ------------------
  |  |  124|    278|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (248:5): [True: 278, False: 775k]
  ------------------
  249|    278|    {
  250|    278|	double dblind = REAL_ELT(s, pos);
  251|    278|	if(!ISNAN(dblind)) {
  ------------------
  |  |   76|    278|#  define ISNAN(x)     (isnan(x)!=0)
  ------------------
  |  Branch (251:5): [True: 278, False: 0]
  ------------------
  252|       |	    /* see comment above integerOneIndex */
  253|    278|	    if (dblind >= 1) {
  ------------------
  |  Branch (253:10): [True: 278, False: 0]
  ------------------
  254|    278|		if(R_FINITE(dblind)) indx = (R_xlen_t)(dblind - 1);
  ------------------
  |  |   82|    278|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (254:6): [True: 278, False: 0]
  ------------------
  255|    278|	    } else if (dblind > -1 || len < 2) {
  ------------------
  |  Branch (255:17): [True: 0, False: 0]
  |  Branch (255:32): [True: 0, False: 0]
  ------------------
  256|      0|		ECALL3(call,
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  |  Branch (47:58): [True: 0, False: 0]
  |  |  |  Branch (47:87): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  257|      0|		       (dblind <= -1) ? _("invalid negative subscript in %s")
  258|      0|		       : _("attempt to select less than one element in %s"),
  259|      0|		       "get1index <real>");
  260|      0|	    } else if (len == 2 && dblind > -3) // dblind = -2 or -1 {why exception ?}
  ------------------
  |  Branch (260:17): [True: 0, False: 0]
  |  Branch (260:29): [True: 0, False: 0]
  ------------------
  261|      0|		indx = 2 + (R_xlen_t) dblind;
  262|      0|	    else {
  263|      0|		ECALL3(call,
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  |  Branch (47:58): [True: 0, False: 0]
  |  |  |  Branch (47:87): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  264|      0|		       (dblind <= -1) ? _("invalid negative subscript in %s")
  265|      0|		       : _("attempt to select more than one element in %s"),
  266|      0|		       "get1index <real>");
  267|      0|	    }
  268|    278|	}
  269|    278|	break;
  270|      0|    }
  271|   772k|    case STRSXP:
  ------------------
  |  |  126|   772k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (271:5): [True: 772k, False: 2.46k]
  ------------------
  272|       |	/* NA matches nothing */
  273|   772k|	if(STRING_ELT(s, pos) == NA_STRING) break;
  ------------------
  |  |  433|   772k|#define NA_STRING	R_NaString
  ------------------
  |  Branch (273:5): [True: 0, False: 772k]
  ------------------
  274|       |	/* "" matches nothing: see names.Rd */
  275|   772k|	if(!CHAR(STRING_ELT(s, pos))[0]) break;
  ------------------
  |  |  203|   772k|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (275:5): [True: 0, False: 772k]
  ------------------
  276|       |
  277|       |	/* Try for exact match */
  278|   772k|	vmax = vmaxget();
  279|   772k|	ss = translateChar(STRING_ELT(s, pos));
  ------------------
  |  | 1037|   772k|#define translateChar		Rf_translateChar
  ------------------
  280|   784k|	for (R_xlen_t i = 0; i < xlength(names); i++)
  ------------------
  |  | 1049|   784k|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (280:23): [True: 782k, False: 1.95k]
  ------------------
  281|   782k|	    if (STRING_ELT(names, i) != NA_STRING) {
  ------------------
  |  |  433|   782k|#define NA_STRING	R_NaString
  ------------------
  |  Branch (281:10): [True: 782k, False: 0]
  ------------------
  282|   782k|		if (streql(translateChar(STRING_ELT(names, i)), ss)) {
  ------------------
  |  | 1498|   782k|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 770k, False: 11.0k]
  |  |  ------------------
  ------------------
  283|   770k|		    indx = i;
  284|   770k|		    break;
  285|   770k|		}
  286|   782k|	    }
  287|       |	/* Try for partial match */
  288|   772k|	if (pok && indx < 0) {
  ------------------
  |  Branch (288:6): [True: 0, False: 772k]
  |  Branch (288:13): [True: 0, False: 0]
  ------------------
  289|      0|	    size_t len = strlen(ss);
  290|      0|	    for(R_xlen_t i = 0; i < xlength(names); i++) {
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (290:26): [True: 0, False: 0]
  ------------------
  291|      0|		if (STRING_ELT(names, i) != NA_STRING) {
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (291:7): [True: 0, False: 0]
  ------------------
  292|      0|		    cur_name = translateChar(STRING_ELT(names, i));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
  293|      0|		    if(!strncmp(cur_name, ss, len)) {
  ------------------
  |  Branch (293:10): [True: 0, False: 0]
  ------------------
  294|      0|			if(indx == -1) {/* first one */
  ------------------
  |  Branch (294:7): [True: 0, False: 0]
  ------------------
  295|      0|			    indx = i;
  296|      0|			    if (warn_pok) {
  ------------------
  |  Branch (296:12): [True: 0, False: 0]
  ------------------
  297|      0|				if (call == R_NilValue)
  ------------------
  |  Branch (297:9): [True: 0, False: 0]
  ------------------
  298|      0|				    warning(_("partial match of '%s' to '%s'"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              				    warning(_("partial match of '%s' to '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  299|      0|					    ss, cur_name);
  300|      0|				else
  301|      0|				    warningcall(call,
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
  302|      0|						_("partial match of '%s' to '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  303|      0|						ss, cur_name);
  304|      0|			    }
  305|      0|			}
  306|      0|			else {
  307|      0|			    indx = -2;/* more than one partial match */
  308|      0|			    if (warn_pok) /* already given context */
  ------------------
  |  Branch (308:12): [True: 0, False: 0]
  ------------------
  309|      0|				warningcall(R_NilValue,
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
  310|      0|					    _("further partial match of '%s' to '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  311|      0|					    ss, cur_name);
  312|      0|			    break;
  313|      0|			}
  314|      0|		    }
  315|      0|		}
  316|      0|	    }
  317|      0|	}
  318|   772k|	vmaxset(vmax);
  319|   772k|	break;
  320|      0|    case SYMSXP:
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (320:5): [True: 0, False: 775k]
  ------------------
  321|      0|	if (s == R_MissingArg) {
  ------------------
  |  Branch (321:6): [True: 0, False: 0]
  ------------------
  322|      0|	    ECALL_MissingSubs(call);
  323|      0|	}
  324|      0|	vmax = vmaxget();
  325|      0|	for (R_xlen_t i = 0; i < xlength(names); i++)
  ------------------
  |  | 1049|      0|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (325:23): [True: 0, False: 0]
  ------------------
  326|      0|	    if (STRING_ELT(names, i) != NA_STRING &&
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (326:10): [True: 0, False: 0]
  ------------------
  327|      0|		streql(translateChar(STRING_ELT(names, i)),
  ------------------
  |  | 1498|      0|#define streql(s, t)	(!strcmp((s), (t)))
  |  |  ------------------
  |  |  |  Branch (1498:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  328|      0|		       CHAR(PRINTNAME(s)))) {
  329|      0|		indx = i;
  330|      0|		vmaxset(vmax);
  331|      0|		break;
  332|      0|	    }
  333|      0|	break;
  334|      0|    default:
  ------------------
  |  Branch (334:5): [True: 0, False: 775k]
  ------------------
  335|      0|	ECALL3(call, _("invalid subscript type '%s'"), R_typeToChar(s));
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  336|   775k|    }
  337|   775k|    return indx;
  338|   775k|}
int_arraySubscript:
 1006|  4.84k|{
 1007|  4.84k|    int nd, ns;
 1008|  4.84k|    R_xlen_t stretch = 0;
 1009|  4.84k|    SEXP dnames, tmp;
 1010|  4.84k|    ns = length(s);
  ------------------
  |  |  987|  4.84k|#define length(x)		Rf_length(x)
  ------------------
 1011|  4.84k|    nd = INTEGER_ELT(dims, dim);
 1012|       |
 1013|  4.84k|    switch (TYPEOF(s)) {
 1014|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1014:5): [True: 0, False: 4.84k]
  ------------------
 1015|      0|	return allocVector(INTSXP, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	return allocVector(INTSXP, 0);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
 1016|     40|    case LGLSXP:
  ------------------
  |  |  121|     40|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1016:5): [True: 40, False: 4.80k]
  ------------------
 1017|     40|	return logicalSubscript(s, ns, nd, &stretch, call, dim + 1);
 1018|  2.33k|    case INTSXP:
  ------------------
  |  |  123|  2.33k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1018:5): [True: 2.33k, False: 2.50k]
  ------------------
 1019|  2.33k|	return integerSubscript(s, ns, nd, &stretch, call, x, dim);
 1020|  2.35k|    case REALSXP:
  ------------------
  |  |  124|  2.35k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1020:5): [True: 2.35k, False: 2.48k]
  ------------------
 1021|       |	/* We don't yet allow subscripts > R_SHORT_LEN_MAX */
 1022|  2.35k|	PROTECT(tmp = coerceVector(s, INTSXP));
  ------------------
  |  |  357|  2.35k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1023|  2.35k|	tmp = integerSubscript(tmp, ns, nd, &stretch, call, x, dim);
 1024|  2.35k|	UNPROTECT(1);
  ------------------
  |  |  358|  2.35k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1025|  2.35k|	return tmp;
 1026|      0|    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1026:5): [True: 0, False: 4.84k]
  ------------------
 1027|      0|	dnames = getAttrib(x, R_DimNamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 1028|      0|	if (dnames == R_NilValue) {
  ------------------
  |  Branch (1028:6): [True: 0, False: 0]
  ------------------
 1029|      0|	    ECALL(call, _("no 'dimnames' attribute for array"));
  ------------------
  |  |   46|      0|#define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (46:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1030|      0|	}
 1031|      0|	dnames = VECTOR_ELT(dnames, dim);
 1032|      0|	return stringSubscript(s, ns, nd, dnames, &stretch, call, x, dim);
 1033|    116|    case SYMSXP:
  ------------------
  |  |  112|    116|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1033:5): [True: 116, False: 4.72k]
  ------------------
 1034|    116|	if (s == R_MissingArg)
  ------------------
  |  Branch (1034:6): [True: 116, False: 0]
  ------------------
 1035|    116|	    return nullSubscript(nd);
 1036|      0|    default:
  ------------------
  |  Branch (1036:5): [True: 0, False: 4.84k]
  ------------------
 1037|      0|	ECALL3(call, _("invalid subscript type '%s'"), R_typeToChar(s));
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1038|  4.84k|    }
 1039|      0|    return R_NilValue;
 1040|  4.84k|}
Rf_makeSubscript:
 1063|   390k|{
 1064|   390k|    if (! (isVector(x) || isList(x) || isLanguage(x))) {
  ------------------
  |  |  974|   390k|#define isVector		Rf_isVector
  ------------------
                  if (! (isVector(x) || isList(x) || isLanguage(x))) {
  ------------------
  |  |  951|      0|#define isList			Rf_isList
  ------------------
                  if (! (isVector(x) || isList(x) || isLanguage(x))) {
  ------------------
  |  |  950|      0|#define isLanguage		Rf_isLanguage
  ------------------
  |  Branch (1064:12): [True: 390k, False: 0]
  |  Branch (1064:27): [True: 0, False: 0]
  |  Branch (1064:40): [True: 0, False: 0]
  ------------------
 1065|      0|	ECALL(call, _("subscripting on non-vector"));
  ------------------
  |  |   46|      0|#define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (46:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1066|      0|    }
 1067|       |
 1068|   390k|    R_xlen_t nx = xlength(x);
  ------------------
  |  | 1049|   390k|#define xlength(x)		Rf_xlength(x)
  ------------------
 1069|       |
 1070|       |    /* special case for simple indices -- does not duplicate */
 1071|   390k|    if (IS_SCALAR(s, INTSXP)) {
  ------------------
  |  |  123|   390k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1071:9): [True: 387k, False: 3.11k]
  ------------------
 1072|   387k|	int i = SCALAR_IVAL(s);
 1073|   387k|	if (0 < i && i <= nx) {
  ------------------
  |  Branch (1073:6): [True: 387k, False: 8]
  |  Branch (1073:15): [True: 387k, False: 0]
  ------------------
 1074|   387k|	    *stretch = 0;
 1075|   387k|	    return s;
 1076|   387k|	}
 1077|   387k|    }
 1078|  3.11k|    else if (IS_SCALAR(s, REALSXP)) {
  ------------------
  |  |  124|  3.11k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1078:14): [True: 125, False: 2.99k]
  ------------------
 1079|    125|	double di = SCALAR_DVAL(s);
 1080|    125|	if (1 <= di && di <= nx) {
  ------------------
  |  Branch (1080:6): [True: 4, False: 121]
  |  Branch (1080:17): [True: 4, False: 0]
  ------------------
 1081|      4|	    *stretch = 0;
 1082|       |	    /* We could only return a REALSXP if the value is too
 1083|       |	       large for an INTSXP, but, as the calling code can
 1084|       |	       handle REALSXP indices, returning the REALSXP
 1085|       |	       avoids an allocation. */
 1086|      4|	    return s;
 1087|      4|	}
 1088|    125|    }
 1089|       |
 1090|  3.12k|    R_xlen_t ns = xlength(s);
  ------------------
  |  | 1049|  3.12k|#define xlength(x)		Rf_xlength(x)
  ------------------
 1091|  3.12k|    SEXP ans = R_NilValue;
 1092|  3.12k|    switch (TYPEOF(s)) {
 1093|      0|    case NILSXP:
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1093:5): [True: 0, False: 3.12k]
  ------------------
 1094|      0|	*stretch = 0;
 1095|      0|	ans = allocVector(INTSXP, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	ans = allocVector(INTSXP, 0);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
 1096|      0|	break;
 1097|  2.09k|    case LGLSXP:
  ------------------
  |  |  121|  2.09k|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1097:5): [True: 2.09k, False: 1.02k]
  ------------------
 1098|  2.09k|	ans = logicalSubscript(s, ns, nx, stretch, call, 0);
 1099|  2.09k|	break;
 1100|    303|    case INTSXP:
  ------------------
  |  |  123|    303|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1100:5): [True: 303, False: 2.81k]
  ------------------
 1101|    303|	ans = integerSubscript(s, ns, nx, stretch, call, x, -1);
 1102|    303|	break;
 1103|    123|    case REALSXP:
  ------------------
  |  |  124|    123|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1103:5): [True: 123, False: 2.99k]
  ------------------
 1104|    123|	ans = realSubscript(s, ns, nx, stretch, call, x);
 1105|    123|	break;
 1106|    596|    case STRSXP:
  ------------------
  |  |  126|    596|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1106:5): [True: 596, False: 2.52k]
  ------------------
 1107|    596|    {
 1108|    596|	SEXP names = PROTECT(getAttrib(x, R_NamesSymbol));
  ------------------
  |  |  357|    596|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1109|    596|	ans = stringSubscript(s, ns, nx, names, stretch, call, x, -1);
 1110|    596|	UNPROTECT(1); /* names */
  ------------------
  |  |  358|    596|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1111|    596|	break;
 1112|      0|    }
 1113|      0|    case SYMSXP:
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1113:5): [True: 0, False: 3.12k]
  ------------------
 1114|      0|	*stretch = 0;
 1115|      0|	if (s == R_MissingArg) {
  ------------------
  |  Branch (1115:6): [True: 0, False: 0]
  ------------------
 1116|      0|	    ans = nullSubscript(nx);
 1117|      0|	    break;
 1118|      0|	}
 1119|      0|    default:
  ------------------
  |  Branch (1119:5): [True: 0, False: 3.12k]
  ------------------
 1120|      0|	ECALL3(call, _("invalid subscript type '%s'"), R_typeToChar(s));
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1121|  3.12k|    }
 1122|  3.12k|    return ans;
 1123|  3.12k|}
subscript.c:integerOneIndex:
   91|  2.18k|{
   92|  2.18k|    int indx = -1;
   93|       |
   94|  2.18k|    if (i > 0) /* a regular 1-based index from R */
  ------------------
  |  Branch (94:9): [True: 2.18k, False: 0]
  ------------------
   95|  2.18k|	indx = i - 1;
   96|      0|    else if (i == 0 || len < 2) {
  ------------------
  |  Branch (96:14): [True: 0, False: 0]
  |  Branch (96:24): [True: 0, False: 0]
  ------------------
   97|      0|	ECALL3(call, _("attempt to select less than one element in %s"), "integerOneIndex");
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   98|      0|    } else if (len == 2 && i > -3)
  ------------------
  |  Branch (98:16): [True: 0, False: 0]
  |  Branch (98:28): [True: 0, False: 0]
  ------------------
   99|      0|	indx = 2 + i;
  100|      0|    else {
  101|      0|	ECALL3(call, _("attempt to select more than one element in %s"), "integerOneIndex");
  ------------------
  |  |   47|      0|#define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL3(call, yy, A) if(call == R_NilValue) error(yy, A); else errorcall(call, yy, A);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (47:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  102|      0|    }
  103|  2.18k|    return indx;
  104|  2.18k|}
subscript.c:logicalSubscript:
  589|  2.28k|{
  590|  2.28k|    bool canstretch = *stretch > 0;
  591|  2.28k|    if (!canstretch && ns > nx) {
  ------------------
  |  Branch (591:9): [True: 181, False: 2.09k]
  |  Branch (591:24): [True: 0, False: 181]
  ------------------
  592|      0|	ECALL(call, _("(subscript) logical subscript too long"));
  ------------------
  |  |   46|      0|#define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (46:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  593|      0|    }
  594|  2.28k|    *stretch = (ns > nx) ? ns : 0;
  ------------------
  |  Branch (594:16): [True: 0, False: 2.28k]
  ------------------
  595|  2.28k|    if (ns == 0) return(allocVector(INTSXP, 0));
  ------------------
  |  |  875|     46|#define allocVector		Rf_allocVector
  ------------------
                  if (ns == 0) return(allocVector(INTSXP, 0));
  ------------------
  |  |  123|     46|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (595:9): [True: 46, False: 2.23k]
  ------------------
  596|  2.23k|    R_xlen_t count, i, i1, i2,
  597|  2.23k|	nmax = (ns > nx) ? ns : nx;
  ------------------
  |  Branch (597:9): [True: 0, False: 2.23k]
  ------------------
  598|       |
  599|  2.23k|    if (nmax % ns != 0) { // fractional recycling of the logical subscript
  ------------------
  |  Branch (599:9): [True: 0, False: 2.23k]
  ------------------
  600|      0|	if (dimno == 0)
  ------------------
  |  Branch (600:6): [True: 0, False: 0]
  ------------------
  601|      0|	    warningcall(call,
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
  602|      0|			_("object length is not a multiple of subscript length"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  603|      0|	else
  604|      0|	    warningcall(call,
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
  605|      0|			_("length of dimension %d is not a multiple of logical subscript length"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  606|      0|			dimno);
  607|      0|    }
  608|       |
  609|  2.23k|    SEXP indx; // result
  610|       |
  611|  2.23k|    const int *ps = LOGICAL_RO(s);    /* Calling LOCICAL_RO here may force a
  612|       |					 large allocation, but no larger than
  613|       |					 the one made by R_alloc below. This
  614|       |					 could use rewriting to better handle
  615|       |					 a sparse logical index. */
  616|  2.23k|#ifdef LONG_VECTOR_SUPPORT
  617|  2.23k|    if (nmax > R_SHORT_LEN_MAX) {
  ------------------
  |  |   77|  2.23k|# define R_SHORT_LEN_MAX 2147483647
  ------------------
  |  Branch (617:9): [True: 0, False: 2.23k]
  ------------------
  618|      0|	if (ns == nmax) { /* no recycling - use fast single-index code */
  ------------------
  |  Branch (618:6): [True: 0, False: 0]
  ------------------
  619|      0|	    const void *vmax = vmaxget();
  620|      0|	    double *buf = (double *) R_alloc(nmax, sizeof(double));
  621|      0|	    count = 0;
  622|      0|	    R_ITERATE_CHECK(NINTERRUPT, nmax, i,
  ------------------
  |  |   53|      0|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|      0|	i = 0;								\
  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|      0|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|      0|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|      0|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (45:23): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (45:23): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|      0|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|      0|	}								\
  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  623|      0|		if (ps[i]) {
  624|      0|		    if (ps[i] == NA_LOGICAL)
  625|      0|			buf[count++] = NA_REAL;
  626|      0|		    else
  627|      0|			buf[count++] = (double)(i + 1);
  628|      0|		});
  629|      0|	    PROTECT(indx = allocVector(REALSXP, count));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  630|      0|	    if (count)
  ------------------
  |  Branch (630:10): [True: 0, False: 0]
  ------------------
  631|      0|		memcpy(REAL(indx), buf, sizeof(double) * count);
  632|      0|	    vmaxset(vmax);
  633|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  634|      0|	    return indx;
  635|      0|	}
  636|      0|	count = 0;
  637|       |	/* we only need to scan s once even if we recycle,
  638|       |	   just remember the total count as well as
  639|       |	   the count for the last incomplete chunk (if any) */
  640|      0|	i1 = (ns < nmax) ? (nmax % ns) : 0;
  ------------------
  |  Branch (640:7): [True: 0, False: 0]
  ------------------
  641|      0|	if (i1 > 0) { /* last recycling chunk is incomplete -
  ------------------
  |  Branch (641:6): [True: 0, False: 0]
  ------------------
  642|       |			 we have to get the truncated count as well */
  643|      0|	    R_xlen_t rem = 0;
  644|      0|	    for (i = 0; i < ns; i++) {
  ------------------
  |  Branch (644:18): [True: 0, False: 0]
  ------------------
  645|      0|		if (i == i1) rem = count;
  ------------------
  |  Branch (645:7): [True: 0, False: 0]
  ------------------
  646|      0|		if (ps[i]) count++;
  ------------------
  |  Branch (646:7): [True: 0, False: 0]
  ------------------
  647|      0|	    }
  648|      0|	    count = count * (nmax / ns) + rem;
  649|      0|	} else { /* nested recycling, total is sufficient */
  650|      0|	    for (i = 0; i < ns; i++)
  ------------------
  |  Branch (650:18): [True: 0, False: 0]
  ------------------
  651|      0|		if (ps[i]) count++;
  ------------------
  |  Branch (651:7): [True: 0, False: 0]
  ------------------
  652|      0|	    count *= nmax / ns;
  653|      0|	}
  654|      0|	PROTECT(indx = allocVector(REALSXP, count));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  655|      0|	double *pindx = REAL(indx);
  656|      0|	count = 0;
  657|      0|	MOD_ITERATE_CHECK(NINTERRUPT, nmax, ns, nmax, i, i1, i2,
  ------------------
  |  |  100|      0|#define MOD_ITERATE_CHECK MOD_ITERATE2_CHECK
  |  |  ------------------
  |  |  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |  |  |   41|      0|	}								\
  |  |  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |   96|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  658|      0|	    if (ps[i1]) {
  659|      0|		if (ps[i1] == NA_LOGICAL)
  660|      0|		    pindx[count++] = NA_REAL;
  661|      0|		else
  662|      0|		    pindx[count++] = (double)(i + 1);
  663|      0|	    });
  664|       |
  665|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  666|      0|	return indx;
  667|      0|    }
  668|  2.23k|#endif
  669|       |// else --- the same code for  non-long vectors --------------------------
  670|  2.23k|    if (ns == nmax) {  /* no recycling - use fast single-index code */
  ------------------
  |  Branch (670:9): [True: 2.23k, False: 0]
  ------------------
  671|  2.23k|	const void *vmax = vmaxget();
  672|  2.23k|	int *buf = (int *) R_alloc(nmax, sizeof(int));
  673|  2.23k|	count = 0;
  674|  2.23k|	R_ITERATE_CHECK(NINTERRUPT, nmax, i,
  ------------------
  |  |   53|  2.23k|#define R_ITERATE_CHECK(ncheck, n, i, loop_body) do {			\
  |  |   54|  2.23k|	i = 0;								\
  |  |   55|  2.23k|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  ------------------
  |  |  |  |   32|  2.23k|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |   33|  2.23k|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |   34|  2.23k|	     TRUE;							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (34:7): [True: 2.23k, Folded]
  |  |  |  |  ------------------
  |  |  |  |   35|  2.23k|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |   36|  2.23k|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (36:28): [True: 2.23k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   37|  2.23k|		n : __intr_threshold__;					\
  |  |  |  |   38|  2.23k|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  ------------------
  |  |  |  |  |  |   55|  2.23k|	LOOP_WITH_INTERRUPT_CHECK(R_ITERATE_CORE, ncheck, n, i, loop_body); \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   44|  2.23k|#define R_ITERATE_CORE(n, i, loop_body) do {	\
  |  |  |  |  |  |  |  |   45|  2.15M|	for (; i < n; ++i) { loop_body }	\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (45:9): [True: 646k, False: 2.23k]
  |  |  |  |  |  |  |  |  |  Branch (45:23): [True: 0, False: 502k]
  |  |  |  |  |  |  |  |  |  Branch (45:23): [True: 502k, False: 144k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   46|  2.23k|    } while (0)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (46:14): [Folded, False: 2.23k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   39|  2.23k|	    if (__intr_end__ == n) break;				\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (39:10): [True: 2.23k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   40|  2.23k|	    else R_CheckUserInterrupt();				\
  |  |  |  |   41|  2.23k|	}								\
  |  |  |  |   42|  2.23k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (42:14): [Folded, False: 2.23k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   56|  2.23k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (56:14): [Folded, False: 2.23k]
  |  |  ------------------
  ------------------
  675|  2.23k|	    if (ps[i]) {
  676|  2.23k|		if (ps[i] == NA_LOGICAL)
  677|  2.23k|		    buf[count++] = NA_INTEGER;
  678|  2.23k|		else
  679|  2.23k|		    buf[count++] = (int)(i + 1);
  680|  2.23k|	    });
  681|  2.23k|	PROTECT(indx = allocVector(INTSXP, count));
  ------------------
  |  |  357|  2.23k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  682|  2.23k|	if (count)
  ------------------
  |  Branch (682:6): [True: 1.70k, False: 530]
  ------------------
  683|  1.70k|	    memcpy(INTEGER(indx), buf, sizeof(int) * count);
  684|  2.23k|	vmaxset(vmax);
  685|  2.23k|	UNPROTECT(1);
  ------------------
  |  |  358|  2.23k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  686|  2.23k|	return indx;
  687|  2.23k|    }
  688|       |
  689|      0|    count = 0;
  690|       |    /* we only need to scan s once even if we recycle,
  691|       |       just remember the total count as well as
  692|       |       the count for the last incomplete chunk (if any) */
  693|      0|    i1 = (ns < nmax) ? (nmax % ns) : 0;
  ------------------
  |  Branch (693:10): [True: 0, False: 0]
  ------------------
  694|      0|    if (i1 > 0) { /* last recycling chunk is incomplete -
  ------------------
  |  Branch (694:9): [True: 0, False: 0]
  ------------------
  695|       |		     we have to get the truncated count as well */
  696|      0|	R_xlen_t rem = 0;
  697|      0|	for (i = 0; i < ns; i++) {
  ------------------
  |  Branch (697:14): [True: 0, False: 0]
  ------------------
  698|      0|	    if (i == i1) rem = count;
  ------------------
  |  Branch (698:10): [True: 0, False: 0]
  ------------------
  699|      0|	    if (ps[i]) count++;
  ------------------
  |  Branch (699:10): [True: 0, False: 0]
  ------------------
  700|      0|	}
  701|      0|	count = count * (nmax / ns) + rem;
  702|      0|    } else { /* nested recycling, total is sufficient */
  703|      0|	for (i = 0; i < ns; i++)
  ------------------
  |  Branch (703:14): [True: 0, False: 0]
  ------------------
  704|      0|	    if (ps[i]) count++;
  ------------------
  |  Branch (704:10): [True: 0, False: 0]
  ------------------
  705|      0|	count *= nmax / ns;
  706|      0|    }
  707|      0|    PROTECT(indx = allocVector(INTSXP, count));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  708|      0|    int *pindx = INTEGER(indx);
  709|      0|    count = 0;
  710|      0|    MOD_ITERATE_CHECK(NINTERRUPT, nmax, ns, nmax, i, i1, i2,
  ------------------
  |  |  100|      0|#define MOD_ITERATE_CHECK MOD_ITERATE2_CHECK
  |  |  ------------------
  |  |  |  |   92|      0|#define MOD_ITERATE2_CHECK(ncheck, n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |   93|      0|	i = i1 = i2 = 0;						\
  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  ------------------
  |  |  |  |  |  |   32|      0|#define LOOP_WITH_INTERRUPT_CHECK(LOOP, ncheck, n, ...) do {		\
  |  |  |  |  |  |   33|      0|	for (size_t __intr_threshold__ = ncheck;			\
  |  |  |  |  |  |   34|      0|	     TRUE;							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (34:7): [True: 0, Folded]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   35|      0|	     __intr_threshold__ += ncheck) {				\
  |  |  |  |  |  |   36|      0|	    size_t __intr_end__ = n < __intr_threshold__ ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (36:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   37|      0|		n : __intr_threshold__;					\
  |  |  |  |  |  |   38|      0|	    LOOP(__intr_end__, __VA_ARGS__);				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   94|      0|	LOOP_WITH_INTERRUPT_CHECK(MOD_ITERATE2_CORE, ncheck, n,		\
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   78|      0|#define MOD_ITERATE2_CORE(n, n1, n2, i, i1, i2, loop_body) do {	\
  |  |  |  |  |  |  |  |  |  |   79|      0|	for (; i < n;							\
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (79:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   80|      0|	     i1 = (++i1 == n1) ? 0 : i1,				\
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (80:12): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   81|      0|		 i2 = (++i2 == n2) ? 0 : i2,				\
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (81:9): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   82|      0|		 ++i) {							\
  |  |  |  |  |  |  |  |  |  |   83|      0|	    loop_body							\
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  |  Branch (83:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   84|      0|		}							\
  |  |  |  |  |  |  |  |  |  |   85|      0|    } while (0)
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (85:14): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   39|      0|	    if (__intr_end__ == n) break;				\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (39:10): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   40|      0|	    else R_CheckUserInterrupt();				\
  |  |  |  |  |  |   41|      0|	}								\
  |  |  |  |  |  |   42|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (42:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   95|      0|				  n1, n2, i, i1, i2, loop_body);	\
  |  |  |  |   96|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (96:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  711|      0|	if (ps[i1]) {
  712|      0|	    if (ps[i1] == NA_LOGICAL)
  713|      0|		pindx[count++] = NA_INTEGER;
  714|      0|	    else
  715|      0|		pindx[count++] = (int)(i + 1);
  716|      0|	});
  717|       |
  718|      0|    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  719|      0|    return indx;
  720|  2.23k|}
subscript.c:integerSubscript:
  760|  4.98k|{
  761|  4.98k|    bool isna = false, neg = false,
  762|  4.98k|	canstretch = *stretch > 0;
  763|  4.98k|    *stretch = 0;
  764|  4.98k|    int max = 0;
  765|  4.98k|    const int *ps = INTEGER_RO(s);
  766|  10.8k|    for (R_xlen_t i = 0; i < ns; i++) {
  ------------------
  |  Branch (766:26): [True: 5.90k, False: 4.98k]
  ------------------
  767|  5.90k|	int ii = ps[i];
  768|  5.90k|	if (ii < 0) {
  ------------------
  |  Branch (768:6): [True: 32, False: 5.87k]
  ------------------
  769|     32|	    if (ii == NA_INTEGER)
  ------------------
  |  |   56|     32|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (769:10): [True: 0, False: 32]
  ------------------
  770|      0|		isna = true;
  771|     32|	    else
  772|     32|		neg = true;
  773|     32|	}
  774|  5.87k|	else if (ii > max)
  ------------------
  |  Branch (774:11): [True: 5.85k, False: 18]
  ------------------
  775|  5.85k|	    max = ii;
  776|  5.90k|    }
  777|  4.98k|    if (max > nx) {
  ------------------
  |  Branch (777:9): [True: 0, False: 4.98k]
  ------------------
  778|      0|	if(canstretch) *stretch = max;
  ------------------
  |  Branch (778:5): [True: 0, False: 0]
  ------------------
  779|      0|	else {
  780|      0|	    ECALL_OutOfBounds(x, dim, max, call);
  781|      0|	}
  782|      0|    }
  783|  4.98k|    if (neg) {
  ------------------
  |  Branch (783:9): [True: 18, False: 4.96k]
  ------------------
  784|     18|	if (max == 0 && !isna) return negativeSubscript(s, ns, nx, call);
  ------------------
  |  Branch (784:6): [True: 18, False: 0]
  |  Branch (784:18): [True: 18, False: 0]
  ------------------
  785|      0|	else {
  786|      0|	    ECALL(call, _("only 0's may be mixed with negative subscripts"));
  ------------------
  |  |   46|      0|#define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (46:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  787|      0|	}
  788|     18|    }
  789|  4.96k|    else return positiveSubscript(s, ns, nx);
  790|      0|    return R_NilValue;
  791|  4.98k|}
subscript.c:negativeSubscript:
  723|     18|{
  724|     18|    SEXP indx = PROTECT(allocVector(LGLSXP, nx));
  ------------------
  |  |  357|     18|#define PROTECT(s)	Rf_protect(s)
  ------------------
  725|     18|    int *pindx = LOGICAL(indx);
  726|     18|    R_xlen_t i;
  727|    130|    for (i = 0; i < nx; i++)
  ------------------
  |  Branch (727:17): [True: 112, False: 18]
  ------------------
  728|    112|	pindx[i] = 1;
  729|     18|    const int *ps = INTEGER_RO(s);
  730|     64|    for (i = 0; i < ns; i++) {
  ------------------
  |  Branch (730:17): [True: 46, False: 18]
  ------------------
  731|     46|	int ix = ps[i];
  732|     46|	if (ix != 0 && ix != NA_INTEGER && -ix <= nx)
  ------------------
  |  |   56|     78|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (732:6): [True: 32, False: 14]
  |  Branch (732:17): [True: 32, False: 0]
  |  Branch (732:37): [True: 32, False: 0]
  ------------------
  733|     32|	    pindx[-ix - 1] = 0;
  734|     46|    }
  735|     18|    R_xlen_t stretch = 0;
  736|     18|    s = logicalSubscript(indx, nx, nx, &stretch, call, 0);
  737|     18|    UNPROTECT(1);
  ------------------
  |  |  358|     18|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  738|     18|    return s;
  739|     18|}
subscript.c:positiveSubscript:
  742|  4.96k|{
  743|  4.96k|    R_xlen_t i, zct = 0;
  744|  4.96k|    const int *ps = INTEGER_RO(s);
  745|  10.8k|    for (i = 0; i < ns; i++) if (ps[i] == 0) zct++;
  ------------------
  |  Branch (745:17): [True: 5.86k, False: 4.96k]
  |  Branch (745:34): [True: 4, False: 5.85k]
  ------------------
  746|  4.96k|    if (zct) {
  ------------------
  |  Branch (746:9): [True: 4, False: 4.96k]
  ------------------
  747|      4|	SEXP indx = allocVector(INTSXP, (ns - zct));
  ------------------
  |  |  875|      4|#define allocVector		Rf_allocVector
  ------------------
              	SEXP indx = allocVector(INTSXP, (ns - zct));
  ------------------
  |  |  123|      4|#define INTSXP	    13	  /* integer vectors */
  ------------------
  748|      4|	int *pindx = INTEGER(indx);
  749|      8|	for (i = 0, zct = 0; i < ns; i++)
  ------------------
  |  Branch (749:23): [True: 4, False: 4]
  ------------------
  750|      4|	    if (ps[i] != 0)
  ------------------
  |  Branch (750:10): [True: 0, False: 4]
  ------------------
  751|      0|		pindx[zct++] = ps[i];
  752|      4|	return indx;
  753|       |
  754|  4.96k|    } else return s;
  755|  4.96k|}
subscript.c:stringSubscript:
  905|    596|{
  906|       |    /* product may overflow, so check factors as well. */
  907|    596|    bool usehashing = ( ((ns > 1000 && nx) || (nx > 1000 && ns)) || (ns * nx > 15*nx + ns) );
  ------------------
  |  Branch (907:27): [True: 0, False: 596]
  |  Branch (907:40): [True: 0, False: 0]
  |  Branch (907:48): [True: 0, False: 596]
  |  Branch (907:61): [True: 0, False: 0]
  |  Branch (907:69): [True: 0, False: 596]
  ------------------
  908|    596|    int nprotect = 0;
  909|    596|    PROTECT(s);
  ------------------
  |  |  357|    596|#define PROTECT(s)	Rf_protect(s)
  ------------------
  910|    596|    PROTECT(names);
  ------------------
  |  |  357|    596|#define PROTECT(s)	Rf_protect(s)
  ------------------
  911|    596|    nprotect += 2;
  912|       |
  913|    596|    SEXP indx, indexnames = R_NilValue;
  914|    596|    bool canstretch = *stretch > 0;
  915|    596|    *stretch = 0;
  916|    596|    R_xlen_t i, sub,
  917|    596|	nnames = nx,
  918|    596|	extra = nnames;
  919|       |
  920|       |    /* Process each of the subscripts. First we compare with the names
  921|       |     * on the vector and then (if there is no match) with each of the
  922|       |     * previous subscripts, since (if assigning) we may have already
  923|       |     * added an element of that name. (If we are not assigning, any
  924|       |     * nonmatch will have given an error.)
  925|       |     */
  926|       |
  927|    596|    if(usehashing) {
  ------------------
  |  Branch (927:8): [True: 0, False: 596]
  ------------------
  928|       |	/* must be internal, so names contains a character vector */
  929|       |	/* NB: this does not behave in the same way with respect to ""
  930|       |	   and NA names: they will match */
  931|      0|	PROTECT(indx = match(names, s, 0)); /**** guaranteed to be fresh???*/
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  932|      0|	nprotect++;
  933|       |	/* second pass to correct this */
  934|      0|	int *pindx = INTEGER(indx);
  935|      0|	for (i = 0; i < ns; i++)
  ------------------
  |  Branch (935:14): [True: 0, False: 0]
  ------------------
  936|      0|	    if(STRING_ELT(s, i) == NA_STRING || !CHAR(STRING_ELT(s, i))[0])
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
              	    if(STRING_ELT(s, i) == NA_STRING || !CHAR(STRING_ELT(s, i))[0])
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (936:9): [True: 0, False: 0]
  |  Branch (936:42): [True: 0, False: 0]
  ------------------
  937|      0|		pindx[i] = 0;
  938|    596|    } else {
  939|    596|	PROTECT(indx = allocVector(INTSXP, ns));
  ------------------
  |  |  357|    596|#define PROTECT(s)	Rf_protect(s)
  ------------------
  940|    596|	nprotect++;
  941|    596|	int *pindx = INTEGER(indx);
  942|  1.23k|	for (i = 0; i < ns; i++) {
  ------------------
  |  Branch (942:14): [True: 636, False: 596]
  ------------------
  943|    636|	    sub = 0;
  944|    636|	    if (names != R_NilValue) {
  ------------------
  |  Branch (944:10): [True: 636, False: 0]
  ------------------
  945|  13.1k|		for (R_xlen_t j = 0; j < nnames; j++) {
  ------------------
  |  Branch (945:24): [True: 13.0k, False: 130]
  ------------------
  946|  13.0k|		    SEXP names_j = STRING_ELT(names, j);
  947|  13.0k|		    if (NonNullStringMatch(STRING_ELT(s, i), names_j)) {
  ------------------
  |  | 1007|  13.0k|#define NonNullStringMatch	Rf_NonNullStringMatch
  ------------------
  |  Branch (947:11): [True: 506, False: 12.5k]
  ------------------
  948|    506|			sub = j + 1;
  949|    506|			break;
  950|    506|		    }
  951|  13.0k|		}
  952|    636|	    }
  953|    636|	    pindx[i] = (int) sub;
  954|    636|	}
  955|    596|    }
  956|       |
  957|    596|    int *pindx = INTEGER(indx);
  958|    596|    SEXP sindx = NULL;
  959|  1.23k|    for (i = 0; i < ns; i++) {
  ------------------
  |  Branch (959:17): [True: 636, False: 596]
  ------------------
  960|    636|	sub = pindx[i];
  961|    636|	if (sub == 0) {
  ------------------
  |  Branch (961:6): [True: 130, False: 506]
  ------------------
  962|    130|	    if (sindx == NULL) {
  ------------------
  |  Branch (962:10): [True: 130, False: 0]
  ------------------
  963|    130|		sindx = PROTECT(match(s, s, 0));
  ------------------
  |  |  357|    130|#define PROTECT(s)	Rf_protect(s)
  ------------------
  964|    130|		indexnames = PROTECT(allocVector(VECSXP, ns));
  ------------------
  |  |  357|    130|#define PROTECT(s)	Rf_protect(s)
  ------------------
  965|    130|		nprotect += 2;
  966|    260|		for (int z = 0; z < ns; z++)
  ------------------
  |  Branch (966:19): [True: 130, False: 130]
  ------------------
  967|    130|		    SET_VECTOR_ELT(indexnames, z, R_NilValue);
  968|    130|	    }
  969|    130|	    int j = INTEGER(sindx)[i] - 1;
  970|    130|	    if(STRING_ELT(s, i) != NA_STRING && CHAR(STRING_ELT(s, i))[0]) {
  ------------------
  |  |  433|    260|#define NA_STRING	R_NaString
  ------------------
              	    if(STRING_ELT(s, i) != NA_STRING && CHAR(STRING_ELT(s, i))[0]) {
  ------------------
  |  |  203|    130|#define CHAR(x) R_CHAR(x)
  ------------------
  |  Branch (970:9): [True: 130, False: 0]
  |  Branch (970:42): [True: 130, False: 0]
  ------------------
  971|    130|		sub = pindx[j];
  972|    130|		SET_VECTOR_ELT(indexnames, i, STRING_ELT(s, j));
  973|    130|	    }
  974|    130|	}
  975|    636|	if (sub == 0) {
  ------------------
  |  Branch (975:6): [True: 130, False: 506]
  ------------------
  976|    130|	    if (!canstretch) {
  ------------------
  |  Branch (976:10): [True: 0, False: 130]
  ------------------
  977|      0|		ECALL_OutOfBoundsCHAR(x, dim, STRING_ELT(s, i), call);
  978|      0|	    }
  979|    130|	    extra += 1;
  980|    130|	    sub = extra;
  981|    130|	    SET_VECTOR_ELT(indexnames, i, STRING_ELT(s, i));
  982|    130|	}
  983|    636|	pindx[i] = (int) sub;
  984|    636|    }
  985|       |    /* We return the new names as the names attribute of the returned
  986|       |       subscript vector. */
  987|    596|    if (extra != nnames) {
  ------------------
  |  Branch (987:9): [True: 130, False: 466]
  ------------------
  988|    130|	setAttrib(indx, R_UseNamesSymbol, indexnames);
  ------------------
  |  | 1027|    130|#define setAttrib		Rf_setAttrib
  ------------------
  989|    130|	if (canstretch)
  ------------------
  |  Branch (989:6): [True: 130, False: 0]
  ------------------
  990|    130|	    *stretch = extra;
  991|    130|    }
  992|    596|    UNPROTECT(nprotect);
  ------------------
  |  |  358|    596|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  993|    596|    return indx;
  994|    596|}
subscript.c:nullSubscript:
  566|    116|{
  567|    116|    SEXP indx;
  568|    116|#ifdef LONG_VECTOR_SUPPORT
  569|    116|    if (n > R_SHORT_LEN_MAX) {
  ------------------
  |  |   77|    116|# define R_SHORT_LEN_MAX 2147483647
  ------------------
  |  Branch (569:9): [True: 0, False: 116]
  ------------------
  570|      0|	indx = allocVector(REALSXP, n);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	indx = allocVector(REALSXP, n);
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  571|      0|	double *pindx = REAL(indx);
  572|      0|	for (R_xlen_t i = 0; i < n; i++)
  ------------------
  |  Branch (572:23): [True: 0, False: 0]
  ------------------
  573|      0|	    pindx[i] = (double)(i + 1);
  574|      0|    } else
  575|    116|#endif
  576|    116|    {
  577|    116|	indx = allocVector(INTSXP, n);
  ------------------
  |  |  875|    116|#define allocVector		Rf_allocVector
  ------------------
              	indx = allocVector(INTSXP, n);
  ------------------
  |  |  123|    116|#define INTSXP	    13	  /* integer vectors */
  ------------------
  578|    116|	int *pindx = INTEGER(indx);
  579|  14.0k|	for (int i = 0; i < n; i++)
  ------------------
  |  Branch (579:18): [True: 13.9k, False: 116]
  ------------------
  580|  13.9k|	    pindx[i] = i + 1;
  581|    116|    }
  582|    116|    return indx;
  583|    116|}
subscript.c:realSubscript:
  796|    123|{
  797|    123|    bool canstretch = *stretch > 0;
  798|    123|    *stretch = 0;
  799|    123|    double min = 0, max = 0;
  800|    123|    const double *ps = REAL_RO(s);
  801|    123|    bool isna = false;
  802|    248|    for (R_xlen_t i = 0; i < ns; i++) {
  ------------------
  |  Branch (802:26): [True: 125, False: 123]
  ------------------
  803|    125|	double ii = ps[i];
  804|    125|	if (R_FINITE(ii)) {
  ------------------
  |  |   82|    125|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (804:6): [True: 125, False: 0]
  ------------------
  805|    125|	    if (ii < min) min = ii;
  ------------------
  |  Branch (805:10): [True: 125, False: 0]
  ------------------
  806|    125|	    if (ii > max) max = ii;
  ------------------
  |  Branch (806:10): [True: 0, False: 125]
  ------------------
  807|    125|	} else isna = true;
  808|    125|    }
  809|    123|    if (max >= (double)nx+1.) {
  ------------------
  |  Branch (809:9): [True: 0, False: 123]
  ------------------
  810|      0|#ifdef LONG_VECTOR_SUPPORT
  811|       |	/* Avoid an out-of-range conversion to R_xlen_t. */
  812|      0|	if (max > R_XLEN_T_MAX) {
  ------------------
  |  |   76|      0|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (812:6): [True: 0, False: 0]
  ------------------
  813|      0|	    ECALL(call, _("subscript too large"));
  ------------------
  |  |   46|      0|#define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (46:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  814|      0|	}
  815|       |#else
  816|       |	if (max > INT_MAX) {
  817|       |	    ECALL(call, _("subscript too large for 32-bit R"));
  818|       |	}
  819|       |#endif
  820|      0|	if(canstretch) *stretch = (R_xlen_t) max;
  ------------------
  |  Branch (820:5): [True: 0, False: 0]
  ------------------
  821|      0|	else {
  822|      0|	    ECALL_OutOfBounds(x, -1, (R_xlen_t) max, call);
  823|      0|	}
  824|      0|    }
  825|    123|    if (min <= -1) {
  ------------------
  |  Branch (825:9): [True: 123, False: 0]
  ------------------
  826|    123|	if (max < 1 && !isna) {
  ------------------
  |  Branch (826:6): [True: 123, False: 0]
  |  Branch (826:17): [True: 123, False: 0]
  ------------------
  827|    123|	    R_xlen_t i, stretch = 0;
  828|    123|	    SEXP indx = PROTECT(allocVector(LGLSXP, nx));
  ------------------
  |  |  357|    123|#define PROTECT(s)	Rf_protect(s)
  ------------------
  829|    123|	    int *pindx = LOGICAL(indx);
  830|    493|	    for (i = 0; i < nx; i++) pindx[i] = 1;
  ------------------
  |  Branch (830:18): [True: 370, False: 123]
  ------------------
  831|    248|	    for (i = 0; i < ns; i++) {
  ------------------
  |  Branch (831:18): [True: 125, False: 123]
  ------------------
  832|    125|		double dx = ps[i];
  833|    125|		if (R_FINITE(dx) && dx <= -1  && -dx < (double)nx+1.) {
  ------------------
  |  |   82|    125|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (833:7): [True: 125, False: 0]
  |  Branch (833:23): [True: 125, False: 0]
  |  Branch (833:36): [True: 125, False: 0]
  ------------------
  834|    125|		    R_xlen_t ix = (R_xlen_t)(-dx - 1);
  835|    125|		    pindx[ix] = 0;
  836|    125|		}
  837|    125|	    }
  838|    123|	    s = logicalSubscript(indx, nx, nx, &stretch, call, 0);
  839|    123|	    UNPROTECT(1);
  ------------------
  |  |  358|    123|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  840|    123|	    return s;
  841|    123|	} else {
  842|      0|	    ECALL(call, _("only 0's may be mixed with negative subscripts"));
  ------------------
  |  |   46|      0|#define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               #define ECALL(call, yy)     if(call == R_NilValue) error(yy);    else errorcall(call, yy);
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  |  |  Branch (46:32): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  843|      0|	}
  844|    123|    } else {
  845|       |	/* Only return a REALSXP index if we need to */
  846|      0|	SEXP indx;
  847|      0|	R_xlen_t i, cnt = 0;
  848|      0|	bool int_ok = true;
  849|       |	/* NB, indices will be truncated eventually,
  850|       |	   so need to do that to take '0' into account */
  851|      0|	for (i = 0; i < ns; i++) {
  ------------------
  |  Branch (851:14): [True: 0, False: 0]
  ------------------
  852|      0|	    double ds = ps[i];
  853|       |#ifdef OLDCODE_LONG_VECTOR
  854|       |	    if (!R_FINITE(ds)) {
  855|       |		if (ds > INT_MAX) int_ok = false;
  856|       |		cnt++;
  857|       |	    } else if ((R_xlen_t) ds != 0) cnt++;
  858|       |#else
  859|      0|	    if (R_FINITE(ds) && ds > INT_MAX) int_ok = false;
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (859:10): [True: 0, False: 0]
  |  Branch (859:26): [True: 0, False: 0]
  ------------------
  860|      0|	    if (!R_FINITE(ds) || (R_xlen_t) ds != 0) cnt++;
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (860:10): [True: 0, False: 0]
  |  Branch (860:27): [True: 0, False: 0]
  ------------------
  861|      0|#endif
  862|      0|	}
  863|      0|	if (int_ok) {
  ------------------
  |  Branch (863:6): [True: 0, False: 0]
  ------------------
  864|      0|	    indx = allocVector(INTSXP, cnt);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	    indx = allocVector(INTSXP, cnt);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  865|      0|	    int *pindx = INTEGER(indx);
  866|      0|	    for (i = 0, cnt = 0; i < ns; i++) {
  ------------------
  |  Branch (866:27): [True: 0, False: 0]
  ------------------
  867|      0|		double ds = ps[i];
  868|      0|		int ia;
  869|      0|		if (!R_FINITE(ds)) ia = NA_INTEGER;
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
              		if (!R_FINITE(ds)) ia = NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (869:7): [True: 0, False: 0]
  ------------------
  870|      0|		else ia = (int) ds;
  871|      0|		if (ia != 0) pindx[cnt++] = ia;
  ------------------
  |  Branch (871:7): [True: 0, False: 0]
  ------------------
  872|      0|	    }
  873|      0|	} else {
  874|      0|	    indx = allocVector(REALSXP, cnt);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	    indx = allocVector(REALSXP, cnt);
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  875|      0|	    double *pindx = REAL(indx);
  876|      0|	    for (i = 0, cnt = 0; i < ns; i++) {
  ------------------
  |  Branch (876:27): [True: 0, False: 0]
  ------------------
  877|      0|		double ds = ps[i];
  878|      0|		if (!R_FINITE(ds) || (R_xlen_t) ds != 0) pindx[cnt++] = ds;
  ------------------
  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (878:7): [True: 0, False: 0]
  |  Branch (878:24): [True: 0, False: 0]
  ------------------
  879|      0|	    }
  880|      0|	}
  881|      0|	return indx;
  882|      0|    }
  883|      0|    return R_NilValue;
  884|    123|}

Rf_ExtractSubset:
  116|   395k|{
  117|   395k|    if (x == R_NilValue)
  ------------------
  |  Branch (117:9): [True: 2.36k, False: 393k]
  ------------------
  118|  2.36k|	return x;
  119|       |
  120|   393k|    SEXP result;
  121|       |
  122|   393k|    if (ALTREP(x)) {
  ------------------
  |  Branch (122:9): [True: 24, False: 393k]
  ------------------
  123|     24|	result = ALTVEC_EXTRACT_SUBSET(x, indx, call);
  124|     24|	if (result != NULL)
  ------------------
  |  Branch (124:6): [True: 0, False: 24]
  ------------------
  125|      0|	    return result;
  126|     24|    }
  127|       |
  128|   393k|    R_xlen_t i, ii, n, nx;
  129|   393k|    n = XLENGTH(indx);
  130|   393k|    nx = xlength(x);
  ------------------
  |  | 1049|   393k|#define xlength(x)		Rf_xlength(x)
  ------------------
  131|   393k|    int mode = TYPEOF(x);
  132|       |
  133|       |    /* protect allocation in case _ELT operations need to allocate */
  134|   393k|    PROTECT(result = allocVector(mode, n));
  ------------------
  |  |  357|   393k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  135|   393k|    switch(mode) {
  136|     14|    case LGLSXP:
  ------------------
  |  |  121|     14|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (136:5): [True: 14, False: 393k]
  ------------------
  137|     14|	EXTRACT_SUBSET_LOOP(LOGICAL0(result)[i] = LOGICAL_ELT(x, ii),
  ------------------
  |  |   69|     14|#define EXTRACT_SUBSET_LOOP(STDCODE, NACODE) do { \
  |  |   70|     14|	if (TYPEOF(indx) == INTSXP) {		  \
  |  |  ------------------
  |  |  |  |  123|     14|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (70:6): [True: 14, False: 0]
  |  |  ------------------
  |  |   71|     14|	    const int *pindx = INTEGER_RO(indx);  \
  |  |   72|     36|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (72:18): [True: 22, False: 14]
  |  |  ------------------
  |  |   73|     22|		ii = pindx[i];			  \
  |  |   74|     22|		if (0 < ii && ii <= nx) {	  \
  |  |  ------------------
  |  |  |  Branch (74:7): [True: 22, False: 0]
  |  |  |  Branch (74:17): [True: 22, False: 0]
  |  |  ------------------
  |  |   75|     22|		    ii--;			  \
  |  |   76|     22|		    STDCODE;			  \
  |  |   77|     22|		}				  \
  |  |   78|     22|		else /* out of bounds or NA */	  \
  |  |   79|     22|		    NACODE;			  \
  |  |   80|     22|	    }					  \
  |  |   81|     14|	}					  \
  |  |   82|     14|	else {					  \
  |  |   83|      0|	    const double *pindx = REAL_RO(indx);  \
  |  |   84|      0|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (84:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   85|      0|		double di = pindx[i];		  \
  |  |   86|      0|		ii = (R_xlen_t) (di - 1);	  \
  |  |   87|      0|		if (R_FINITE(di) &&		  \
  |  |  ------------------
  |  |  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  |  |  ------------------
  |  |   88|      0|		    0 <= ii && ii < nx)		  \
  |  |  ------------------
  |  |  |  Branch (88:7): [True: 0, False: 0]
  |  |  |  Branch (88:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   89|      0|		    STDCODE;			  \
  |  |   90|      0|		else				  \
  |  |   91|      0|		    NACODE;			  \
  |  |   92|      0|	    }					  \
  |  |   93|      0|	}					  \
  |  |   94|     14|    } while (0)
  |  |  ------------------
  |  |  |  Branch (94:14): [Folded, False: 14]
  |  |  ------------------
  ------------------
  |  Branch (137:2): [True: 0, False: 0]
  ------------------
  138|     14|			    LOGICAL0(result)[i] = NA_INTEGER);
  139|     14|	break;
  140|     71|    case INTSXP:
  ------------------
  |  |  123|     71|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (140:5): [True: 71, False: 393k]
  ------------------
  141|     71|	EXTRACT_SUBSET_LOOP(INTEGER0(result)[i] = INTEGER_ELT(x, ii),
  ------------------
  |  |   69|     71|#define EXTRACT_SUBSET_LOOP(STDCODE, NACODE) do { \
  |  |   70|     71|	if (TYPEOF(indx) == INTSXP) {		  \
  |  |  ------------------
  |  |  |  |  123|     71|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (70:6): [True: 71, False: 0]
  |  |  ------------------
  |  |   71|     71|	    const int *pindx = INTEGER_RO(indx);  \
  |  |   72|    401|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (72:18): [True: 330, False: 71]
  |  |  ------------------
  |  |   73|    330|		ii = pindx[i];			  \
  |  |   74|    330|		if (0 < ii && ii <= nx) {	  \
  |  |  ------------------
  |  |  |  Branch (74:7): [True: 330, False: 0]
  |  |  |  Branch (74:17): [True: 330, False: 0]
  |  |  ------------------
  |  |   75|    330|		    ii--;			  \
  |  |   76|    330|		    STDCODE;			  \
  |  |   77|    330|		}				  \
  |  |   78|    330|		else /* out of bounds or NA */	  \
  |  |   79|    330|		    NACODE;			  \
  |  |   80|    330|	    }					  \
  |  |   81|     71|	}					  \
  |  |   82|     71|	else {					  \
  |  |   83|      0|	    const double *pindx = REAL_RO(indx);  \
  |  |   84|      0|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (84:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   85|      0|		double di = pindx[i];		  \
  |  |   86|      0|		ii = (R_xlen_t) (di - 1);	  \
  |  |   87|      0|		if (R_FINITE(di) &&		  \
  |  |  ------------------
  |  |  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  |  |  ------------------
  |  |   88|      0|		    0 <= ii && ii < nx)		  \
  |  |  ------------------
  |  |  |  Branch (88:7): [True: 0, False: 0]
  |  |  |  Branch (88:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   89|      0|		    STDCODE;			  \
  |  |   90|      0|		else				  \
  |  |   91|      0|		    NACODE;			  \
  |  |   92|      0|	    }					  \
  |  |   93|      0|	}					  \
  |  |   94|     71|    } while (0)
  |  |  ------------------
  |  |  |  Branch (94:14): [Folded, False: 71]
  |  |  ------------------
  ------------------
  |  Branch (141:2): [True: 0, False: 0]
  ------------------
  142|     71|			    INTEGER0(result)[i] = NA_INTEGER);
  143|     71|	break;
  144|  1.77k|    case REALSXP:
  ------------------
  |  |  124|  1.77k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (144:5): [True: 1.77k, False: 391k]
  ------------------
  145|  1.77k|	EXTRACT_SUBSET_LOOP(REAL0(result)[i] = REAL_ELT(x, ii),
  ------------------
  |  |   69|  1.77k|#define EXTRACT_SUBSET_LOOP(STDCODE, NACODE) do { \
  |  |   70|  1.77k|	if (TYPEOF(indx) == INTSXP) {		  \
  |  |  ------------------
  |  |  |  |  123|  1.77k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (70:6): [True: 1.77k, False: 0]
  |  |  ------------------
  |  |   71|  1.77k|	    const int *pindx = INTEGER_RO(indx);  \
  |  |   72|   483k|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (72:18): [True: 481k, False: 1.77k]
  |  |  ------------------
  |  |   73|   481k|		ii = pindx[i];			  \
  |  |   74|   481k|		if (0 < ii && ii <= nx) {	  \
  |  |  ------------------
  |  |  |  Branch (74:7): [True: 481k, False: 0]
  |  |  |  Branch (74:17): [True: 481k, False: 0]
  |  |  ------------------
  |  |   75|   481k|		    ii--;			  \
  |  |   76|   481k|		    STDCODE;			  \
  |  |   77|   481k|		}				  \
  |  |   78|   481k|		else /* out of bounds or NA */	  \
  |  |   79|   481k|		    NACODE;			  \
  |  |   80|   481k|	    }					  \
  |  |   81|  1.77k|	}					  \
  |  |   82|  1.77k|	else {					  \
  |  |   83|      0|	    const double *pindx = REAL_RO(indx);  \
  |  |   84|      0|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (84:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   85|      0|		double di = pindx[i];		  \
  |  |   86|      0|		ii = (R_xlen_t) (di - 1);	  \
  |  |   87|      0|		if (R_FINITE(di) &&		  \
  |  |  ------------------
  |  |  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  |  |  ------------------
  |  |   88|      0|		    0 <= ii && ii < nx)		  \
  |  |  ------------------
  |  |  |  Branch (88:7): [True: 0, False: 0]
  |  |  |  Branch (88:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   89|      0|		    STDCODE;			  \
  |  |   90|      0|		else				  \
  |  |   91|      0|		    NACODE;			  \
  |  |   92|      0|	    }					  \
  |  |   93|      0|	}					  \
  |  |   94|  1.77k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (94:14): [Folded, False: 1.77k]
  |  |  ------------------
  ------------------
  |  Branch (145:2): [True: 0, False: 0]
  ------------------
  146|  1.77k|			    REAL0(result)[i] = NA_REAL);
  147|  1.77k|	break;
  148|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (148:5): [True: 0, False: 393k]
  ------------------
  149|      0|	{
  150|      0|	    Rcomplex NA_CPLX = { .r = NA_REAL, .i = NA_REAL };
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
              	    Rcomplex NA_CPLX = { .r = NA_REAL, .i = NA_REAL };
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  151|      0|	    EXTRACT_SUBSET_LOOP(COMPLEX0(result)[i] = COMPLEX_ELT(x, ii),
  ------------------
  |  |   69|      0|#define EXTRACT_SUBSET_LOOP(STDCODE, NACODE) do { \
  |  |   70|      0|	if (TYPEOF(indx) == INTSXP) {		  \
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (70:6): [True: 0, False: 0]
  |  |  ------------------
  |  |   71|      0|	    const int *pindx = INTEGER_RO(indx);  \
  |  |   72|      0|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (72:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   73|      0|		ii = pindx[i];			  \
  |  |   74|      0|		if (0 < ii && ii <= nx) {	  \
  |  |  ------------------
  |  |  |  Branch (74:7): [True: 0, False: 0]
  |  |  |  Branch (74:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   75|      0|		    ii--;			  \
  |  |   76|      0|		    STDCODE;			  \
  |  |   77|      0|		}				  \
  |  |   78|      0|		else /* out of bounds or NA */	  \
  |  |   79|      0|		    NACODE;			  \
  |  |   80|      0|	    }					  \
  |  |   81|      0|	}					  \
  |  |   82|      0|	else {					  \
  |  |   83|      0|	    const double *pindx = REAL_RO(indx);  \
  |  |   84|      0|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (84:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   85|      0|		double di = pindx[i];		  \
  |  |   86|      0|		ii = (R_xlen_t) (di - 1);	  \
  |  |   87|      0|		if (R_FINITE(di) &&		  \
  |  |  ------------------
  |  |  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  |  |  ------------------
  |  |   88|      0|		    0 <= ii && ii < nx)		  \
  |  |  ------------------
  |  |  |  Branch (88:7): [True: 0, False: 0]
  |  |  |  Branch (88:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   89|      0|		    STDCODE;			  \
  |  |   90|      0|		else				  \
  |  |   91|      0|		    NACODE;			  \
  |  |   92|      0|	    }					  \
  |  |   93|      0|	}					  \
  |  |   94|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (94:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (151:6): [True: 0, False: 0]
  ------------------
  152|      0|				COMPLEX0(result)[i] = NA_CPLX);
  153|      0|	}
  154|      0|	break;
  155|   391k|    case STRSXP:
  ------------------
  |  |  126|   391k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (155:5): [True: 391k, False: 2.06k]
  ------------------
  156|   391k|	EXTRACT_SUBSET_LOOP(SET_STRING_ELT(result, i, STRING_ELT(x, ii)),
  ------------------
  |  |   69|   391k|#define EXTRACT_SUBSET_LOOP(STDCODE, NACODE) do { \
  |  |   70|   391k|	if (TYPEOF(indx) == INTSXP) {		  \
  |  |  ------------------
  |  |  |  |  123|   391k|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (70:6): [True: 391k, False: 4]
  |  |  ------------------
  |  |   71|   391k|	    const int *pindx = INTEGER_RO(indx);  \
  |  |   72|   799k|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (72:18): [True: 408k, False: 391k]
  |  |  ------------------
  |  |   73|   408k|		ii = pindx[i];			  \
  |  |   74|   408k|		if (0 < ii && ii <= nx) {	  \
  |  |  ------------------
  |  |  |  Branch (74:7): [True: 408k, False: 0]
  |  |  |  Branch (74:17): [True: 407k, False: 260]
  |  |  ------------------
  |  |   75|   407k|		    ii--;			  \
  |  |   76|   407k|		    STDCODE;			  \
  |  |   77|   407k|		}				  \
  |  |   78|   408k|		else /* out of bounds or NA */	  \
  |  |   79|   408k|		    NACODE;			  \
  |  |   80|   408k|	    }					  \
  |  |   81|   391k|	}					  \
  |  |   82|   391k|	else {					  \
  |  |   83|      4|	    const double *pindx = REAL_RO(indx);  \
  |  |   84|      8|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (84:18): [True: 4, False: 4]
  |  |  ------------------
  |  |   85|      4|		double di = pindx[i];		  \
  |  |   86|      4|		ii = (R_xlen_t) (di - 1);	  \
  |  |   87|      4|		if (R_FINITE(di) &&		  \
  |  |  ------------------
  |  |  |  |   82|      4|# define R_FINITE(x)    isfinite(x)
  |  |  ------------------
  |  |   88|      4|		    0 <= ii && ii < nx)		  \
  |  |  ------------------
  |  |  |  Branch (88:7): [True: 4, False: 0]
  |  |  |  Branch (88:18): [True: 4, False: 0]
  |  |  ------------------
  |  |   89|      4|		    STDCODE;			  \
  |  |   90|      4|		else				  \
  |  |   91|      4|		    NACODE;			  \
  |  |   92|      4|	    }					  \
  |  |   93|      4|	}					  \
  |  |   94|   391k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (94:14): [Folded, False: 391k]
  |  |  ------------------
  ------------------
  |  Branch (156:2): [True: 4, False: 0]
  ------------------
  157|   391k|			    SET_STRING_ELT(result, i, NA_STRING));
  158|   391k|	break;
  159|    190|    case VECSXP:
  ------------------
  |  |  131|    190|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (159:5): [True: 190, False: 392k]
  ------------------
  160|    202|    case EXPRSXP:
  ------------------
  |  |  132|    202|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (160:5): [True: 12, False: 393k]
  ------------------
  161|    202|	EXTRACT_SUBSET_LOOP(SET_VECTOR_ELT(result, i,
  ------------------
  |  |   69|    202|#define EXTRACT_SUBSET_LOOP(STDCODE, NACODE) do { \
  |  |   70|    202|	if (TYPEOF(indx) == INTSXP) {		  \
  |  |  ------------------
  |  |  |  |  123|    202|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (70:6): [True: 202, False: 0]
  |  |  ------------------
  |  |   71|    202|	    const int *pindx = INTEGER_RO(indx);  \
  |  |   72|  6.74k|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (72:18): [True: 6.54k, False: 202]
  |  |  ------------------
  |  |   73|  6.54k|		ii = pindx[i];			  \
  |  |   74|  6.54k|		if (0 < ii && ii <= nx) {	  \
  |  |  ------------------
  |  |  |  Branch (74:7): [True: 6.54k, False: 0]
  |  |  |  Branch (74:17): [True: 6.54k, False: 0]
  |  |  ------------------
  |  |   75|  6.54k|		    ii--;			  \
  |  |   76|  6.54k|		    STDCODE;			  \
  |  |   77|  6.54k|		}				  \
  |  |   78|  6.54k|		else /* out of bounds or NA */	  \
  |  |   79|  6.54k|		    NACODE;			  \
  |  |   80|  6.54k|	    }					  \
  |  |   81|    202|	}					  \
  |  |   82|    202|	else {					  \
  |  |   83|      0|	    const double *pindx = REAL_RO(indx);  \
  |  |   84|      0|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (84:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   85|      0|		double di = pindx[i];		  \
  |  |   86|      0|		ii = (R_xlen_t) (di - 1);	  \
  |  |   87|      0|		if (R_FINITE(di) &&		  \
  |  |  ------------------
  |  |  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  |  |  ------------------
  |  |   88|      0|		    0 <= ii && ii < nx)		  \
  |  |  ------------------
  |  |  |  Branch (88:7): [True: 0, False: 0]
  |  |  |  Branch (88:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   89|      0|		    STDCODE;			  \
  |  |   90|      0|		else				  \
  |  |   91|      0|		    NACODE;			  \
  |  |   92|      0|	    }					  \
  |  |   93|      0|	}					  \
  |  |   94|    202|    } while (0)
  |  |  ------------------
  |  |  |  Branch (94:14): [Folded, False: 202]
  |  |  ------------------
  ------------------
  |  Branch (161:2): [True: 0, False: 0]
  ------------------
  162|    202|					   VECTOR_ELT_FIX_NAMED(x, ii)),
  163|    202|			    SET_VECTOR_ELT(result, i, R_NilValue));
  164|    202|	break;
  165|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (165:5): [True: 0, False: 393k]
  ------------------
  166|      0|	EXTRACT_SUBSET_LOOP(RAW0(result)[i] = RAW_ELT(x, ii),
  ------------------
  |  |   69|      0|#define EXTRACT_SUBSET_LOOP(STDCODE, NACODE) do { \
  |  |   70|      0|	if (TYPEOF(indx) == INTSXP) {		  \
  |  |  ------------------
  |  |  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |  |  Branch (70:6): [True: 0, False: 0]
  |  |  ------------------
  |  |   71|      0|	    const int *pindx = INTEGER_RO(indx);  \
  |  |   72|      0|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (72:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   73|      0|		ii = pindx[i];			  \
  |  |   74|      0|		if (0 < ii && ii <= nx) {	  \
  |  |  ------------------
  |  |  |  Branch (74:7): [True: 0, False: 0]
  |  |  |  Branch (74:17): [True: 0, False: 0]
  |  |  ------------------
  |  |   75|      0|		    ii--;			  \
  |  |   76|      0|		    STDCODE;			  \
  |  |   77|      0|		}				  \
  |  |   78|      0|		else /* out of bounds or NA */	  \
  |  |   79|      0|		    NACODE;			  \
  |  |   80|      0|	    }					  \
  |  |   81|      0|	}					  \
  |  |   82|      0|	else {					  \
  |  |   83|      0|	    const double *pindx = REAL_RO(indx);  \
  |  |   84|      0|	    for (i = 0; i < n; i++) {		  \
  |  |  ------------------
  |  |  |  Branch (84:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   85|      0|		double di = pindx[i];		  \
  |  |   86|      0|		ii = (R_xlen_t) (di - 1);	  \
  |  |   87|      0|		if (R_FINITE(di) &&		  \
  |  |  ------------------
  |  |  |  |   82|      0|# define R_FINITE(x)    isfinite(x)
  |  |  ------------------
  |  |   88|      0|		    0 <= ii && ii < nx)		  \
  |  |  ------------------
  |  |  |  Branch (88:7): [True: 0, False: 0]
  |  |  |  Branch (88:18): [True: 0, False: 0]
  |  |  ------------------
  |  |   89|      0|		    STDCODE;			  \
  |  |   90|      0|		else				  \
  |  |   91|      0|		    NACODE;			  \
  |  |   92|      0|	    }					  \
  |  |   93|      0|	}					  \
  |  |   94|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (94:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (166:2): [True: 0, False: 0]
  ------------------
  167|      0|			    RAW0(result)[i] = (Rbyte) 0);
  168|      0|	break;
  169|      0|    case LISTSXP:
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (169:5): [True: 0, False: 393k]
  ------------------
  170|       |	/* cannot happen: pairlists are coerced to lists */
  171|      0|    case LANGSXP:
  ------------------
  |  |  117|      0|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (171:5): [True: 0, False: 393k]
  ------------------
  172|       |	/* cannot happen: LANGSXPs are coerced to lists */
  173|      0|    default:
  ------------------
  |  Branch (173:5): [True: 0, False: 393k]
  ------------------
  174|      0|	errorcallNotSubsettable(x, call);
  175|   393k|    }
  176|   393k|    UNPROTECT(1); /* result */
  ------------------
  |  |  358|   393k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  177|   393k|    return result;
  178|   393k|}
do_subset:
  681|    812|{
  682|    812|    SEXP ans;
  683|       |
  684|       |    /* If the first argument is an object and there is an */
  685|       |    /* appropriate method, we dispatch to that method, */
  686|       |    /* otherwise we evaluate the arguments and fall through */
  687|       |    /* to the generic code below.  Note that evaluation */
  688|       |    /* retains any missing argument indicators. */
  689|       |
  690|       |    /* DispatchOrEval internal generic: [ */
  691|    812|    if(R_DispatchOrEvalSP(call, op, "[", args, rho, &ans)) {
  ------------------
  |  Branch (691:8): [True: 0, False: 812]
  ------------------
  692|       |/*     if(DispatchAnyOrEval(call, op, "[", args, rho, &ans, 0, 0)) */
  693|      0|	if (NAMED(ans))
  ------------------
  |  Branch (693:6): [True: 0, False: 0]
  ------------------
  694|      0|	    ENSURE_NAMEDMAX(ans);
  695|      0|	return(ans);
  696|      0|    }
  697|       |
  698|       |    /* Method dispatch has failed, we now */
  699|       |    /* run the generic internal code. */
  700|    812|    return do_subset_dflt(call, op, ans, rho);
  701|    812|}
do_subset_dflt:
  726|   392k|{
  727|       |    /* By default we drop extents of length 1 */
  728|       |
  729|       |    /* Handle cases of extracting a single element from a simple vector
  730|       |       or matrix directly to improve speed for these simple cases. */
  731|   392k|    SEXP x = CAR(args);
  732|   392k|    SEXP cdrArgs = CDR(args);
  733|   392k|    SEXP cddrArgs = CDR(cdrArgs);
  734|   392k|    if (cdrArgs != R_NilValue && cddrArgs == R_NilValue &&
  ------------------
  |  Branch (734:9): [True: 392k, False: 0]
  |  Branch (734:34): [True: 390k, False: 2.41k]
  ------------------
  735|   390k|	TAG(cdrArgs) == R_NilValue) {
  ------------------
  |  Branch (735:2): [True: 390k, False: 0]
  ------------------
  736|       |	/* one index, not named */
  737|   390k|	if (ATTRIB(x) == R_NilValue) {
  ------------------
  |  Branch (737:6): [True: 389k, False: 745]
  ------------------
  738|   389k|	    SEXP s = CAR(cdrArgs);
  739|   389k|	    R_xlen_t i = scalarIndex(s);
  740|   389k|	    switch (TYPEOF(x)) {
  741|  1.77k|	    case REALSXP:
  ------------------
  |  |  124|  1.77k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (741:6): [True: 1.77k, False: 387k]
  ------------------
  742|  1.77k|		if (i >= 1 && i <= XLENGTH(x))
  ------------------
  |  Branch (742:7): [True: 0, False: 1.77k]
  |  Branch (742:17): [True: 0, False: 0]
  ------------------
  743|      0|		    return ScalarReal( REAL_ELT(x, i-1) );
  ------------------
  |  | 1024|      0|#define ScalarReal		Rf_ScalarReal
  ------------------
  744|  1.77k|		break;
  745|  1.77k|	    case INTSXP:
  ------------------
  |  |  123|     85|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (745:6): [True: 85, False: 389k]
  ------------------
  746|     85|		if (i >= 1 && i <= XLENGTH(x))
  ------------------
  |  Branch (746:7): [True: 14, False: 71]
  |  Branch (746:17): [True: 14, False: 0]
  ------------------
  747|     14|		    return ScalarInteger( INTEGER_ELT(x, i-1) );
  ------------------
  |  | 1022|     14|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  748|     71|		break;
  749|     71|	    case LGLSXP:
  ------------------
  |  |  121|      8|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (749:6): [True: 8, False: 389k]
  ------------------
  750|      8|		if (i >= 1 && i <= XLENGTH(x))
  ------------------
  |  Branch (750:7): [True: 0, False: 8]
  |  Branch (750:17): [True: 0, False: 0]
  ------------------
  751|      0|		    return ScalarLogical( LOGICAL_ELT(x, i-1) );
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  752|      8|		break;
  753|       |//	    do the more rare cases as well, since we've already prepared everything:
  754|      8|	    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (754:6): [True: 0, False: 389k]
  ------------------
  755|      0|		if (i >= 1 && i <= XLENGTH(x))
  ------------------
  |  Branch (755:7): [True: 0, False: 0]
  |  Branch (755:17): [True: 0, False: 0]
  ------------------
  756|      0|		    return ScalarComplex( COMPLEX_ELT(x, i-1) );
  ------------------
  |  | 1021|      0|#define ScalarComplex		Rf_ScalarComplex
  ------------------
  757|      0|		break;
  758|      0|	    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (758:6): [True: 0, False: 389k]
  ------------------
  759|      0|		if (i >= 1 && i <= XLENGTH(x))
  ------------------
  |  Branch (759:7): [True: 0, False: 0]
  |  Branch (759:17): [True: 0, False: 0]
  ------------------
  760|      0|		    return ScalarRaw( RAW_ELT(x, i-1) );
  ------------------
  |  | 1026|      0|#define ScalarRaw		Rf_ScalarRaw
  ------------------
  761|      0|		break;
  762|   387k|	    default: break;
  ------------------
  |  Branch (762:6): [True: 387k, False: 1.86k]
  ------------------
  763|   389k|	    }
  764|   389k|	}
  765|   390k|    }
  766|  2.41k|    else if (cddrArgs != R_NilValue && CDR(cddrArgs) == R_NilValue &&
  ------------------
  |  Branch (766:14): [True: 2.41k, False: 0]
  |  Branch (766:40): [True: 2.37k, False: 40]
  ------------------
  767|  2.37k|	     TAG(cdrArgs) == R_NilValue && TAG(cddrArgs) == R_NilValue) {
  ------------------
  |  Branch (767:7): [True: 2.37k, False: 0]
  |  Branch (767:37): [True: 2.37k, False: 0]
  ------------------
  768|       |	/* two indices, not named */
  769|  2.37k|	SEXP attr = ATTRIB(x);
  770|  2.37k|	if (TAG(attr) == R_DimSymbol && CDR(attr) == R_NilValue) {
  ------------------
  |  Branch (770:6): [True: 2.37k, False: 0]
  |  Branch (770:34): [True: 40, False: 2.33k]
  ------------------
  771|       |	    /* only attribute of x is 'dim' */
  772|     40|	    SEXP dim = CAR(attr);
  773|     40|	    if (TYPEOF(dim) == INTSXP && LENGTH(dim) == 2) {
  ------------------
  |  |  123|     80|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (773:10): [True: 40, False: 0]
  |  Branch (773:35): [True: 40, False: 0]
  ------------------
  774|       |		/* x is a matrix */
  775|     40|		SEXP si = CAR(cdrArgs);
  776|     40|		SEXP sj = CAR(cddrArgs);
  777|     40|		R_xlen_t i = scalarIndex(si);
  778|     40|		R_xlen_t j = scalarIndex(sj);
  779|     40|		int nrow = INTEGER_ELT(dim, 0);
  780|     40|		int ncol = INTEGER_ELT(dim, 1);
  781|     40|		if (i > 0 && j > 0 && i <= nrow && j <= ncol) {
  ------------------
  |  Branch (781:7): [True: 0, False: 40]
  |  Branch (781:16): [True: 0, False: 0]
  |  Branch (781:25): [True: 0, False: 0]
  |  Branch (781:38): [True: 0, False: 0]
  ------------------
  782|       |		    /* indices are legal scalars */
  783|      0|		    R_xlen_t k = i - 1 + nrow * (j - 1);
  784|      0|		    switch (TYPEOF(x)) {
  785|      0|		    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (785:7): [True: 0, False: 0]
  ------------------
  786|      0|			if (k < XLENGTH(x))
  ------------------
  |  Branch (786:8): [True: 0, False: 0]
  ------------------
  787|      0|			    return ScalarReal( REAL_ELT(x, k) );
  ------------------
  |  | 1024|      0|#define ScalarReal		Rf_ScalarReal
  ------------------
  788|      0|			break;
  789|      0|		    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (789:7): [True: 0, False: 0]
  ------------------
  790|      0|			if (k < XLENGTH(x))
  ------------------
  |  Branch (790:8): [True: 0, False: 0]
  ------------------
  791|      0|			    return ScalarInteger( INTEGER_ELT(x, k) );
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  792|      0|			break;
  793|      0|		    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (793:7): [True: 0, False: 0]
  ------------------
  794|      0|			if (k < XLENGTH(x))
  ------------------
  |  Branch (794:8): [True: 0, False: 0]
  ------------------
  795|      0|			    return ScalarLogical( LOGICAL_ELT(x, k) );
  ------------------
  |  | 1023|      0|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  796|      0|			break;
  797|      0|		    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (797:7): [True: 0, False: 0]
  ------------------
  798|      0|			if (k < XLENGTH(x))
  ------------------
  |  Branch (798:8): [True: 0, False: 0]
  ------------------
  799|      0|			    return ScalarComplex( COMPLEX_ELT(x, k) );
  ------------------
  |  | 1021|      0|#define ScalarComplex		Rf_ScalarComplex
  ------------------
  800|      0|			break;
  801|      0|		    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (801:7): [True: 0, False: 0]
  ------------------
  802|      0|			if (k < XLENGTH(x))
  ------------------
  |  Branch (802:8): [True: 0, False: 0]
  ------------------
  803|      0|			    return ScalarRaw( RAW_ELT(x, k) );
  ------------------
  |  | 1026|      0|#define ScalarRaw		Rf_ScalarRaw
  ------------------
  804|      0|			break;
  805|      0|		    default: break;
  ------------------
  |  Branch (805:7): [True: 0, False: 0]
  ------------------
  806|      0|		    }
  807|      0|		}
  808|     40|	    }
  809|     40|	}
  810|  2.37k|    }
  811|       |
  812|   392k|    PROTECT(args);
  ------------------
  |  |  357|   392k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  813|       |
  814|   392k|    int drop = 1;
  815|   392k|    ExtractDropArg(args, &drop);
  816|       |
  817|       |    /* This was intended for compatibility with S, */
  818|       |    /* but in fact S does not do this. */
  819|       |    /* FIXME: replace the test by isNull ... ? */
  820|       |
  821|   392k|    if (x == R_NilValue) {
  ------------------
  |  Branch (821:9): [True: 0, False: 392k]
  ------------------
  822|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  823|      0|	return x;
  824|      0|    }
  825|       |
  826|   392k|    SEXP subs = CDR(args);
  827|   392k|    int nsubs = length(subs); /* Will be short */
  ------------------
  |  |  987|   392k|#define length(x)		Rf_length(x)
  ------------------
  828|   392k|    int type = TYPEOF(x);
  829|       |
  830|       |    /* Here coerce pair-based objects into generic vectors. */
  831|       |    /* All subsetting takes place on the generic vector form. */
  832|       |
  833|   392k|    SEXP ax = x;
  834|   392k|    if (isVector(x))
  ------------------
  |  |  974|   392k|#define isVector		Rf_isVector
  ------------------
  |  Branch (834:9): [True: 392k, False: 122]
  ------------------
  835|   392k|	PROTECT(ax);
  ------------------
  |  |  357|   392k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  836|    122|    else if (type == LISTSXP || type == LANGSXP) { // *not* <DOTSXP>[]  :
  ------------------
  |  |  113|    244|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
                  else if (type == LISTSXP || type == LANGSXP) { // *not* <DOTSXP>[]  :
  ------------------
  |  |  117|    122|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (836:14): [True: 0, False: 122]
  |  Branch (836:33): [True: 122, False: 0]
  ------------------
  837|    122|	SEXP dim = getAttrib(x, R_DimSymbol);
  ------------------
  |  |  924|    122|#define getAttrib		Rf_getAttrib
  ------------------
  838|    122|	int ndim = length(dim);
  ------------------
  |  |  987|    122|#define length(x)		Rf_length(x)
  ------------------
  839|    122|	if (ndim > 1) {
  ------------------
  |  Branch (839:6): [True: 0, False: 122]
  ------------------
  840|      0|	    PROTECT(ax = allocArray(VECSXP, dim));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  841|      0|	    setAttrib(ax, R_DimNamesSymbol, getAttrib(x, R_DimNamesSymbol));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              	    setAttrib(ax, R_DimNamesSymbol, getAttrib(x, R_DimNamesSymbol));
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  842|      0|	    setAttrib(ax, R_NamesSymbol, getAttrib(x, R_DimNamesSymbol));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              	    setAttrib(ax, R_NamesSymbol, getAttrib(x, R_DimNamesSymbol));
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  843|      0|	}
  844|    122|	else {
  845|    122|	    PROTECT(ax = allocVector(VECSXP, length(x)));
  ------------------
  |  |  357|    122|#define PROTECT(s)	Rf_protect(s)
  ------------------
  846|    122|	    setAttrib(ax, R_NamesSymbol, getAttrib(x, R_NamesSymbol));
  ------------------
  |  | 1027|    122|#define setAttrib		Rf_setAttrib
  ------------------
              	    setAttrib(ax, R_NamesSymbol, getAttrib(x, R_NamesSymbol));
  ------------------
  |  |  924|    122|#define getAttrib		Rf_getAttrib
  ------------------
  847|    122|	}
  848|    122|	SEXP px; int i;
  849|    489|	for(px = x, i = 0 ; px != R_NilValue ; px = CDR(px))
  ------------------
  |  Branch (849:22): [True: 367, False: 122]
  ------------------
  850|    367|	    SET_VECTOR_ELT(ax, i++, CAR(px));
  851|    122|    }
  852|      0|    else errorcallNotSubsettable(x, call);
  853|       |
  854|       |    /* This is the actual subsetting code. */
  855|       |    /* The separation of arrays and matrices is purely an optimization. */
  856|       |
  857|   392k|    SEXP ans;
  858|   392k|    if(nsubs < 2) {
  ------------------
  |  Branch (858:8): [True: 389k, False: 2.41k]
  ------------------
  859|   389k|	SEXP dim = getAttrib(x, R_DimSymbol);
  ------------------
  |  |  924|   389k|#define getAttrib		Rf_getAttrib
  ------------------
  860|   389k|	int ndim = length(dim);
  ------------------
  |  |  987|   389k|#define length(x)		Rf_length(x)
  ------------------
  861|   389k|	PROTECT(ans = VectorSubset(ax, (nsubs == 1 ? CAR(subs) : R_MissingArg),
  ------------------
  |  |  357|   779k|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  |  Branch (357:31): [True: 389k, False: 0]
  |  |  ------------------
  ------------------
  862|   389k|				   call));
  863|       |	/* one-dimensional arrays went through here, and they should
  864|       |	   have their dimensions dropped only if the result has
  865|       |	   length one and drop == TRUE
  866|       |	*/
  867|   389k|	if(ndim == 1) {
  ------------------
  |  Branch (867:5): [True: 0, False: 389k]
  ------------------
  868|      0|	    int len = length(ans);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  869|      0|	    if(!drop || len > 1) {
  ------------------
  |  Branch (869:9): [True: 0, False: 0]
  |  Branch (869:18): [True: 0, False: 0]
  ------------------
  870|       |		// must grab these before the dim is set.
  871|      0|		SEXP nm = PROTECT(getAttrib(ans, R_NamesSymbol));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  872|      0|		SEXP attr = PROTECT(ScalarInteger(length(ans)));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  873|      0|		if(!isNull(getAttrib(dim, R_NamesSymbol)))
  ------------------
  |  |  956|      0|#define isNull			Rf_isNull
  ------------------
              		if(!isNull(getAttrib(dim, R_NamesSymbol)))
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (873:6): [True: 0, False: 0]
  ------------------
  874|      0|		    setAttrib(attr, R_NamesSymbol, getAttrib(dim, R_NamesSymbol));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              		    setAttrib(attr, R_NamesSymbol, getAttrib(dim, R_NamesSymbol));
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  875|      0|		setAttrib(ans, R_DimSymbol, attr);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  876|      0|		SEXP attrib;
  877|      0|		if((attrib = getAttrib(x, R_DimNamesSymbol)) != R_NilValue) {
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (877:6): [True: 0, False: 0]
  ------------------
  878|       |		    /* reinstate dimnames, include names of dimnames */
  879|      0|		    SEXP nattrib = PROTECT(duplicate(attrib));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  880|      0|		    SET_VECTOR_ELT(nattrib, 0, nm);
  881|      0|		    setAttrib(ans, R_DimNamesSymbol, nattrib);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  882|      0|		    setAttrib(ans, R_NamesSymbol, R_NilValue);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  883|      0|		    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  884|      0|		}
  885|      0|		UNPROTECT(2);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  886|      0|	    }
  887|      0|	}
  888|   389k|    } else {
  889|  2.41k|	if (nsubs != length(getAttrib(x, R_DimSymbol)))
  ------------------
  |  |  987|  2.41k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (889:6): [True: 0, False: 2.41k]
  ------------------
  890|      0|	    errorcall(call, _("incorrect number of dimensions"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("incorrect number of dimensions"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  891|  2.41k|	if (nsubs == 2)
  ------------------
  |  Branch (891:6): [True: 2.41k, False: 0]
  ------------------
  892|  2.41k|	    ans = MatrixSubset(ax, subs, call, drop);
  893|      0|	else
  894|      0|	    ans = ArraySubset(ax, subs, call, drop);
  895|  2.41k|	PROTECT(ans);
  ------------------
  |  |  357|  2.41k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  896|  2.41k|    }
  897|       |
  898|       |    /* Note: we do not coerce back to pair-based lists. */
  899|       |    /* They are "defunct" in this version of R. */
  900|       |
  901|   392k|    if (type == LANGSXP) {
  ------------------
  |  |  117|   392k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (901:9): [True: 122, False: 392k]
  ------------------
  902|    122|	ax = ans;
  903|    122|	PROTECT(ans = allocLang(LENGTH(ax)));
  ------------------
  |  |  357|    122|#define PROTECT(s)	Rf_protect(s)
  ------------------
  904|    122|	if ( LENGTH(ax) > 0 ) {
  ------------------
  |  Branch (904:7): [True: 122, False: 0]
  ------------------
  905|    122|	    SEXP px; int i;
  906|    365|	    for(px = ans, i = 0 ; px != R_NilValue ; px = CDR(px))
  ------------------
  |  Branch (906:28): [True: 243, False: 122]
  ------------------
  907|    243|		SETCAR(px, VECTOR_ELT(ax, i++));
  908|    122|	    setAttrib(ans, R_DimSymbol,      getAttrib(ax, R_DimSymbol));
  ------------------
  |  | 1027|    122|#define setAttrib		Rf_setAttrib
  ------------------
              	    setAttrib(ans, R_DimSymbol,      getAttrib(ax, R_DimSymbol));
  ------------------
  |  |  924|    122|#define getAttrib		Rf_getAttrib
  ------------------
  909|    122|	    setAttrib(ans, R_DimNamesSymbol, getAttrib(ax, R_DimNamesSymbol));
  ------------------
  |  | 1027|    122|#define setAttrib		Rf_setAttrib
  ------------------
              	    setAttrib(ans, R_DimNamesSymbol, getAttrib(ax, R_DimNamesSymbol));
  ------------------
  |  |  924|    122|#define getAttrib		Rf_getAttrib
  ------------------
  910|    122|	    setAttrib(ans, R_NamesSymbol,    getAttrib(ax, R_NamesSymbol));
  ------------------
  |  | 1027|    122|#define setAttrib		Rf_setAttrib
  ------------------
              	    setAttrib(ans, R_NamesSymbol,    getAttrib(ax, R_NamesSymbol));
  ------------------
  |  |  924|    122|#define getAttrib		Rf_getAttrib
  ------------------
  911|    122|	    RAISE_NAMED(ans, NAMED(ax)); /* PR#7924 */
  912|    122|	}
  913|    122|    }
  914|   392k|    else {
  915|   392k|	PROTECT(ans);
  ------------------
  |  |  357|   392k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  916|   392k|    }
  917|   392k|    if (ATTRIB(ans) != R_NilValue) { /* remove probably erroneous attr's */
  ------------------
  |  Branch (917:9): [True: 3.08k, False: 389k]
  ------------------
  918|  3.08k|	setAttrib(ans, R_TspSymbol, R_NilValue);
  ------------------
  |  | 1027|  3.08k|#define setAttrib		Rf_setAttrib
  ------------------
  919|       |#ifdef _S4_subsettable
  920|       |	if(!IS_S4_OBJECT(x))
  921|       |#endif
  922|  3.08k|	    setAttrib(ans, R_ClassSymbol, R_NilValue);
  ------------------
  |  | 1027|  3.08k|#define setAttrib		Rf_setAttrib
  ------------------
  923|  3.08k|    }
  924|   392k|    UNPROTECT(4);
  ------------------
  |  |  358|   392k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  925|   392k|    return ans;
  926|   392k|}
do_subset2:
  933|  2.05k|{
  934|  2.05k|    SEXP ans;
  935|       |
  936|       |    /* If the first argument is an object and there is */
  937|       |    /* an appropriate method, we dispatch to that method, */
  938|       |    /* otherwise we evaluate the arguments and fall */
  939|       |    /* through to the generic code below.  Note that */
  940|       |    /* evaluation retains any missing argument indicators. */
  941|       |
  942|       |    /* DispatchOrEval internal generic: [[ */
  943|  2.05k|    if(R_DispatchOrEvalSP(call, op, "[[", args, rho, &ans)) {
  ------------------
  |  Branch (943:8): [True: 0, False: 2.05k]
  ------------------
  944|      0|	if (NAMED(ans))
  ------------------
  |  Branch (944:6): [True: 0, False: 0]
  ------------------
  945|      0|	    ENSURE_NAMEDMAX(ans);
  946|      0|	return(ans);
  947|      0|    }
  948|       |
  949|       |    /* Method dispatch has failed. */
  950|       |    /* We now run the generic internal code. */
  951|       |
  952|  2.05k|    return do_subset2_dflt(call, op, ans, rho);
  953|  2.05k|}
do_subset2_dflt:
  956|   778k|{
  957|   778k|    SEXP ans, dims, dimnames, indx, subs, x;
  958|   778k|    int i, ndims, nsubs;
  959|   778k|    int drop = 1;
  960|   778k|    R_xlen_t offset = 0;
  961|       |
  962|   778k|    PROTECT(args);
  ------------------
  |  |  357|   778k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  963|   778k|    ExtractDropArg(args, &drop);
  964|       |    /* Is partial matching ok?  When the exact arg is NA, a warning is
  965|       |       issued if partial matching occurs.
  966|       |     */
  967|   778k|    int exact = ExtractExactArg(args);
  968|   778k|    int pok = (exact == -1) ? exact : ! exact;
  ------------------
  |  Branch (968:15): [True: 0, False: 778k]
  ------------------
  969|       |
  970|   778k|    x = CAR(args);
  971|       |
  972|       |    /* Get the subscripting and dimensioning information */
  973|       |    /* and check that any array subscripting is compatible. */
  974|       |
  975|   778k|    subs = CDR(args);
  976|   778k|    if(0 == (nsubs = length(subs)))
  ------------------
  |  |  987|   778k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (976:8): [True: 0, False: 778k]
  ------------------
  977|      0|	errorcall(call, _("no index specified"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("no index specified"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  978|       |
  979|       |    /* This code was intended for compatibility with S, */
  980|       |    /* but in fact S does not do this.	Will anyone notice? */
  981|   778k|    if (x == R_NilValue) {
  ------------------
  |  Branch (981:9): [True: 32, False: 778k]
  ------------------
  982|     32|	UNPROTECT(1); /* args */
  ------------------
  |  |  358|     32|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  983|     32|	if(CAR(subs) == R_MissingArg)
  ------------------
  |  Branch (983:5): [True: 0, False: 32]
  ------------------
  984|      0|	    errorcallMissingSubs(x, call);
  985|       |	// else
  986|     32|	return x;
  987|     32|    }
  988|       |
  989|   778k|    dims = getAttrib(x, R_DimSymbol);
  ------------------
  |  |  924|   778k|#define getAttrib		Rf_getAttrib
  ------------------
  990|   778k|    ndims = length(dims);
  ------------------
  |  |  987|   778k|#define length(x)		Rf_length(x)
  ------------------
  991|   778k|    if(nsubs > 1 && nsubs != ndims)
  ------------------
  |  Branch (991:8): [True: 0, False: 778k]
  |  Branch (991:21): [True: 0, False: 0]
  ------------------
  992|      0|	errorcall(call, _("incorrect number of subscripts"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("incorrect number of subscripts"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  993|       |
  994|       |    /* code to allow classes to extend environment */
  995|   778k|    if(TYPEOF(x) == OBJSXP) {
  ------------------
  |  |  137|   778k|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (995:8): [True: 0, False: 778k]
  ------------------
  996|      0|	SEXP xs = x;
  997|      0|	x = R_getS4DataSlot(x, ANYSXP);
  ------------------
  |  |  128|      0|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
  998|      0|	if(x == R_NilValue)
  ------------------
  |  Branch (998:5): [True: 0, False: 0]
  ------------------
  999|      0|	    errorcall(call, _("this %s class is not subsettable"),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("this %s class is not subsettable"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1000|      0|		      IS_S4_OBJECT(xs) ? "S4" : "object");
  ------------------
  |  Branch (1000:9): [True: 0, False: 0]
  ------------------
 1001|      0|    }
 1002|   778k|    PROTECT(x);
  ------------------
  |  |  357|   778k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1003|       |
 1004|       |    /* split out ENVSXP for now */
 1005|   778k|    if( TYPEOF(x) == ENVSXP ) {
  ------------------
  |  |  115|   778k|#define ENVSXP	     4	  /* environments */
  ------------------
  |  Branch (1005:9): [True: 3.24k, False: 775k]
  ------------------
 1006|  3.24k|	if( nsubs != 1 || !isString(CAR(subs)) || length(CAR(subs)) != 1 )
  ------------------
  |  |  966|  3.24k|#define isString		Rf_isString
  ------------------
              	if( nsubs != 1 || !isString(CAR(subs)) || length(CAR(subs)) != 1 )
  ------------------
  |  |  987|  3.24k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1006:6): [True: 0, False: 3.24k]
  |  Branch (1006:20): [True: 0, False: 3.24k]
  |  Branch (1006:44): [True: 0, False: 3.24k]
  ------------------
 1007|      0|	    errorcall(call, _("wrong arguments for subsetting an environment"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("wrong arguments for subsetting an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1008|  3.24k|	ans = R_findVarInFrame(x, installTrChar(STRING_ELT(CAR(subs), 0)));
  ------------------
  |  |  937|  3.24k|#define installTrChar		Rf_installTrChar
  ------------------
 1009|  3.24k|	if( TYPEOF(ans) == PROMSXP ) {
  ------------------
  |  |  116|  3.24k|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (1009:6): [True: 512, False: 2.73k]
  ------------------
 1010|    512|	    PROTECT(ans);
  ------------------
  |  |  357|    512|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1011|    512|	    ans = eval(ans, R_GlobalEnv);
  ------------------
  |  |  913|    512|#define eval			Rf_eval
  ------------------
 1012|    512|	    UNPROTECT(1); /* ans */
  ------------------
  |  |  358|    512|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1013|  2.73k|	} else ENSURE_NAMEDMAX(ans);
 1014|       |
 1015|  3.24k|	UNPROTECT(2); /* args, x */
  ------------------
  |  |  358|  3.24k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1016|  3.24k|	if(ans == R_UnboundValue)
  ------------------
  |  Branch (1016:5): [True: 992, False: 2.25k]
  ------------------
 1017|    992|	    return(R_NilValue);
 1018|  2.25k|	if (NAMED(ans))
  ------------------
  |  Branch (1018:6): [True: 2.25k, False: 0]
  ------------------
 1019|  2.25k|	    ENSURE_NAMEDMAX(ans);
 1020|  2.25k|	return ans;
 1021|  3.24k|    }
 1022|       |
 1023|       |    /* back to the regular program */
 1024|   775k|    if (!(isVector(x) || isList(x) || isLanguage(x)))
  ------------------
  |  |  974|   775k|#define isVector		Rf_isVector
  ------------------
                  if (!(isVector(x) || isList(x) || isLanguage(x)))
  ------------------
  |  |  951|    422|#define isList			Rf_isList
  ------------------
                  if (!(isVector(x) || isList(x) || isLanguage(x)))
  ------------------
  |  |  950|    388|#define isLanguage		Rf_isLanguage
  ------------------
  |  Branch (1024:11): [True: 774k, False: 422]
  |  Branch (1024:26): [True: 34, False: 388]
  |  Branch (1024:39): [True: 388, False: 0]
  ------------------
 1025|      0|	errorcallNotSubsettable(x, call);
 1026|       |
 1027|       |#ifndef SWITCH_TO_REFCNT
 1028|       |    int named_x;
 1029|       |    named_x = NAMED(x);  /* x may change below; save this now.  See PR#13411 */
 1030|       |#endif
 1031|       |
 1032|   775k|    if(nsubs == 1) { /* vector indexing */
  ------------------
  |  Branch (1032:8): [True: 775k, False: 0]
  ------------------
 1033|   775k|	SEXP thesub = CAR(subs);
 1034|   775k|	int len = length(thesub);
  ------------------
  |  |  987|   775k|#define length(x)		Rf_length(x)
  ------------------
 1035|       |
 1036|   775k|	if (len > 1) {
  ------------------
  |  Branch (1036:6): [True: 0, False: 775k]
  ------------------
 1037|      0|#ifdef SWITCH_TO_REFCNT
 1038|      0|	    if (IS_GETTER_CALL(call)) {
  ------------------
  |  |  554|      0|#define IS_GETTER_CALL(call) (CADR(call) == R_TmpvalSymbol)
  |  |  ------------------
  |  |  |  Branch (554:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1039|       |		/* This is (most likely) a getter call in a complex
 1040|       |		   assighment so we duplicate as needed. The original
 1041|       |		   x should have been duplicated if it might be
 1042|       |		   shared, but might get additional references before
 1043|       |		   it arrives here. */
 1044|      0|		if (MAYBE_SHARED(x)) {
  ------------------
  |  Branch (1044:7): [True: 0, False: 0]
  ------------------
 1045|      0|		    x = shallow_duplicate(x);
  ------------------
  |  | 1030|      0|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 1046|      0|		    UNPROTECT(1); /* old x */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1047|      0|		    PROTECT(x);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1048|      0|		}
 1049|      0|		x = vectorIndex(x, thesub, 0, len-1, pok, call, TRUE);
  ------------------
  |  | 2012|      0|# define vectorIndex		Rf_vectorIndex
  ------------------
 1050|      0|	    }
 1051|      0|	    else
 1052|      0|		x = vectorIndex(x, thesub, 0, len-1, pok, call, FALSE);
  ------------------
  |  | 2012|      0|# define vectorIndex		Rf_vectorIndex
  ------------------
 1053|       |#else
 1054|       |	    x = vectorIndex(x, thesub, 0, len-1, pok, call, FALSE);
 1055|       |	    named_x = NAMED(x);
 1056|       |#endif
 1057|      0|	    UNPROTECT(1); /* x */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1058|      0|	    PROTECT(x);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1059|      0|	}
 1060|       |
 1061|   775k|	SEXP xnames = PROTECT(getAttrib(x, R_NamesSymbol));
  ------------------
  |  |  357|   775k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1062|   775k|	offset = get1index(thesub, xnames,
  ------------------
  |  | 1906|   775k|# define get1index		Rf_get1index
  ------------------
 1063|   775k|			   xlength(x), pok, len > 1 ? len-1 : -1, call);
  ------------------
  |  | 1049|   775k|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (1063:24): [True: 0, False: 775k]
  ------------------
 1064|   775k|	UNPROTECT(1); /* xnames */
  ------------------
  |  |  358|   775k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1065|   775k|	if (offset < 0 || offset >= xlength(x)) {
  ------------------
  |  | 1049|   773k|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (1065:6): [True: 1.95k, False: 773k]
  |  Branch (1065:20): [True: 0, False: 773k]
  ------------------
 1066|       |	    /* a bold attempt to get the same behaviour for $ and [[ */
 1067|  1.95k|	    if (offset < 0 && (isNewList(x) ||
  ------------------
  |  |  955|  1.95k|#define isNewList		Rf_isNewList
  ------------------
  |  Branch (1067:10): [True: 1.95k, False: 0]
  |  Branch (1067:25): [True: 1.95k, False: 0]
  ------------------
 1068|      0|			       isExpression(x) ||
  ------------------
  |  |  945|      0|#define isExpression		Rf_isExpression
  ------------------
  |  Branch (1068:11): [True: 0, False: 0]
  ------------------
 1069|      0|			       isList(x) ||
  ------------------
  |  |  951|      0|#define isList			Rf_isList
  ------------------
  |  Branch (1069:11): [True: 0, False: 0]
  ------------------
 1070|  1.95k|			       isLanguage(x))) {
  ------------------
  |  |  950|      0|#define isLanguage		Rf_isLanguage
  ------------------
  |  Branch (1070:11): [True: 0, False: 0]
  ------------------
 1071|  1.95k|		UNPROTECT(2); /* args, x */
  ------------------
  |  |  358|  1.95k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1072|  1.95k|		return R_NilValue;
 1073|  1.95k|	    }
 1074|      0|	    else errorcallOutOfBoundsSEXP(x, -1, thesub, call);
 1075|  1.95k|	}
 1076|   775k|    } else { /* nsubs == ndims >= 2 : matrix|array indexing */
 1077|       |	/* Here we use the fact that: */
 1078|       |	/* CAR(R_NilValue) = R_NilValue */
 1079|       |	/* CDR(R_NilValue) = R_NilValue */
 1080|       |
 1081|      0|	int ndn; /* Number of dimnames. Unlikely to be anything but
 1082|       |		    0 or nsubs, but just in case... */
 1083|       |
 1084|      0|	PROTECT(indx = allocVector(INTSXP, nsubs));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1085|      0|	int *pindx = INTEGER(indx);
 1086|      0|	const int *pdims = INTEGER_RO(dims);
 1087|      0|	dimnames = getAttrib(x, R_DimNamesSymbol);
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
 1088|      0|	ndn = length(dimnames);
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
 1089|      0|	for (i = 0; i < nsubs; i++) {
  ------------------
  |  Branch (1089:14): [True: 0, False: 0]
  ------------------
 1090|      0|	    SEXP thesub = CAR(subs);
 1091|      0|	    pindx[i] = (int)
 1092|      0|		get1index(thesub,
  ------------------
  |  | 1906|      0|# define get1index		Rf_get1index
  ------------------
 1093|      0|			  (i < ndn) ? VECTOR_ELT(dimnames, i) : R_NilValue,
  ------------------
  |  Branch (1093:6): [True: 0, False: 0]
  ------------------
 1094|      0|			  pdims[i], pok, -1, call);
 1095|      0|	    subs = CDR(subs);
 1096|      0|	    if (pindx[i] < 0 || pindx[i] >= pdims[i])
  ------------------
  |  Branch (1096:10): [True: 0, False: 0]
  |  Branch (1096:26): [True: 0, False: 0]
  ------------------
 1097|      0|		errorcallOutOfBoundsSEXP(x, i, thesub, call);
 1098|      0|	}
 1099|      0|	offset = 0;
 1100|      0|	for (i = (nsubs - 1); i > 0; i--)
  ------------------
  |  Branch (1100:24): [True: 0, False: 0]
  ------------------
 1101|      0|	    offset = (offset + pindx[i]) * pdims[i - 1];
 1102|      0|	offset += pindx[0];
 1103|      0|	UNPROTECT(1); /* indx */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1104|      0|    }
 1105|       |
 1106|   773k|    if(isPairList(x)) {
  ------------------
  |  |  961|   773k|#define isPairList		Rf_isPairList
  ------------------
  |  Branch (1106:8): [True: 422, False: 773k]
  ------------------
 1107|    422|#ifdef LONG_VECTOR_SUPPORT
 1108|    422|	if (offset > R_SHORT_LEN_MAX)
  ------------------
  |  |   77|    422|# define R_SHORT_LEN_MAX 2147483647
  ------------------
  |  Branch (1108:6): [True: 0, False: 422]
  ------------------
 1109|      0|	    error("invalid subscript for pairlist");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 1110|    422|#endif
 1111|    422|	ans = CAR(nthcdr(x, (int) offset));
  ------------------
  |  | 1009|    422|#define nthcdr			Rf_nthcdr
  ------------------
 1112|       |#ifndef SWITCH_TO_REFCNT
 1113|       |	RAISE_NAMED(ans, named_x);
 1114|       |#endif
 1115|   773k|    } else if(isVectorList(x)) {
  ------------------
  |  |  977|   773k|#define isVectorList		Rf_isVectorList
  ------------------
  |  Branch (1115:15): [True: 772k, False: 203]
  ------------------
 1116|       |	/* did unconditional duplication before 2.4.0 */
 1117|   772k|	ans = VECTOR_ELT(x, offset);
 1118|       |#ifndef SWITCH_TO_REFCNT
 1119|       |	RAISE_NAMED(ans, named_x);
 1120|       |#endif
 1121|   772k|    } else {
 1122|    203|	ans = PROTECT(allocVector(TYPEOF(x), 1));
  ------------------
  |  |  357|    203|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1123|    203|	switch (TYPEOF(x)) {
 1124|      0|	case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1124:2): [True: 0, False: 203]
  ------------------
 1125|      0|	    LOGICAL0(ans)[0] = LOGICAL_ELT(x, offset);
 1126|      0|	    break;
 1127|     74|	case INTSXP:
  ------------------
  |  |  123|     74|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1127:2): [True: 74, False: 129]
  ------------------
 1128|     74|	    INTEGER0(ans)[0] = INTEGER_ELT(x, offset);
 1129|     74|	    break;
 1130|      0|	case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1130:2): [True: 0, False: 203]
  ------------------
 1131|      0|	    REAL0(ans)[0] = REAL_ELT(x, offset);
 1132|      0|	    break;
 1133|      0|	case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1133:2): [True: 0, False: 203]
  ------------------
 1134|      0|	    COMPLEX0(ans)[0] = COMPLEX_ELT(x, offset);
 1135|      0|	    break;
 1136|    129|	case STRSXP:
  ------------------
  |  |  126|    129|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1136:2): [True: 129, False: 74]
  ------------------
 1137|    129|	    SET_STRING_ELT(ans, 0, STRING_ELT(x, offset));
 1138|    129|	    break;
 1139|      0|	case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1139:2): [True: 0, False: 203]
  ------------------
 1140|      0|	    RAW0(ans)[0] = RAW_ELT(x, offset);
 1141|      0|	    break;
 1142|      0|	default:
  ------------------
  |  Branch (1142:2): [True: 0, False: 203]
  ------------------
 1143|      0|	    UNIMPLEMENTED_TYPE("do_subset2", x);
 1144|    203|	}
 1145|    203|	UNPROTECT(1); /* ans */
  ------------------
  |  |  358|    203|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1146|    203|    }
 1147|   773k|    UNPROTECT(2); /* args, x */
  ------------------
  |  |  358|   773k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1148|   773k|    return ans;
 1149|   773k|}
dispatch_subset2:
 1152|  3.11k|{
 1153|  3.11k|    static SEXP bracket_op = NULL;
 1154|  3.11k|    SEXP args, x_elt;
 1155|  3.11k|    if (isObject(x)) {
  ------------------
  |  |  959|  3.11k|#define isObject		Rf_isObject
  ------------------
  |  Branch (1155:9): [True: 0, False: 3.11k]
  ------------------
 1156|      0|        if (bracket_op == NULL)
  ------------------
  |  Branch (1156:13): [True: 0, False: 0]
  ------------------
 1157|      0|            bracket_op = R_Primitive("[[");
 1158|      0|        PROTECT(args = list2(x, ScalarReal((double)i + 1)));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1159|      0|        x_elt = do_subset2(call, bracket_op, args, rho);
 1160|      0|        UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1161|  3.11k|    } else {
 1162|       |      // FIXME: throw error if not a list
 1163|  3.11k|        x_elt = VECTOR_ELT(x, i);
 1164|  3.11k|    }
 1165|  3.11k|    return(x_elt);
 1166|  3.11k|}
Rf_fixSubset3Args:
 1209|    392|{
 1210|    392|    SEXP input, nlist;
 1211|       |
 1212|       |    /* first translate CADR of args into a string so that we can
 1213|       |       pass it down to DispatchorEval and have it behave correctly */
 1214|       |
 1215|    392|    PROTECT(input = allocVector(STRSXP, 1));
  ------------------
  |  |  357|    392|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1216|    392|    nlist = CADR(args);
 1217|    392|    if (TYPEOF(nlist) == PROMSXP)
  ------------------
  |  |  116|    392|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (1217:9): [True: 0, False: 392]
  ------------------
 1218|      0|	nlist = eval(nlist, env);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 1219|    392|    if(isSymbol(nlist)) {
  ------------------
  |  |  953|    392|#define isSymbol		Rf_isSymbol
  ------------------
  |  Branch (1219:8): [True: 392, False: 0]
  ------------------
 1220|    392|	if (syminp != NULL)
  ------------------
  |  Branch (1220:6): [True: 0, False: 392]
  ------------------
 1221|      0|	    *syminp = nlist;
 1222|    392|	SET_STRING_ELT(input, 0, PRINTNAME(nlist));
 1223|    392|    } else if(isString(nlist) ) {
  ------------------
  |  |  966|      0|#define isString		Rf_isString
  ------------------
  |  Branch (1223:15): [True: 0, False: 0]
  ------------------
 1224|      0|	if (LENGTH(nlist) != 1)
  ------------------
  |  Branch (1224:6): [True: 0, False: 0]
  ------------------
 1225|      0|	    error(_("invalid subscript length"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("invalid subscript length"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1226|      0|	SET_STRING_ELT(input, 0, STRING_ELT(nlist, 0));
 1227|      0|    }
 1228|      0|    else {
 1229|      0|	errorcall(call,_("invalid subscript type '%s'"),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call,_("invalid subscript type '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1230|      0|		  R_typeToChar(nlist));
 1231|      0|	return R_NilValue; /*-Wall*/
 1232|      0|    }
 1233|       |
 1234|       |    /* replace the second argument with a string */
 1235|       |
 1236|       |    /* Previously this was SETCADR(args, input); */
 1237|       |    /* which could cause problems when nlist was */
 1238|       |    /* ..., as in PR#8718 */
 1239|       |
 1240|    392|    args = shallow_duplicate(args);
  ------------------
  |  | 1030|    392|#define shallow_duplicate	Rf_shallow_duplicate
  ------------------
 1241|    392|    SETCADR(args, input);
 1242|    392|    UNPROTECT(1); /* input */
  ------------------
  |  |  358|    392|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1243|    392|    return args;
 1244|    392|}
do_subset3:
 1251|    392|{
 1252|    392|    SEXP ans;
 1253|       |
 1254|    392|    checkArity(op, args);
  ------------------
  |  | 1788|    392|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1255|    392|    PROTECT(args = fixSubset3Args(call, args, env, NULL));
  ------------------
  |  |  357|    392|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1256|       |
 1257|       |    /* If the first argument is an object and there is */
 1258|       |    /* an appropriate method, we dispatch to that method, */
 1259|       |    /* otherwise we evaluate the arguments and fall */
 1260|       |    /* through to the generic code below.  Note that */
 1261|       |    /* evaluation retains any missing argument indicators. */
 1262|       |
 1263|       |    /* DispatchOrEval internal generic: $ */
 1264|    392|    if(R_DispatchOrEvalSP(call, op, "$", args, env, &ans)) {
  ------------------
  |  Branch (1264:8): [True: 0, False: 392]
  ------------------
 1265|      0|	UNPROTECT(1); /* args */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1266|      0|	if (NAMED(ans))
  ------------------
  |  Branch (1266:6): [True: 0, False: 0]
  ------------------
 1267|      0|	    ENSURE_NAMEDMAX(ans);
 1268|      0|	return(ans);
 1269|      0|    }
 1270|    392|    PROTECT(ans);
  ------------------
  |  |  357|    392|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1271|    392|    ans = R_subset3_dflt(CAR(ans), STRING_ELT(CADR(args), 0), call);
 1272|    392|    UNPROTECT(2); /* args, ans */
  ------------------
  |  |  358|    392|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1273|    392|    return ans;
 1274|    392|}
R_subset3_dflt:
 1278|  8.63k|{
 1279|  8.63k|    SEXP y;
 1280|  8.63k|    PROTECT(input);
  ------------------
  |  |  357|  8.63k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1281|  8.63k|    PROTECT(x);
  ------------------
  |  |  357|  8.63k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1282|       |
 1283|       |    /* Optimisation to prevent repeated recalculation */
 1284|  8.63k|    size_t slen = strlen(translateChar(input));
  ------------------
  |  | 1037|  8.63k|#define translateChar		Rf_translateChar
  ------------------
 1285|       |    /* The mechanism to allow a class extending "environment" */
 1286|  8.63k|    if( IS_S4_OBJECT(x) && TYPEOF(x) == OBJSXP ){
  ------------------
  |  |  137|      0|#define OBJSXP      25    /* object, non-vector  */
  ------------------
  |  Branch (1286:9): [True: 0, False: 8.63k]
  |  Branch (1286:28): [True: 0, False: 0]
  ------------------
 1287|      0|	x = R_getS4DataSlot(x, ANYSXP);
  ------------------
  |  |  128|      0|#define ANYSXP	    18	  /* make "any" args work.
  ------------------
 1288|      0|	if(x == R_NilValue)
  ------------------
  |  Branch (1288:5): [True: 0, False: 0]
  ------------------
 1289|      0|	    errorcall(call, "$ operator not defined for this S4 class");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 1290|       |
 1291|      0|	UNPROTECT(1); /* x */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1292|      0|	PROTECT(x);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1293|      0|    }
 1294|       |
 1295|       |    // isPairList(x)  but *not* <DOTSXP> :
 1296|  8.63k|    if (TYPEOF(x) == LISTSXP || TYPEOF(x) == LANGSXP || TYPEOF(x) == NILSXP) {
  ------------------
  |  |  113|  17.2k|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
                  if (TYPEOF(x) == LISTSXP || TYPEOF(x) == LANGSXP || TYPEOF(x) == NILSXP) {
  ------------------
  |  |  117|  17.2k|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
                  if (TYPEOF(x) == LISTSXP || TYPEOF(x) == LANGSXP || TYPEOF(x) == NILSXP) {
  ------------------
  |  |  111|  8.63k|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (1296:9): [True: 0, False: 8.63k]
  |  Branch (1296:33): [True: 0, False: 8.63k]
  |  Branch (1296:57): [True: 63, False: 8.57k]
  ------------------
 1297|     63|	SEXP xmatch = R_NilValue;
 1298|     63|	int havematch;
 1299|     63|	havematch = 0;
 1300|     63|	for (y = x ; y != R_NilValue ; y = CDR(y)) {
  ------------------
  |  Branch (1300:15): [True: 0, False: 63]
  ------------------
 1301|      0|	    switch(pstrmatch(TAG(y), input, slen)) {
  ------------------
  |  Branch (1301:13): [True: 0, False: 0]
  ------------------
 1302|      0|	    case EXACT_MATCH:
  ------------------
  |  Branch (1302:6): [True: 0, False: 0]
  ------------------
 1303|      0|		y = CAR(y);
 1304|      0|		RAISE_NAMED(y, NAMED(x));
 1305|      0|		UNPROTECT(2); /* input, x */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1306|      0|		return y;
 1307|      0|	    case PARTIAL_MATCH:
  ------------------
  |  Branch (1307:6): [True: 0, False: 0]
  ------------------
 1308|      0|		havematch++;
 1309|      0|		xmatch = y;
 1310|      0|#ifdef SWITCH_TO_REFCNT
 1311|      0|		if (IS_GETTER_CALL(call))
  ------------------
  |  |  554|      0|#define IS_GETTER_CALL(call) (CADR(call) == R_TmpvalSymbol)
  |  |  ------------------
  |  |  |  Branch (554:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1312|      0|		    MARK_NOT_MUTABLE(y);
 1313|      0|#endif
 1314|      0|		break;
 1315|      0|	    case NO_MATCH:
  ------------------
  |  Branch (1315:6): [True: 0, False: 0]
  ------------------
 1316|      0|		break;
 1317|      0|	    }
 1318|      0|	}
 1319|     63|	if (havematch == 1) { /* unique partial match */
  ------------------
  |  Branch (1319:6): [True: 0, False: 63]
  ------------------
 1320|      0|	    if(R_warn_partial_match_dollar) {
  ------------------
  |  Branch (1320:9): [True: 0, False: 0]
  ------------------
 1321|      0|		SEXP target = TAG(xmatch);
 1322|      0|		SEXP cond =
 1323|      0|		    R_makePartialMatchWarningCondition(call,
 1324|      0|						       input,
 1325|      0|						       target);
 1326|      0|		PROTECT(cond);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1327|      0|		R_signalWarningCondition(cond);
 1328|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1329|      0|	    }
 1330|      0|	    y = CAR(xmatch);
 1331|      0|	    RAISE_NAMED(y, NAMED(x));
 1332|      0|	    UNPROTECT(2); /* input, x */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1333|      0|	    return y;
 1334|      0|	}
 1335|     63|	UNPROTECT(2); /* input, x */
  ------------------
  |  |  358|     63|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1336|     63|	return R_NilValue;
 1337|     63|    }
 1338|  8.57k|    else if (isVectorList(x)) {
  ------------------
  |  |  977|  8.57k|#define isVectorList		Rf_isVectorList
  ------------------
  |  Branch (1338:14): [True: 8.52k, False: 44]
  ------------------
 1339|  8.52k|	R_xlen_t i, n, imatch = -1;
 1340|  8.52k|	int havematch;
 1341|  8.52k|	SEXP nlist = getAttrib(x, R_NamesSymbol);
  ------------------
  |  |  924|  8.52k|#define getAttrib		Rf_getAttrib
  ------------------
 1342|       |
 1343|  8.52k|	n = xlength(nlist);
  ------------------
  |  | 1049|  8.52k|#define xlength(x)		Rf_xlength(x)
  ------------------
 1344|  8.52k|	havematch = 0;
 1345|  25.6k|	for (i = 0 ; i < n ; i = i + 1) {
  ------------------
  |  Branch (1345:15): [True: 25.6k, False: 57]
  ------------------
 1346|  25.6k|	    switch(pstrmatch(STRING_ELT(nlist, i), input, slen)) {
  ------------------
  |  Branch (1346:13): [True: 25.6k, False: 0]
  ------------------
 1347|  8.47k|	    case EXACT_MATCH:
  ------------------
  |  Branch (1347:6): [True: 8.47k, False: 17.1k]
  ------------------
 1348|  8.47k|		y = VECTOR_ELT(x, i);
 1349|  8.47k|		RAISE_NAMED(y, NAMED(x));
 1350|  8.47k|		UNPROTECT(2); /* input, x */
  ------------------
  |  |  358|  8.47k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1351|  8.47k|		return y;
 1352|      0|	    case PARTIAL_MATCH:
  ------------------
  |  Branch (1352:6): [True: 0, False: 25.6k]
  ------------------
 1353|      0|		havematch++;
 1354|      0|		if (havematch == 1) {
  ------------------
  |  Branch (1354:7): [True: 0, False: 0]
  ------------------
 1355|       |		    /* partial matches can cause aliasing in eval.c:evalseq
 1356|       |		       This is overkill, but alternative ways to prevent
 1357|       |		       the aliasing appear to be even worse */
 1358|      0|		    y = VECTOR_ELT(x,i);
 1359|      0|#ifdef SWITCH_TO_REFCNT
 1360|      0|		    if (IS_GETTER_CALL(call))
  ------------------
  |  |  554|      0|#define IS_GETTER_CALL(call) (CADR(call) == R_TmpvalSymbol)
  |  |  ------------------
  |  |  |  Branch (554:30): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1361|      0|			MARK_NOT_MUTABLE(y);
 1362|       |#else
 1363|       |		    ENSURE_NAMEDMAX(y);
 1364|       |#endif
 1365|      0|		    SET_VECTOR_ELT(x,i,y);
 1366|      0|		}
 1367|      0|		imatch = i;
 1368|      0|		break;
 1369|  17.1k|	    case NO_MATCH:
  ------------------
  |  Branch (1369:6): [True: 17.1k, False: 8.47k]
  ------------------
 1370|  17.1k|		break;
 1371|  25.6k|	    }
 1372|  25.6k|	}
 1373|     57|	if(havematch == 1) { /* unique partial match */
  ------------------
  |  Branch (1373:5): [True: 0, False: 57]
  ------------------
 1374|      0|	    if(R_warn_partial_match_dollar) {
  ------------------
  |  Branch (1374:9): [True: 0, False: 0]
  ------------------
 1375|      0|		SEXP target = STRING_ELT(nlist, imatch);
 1376|      0|		SEXP cond =
 1377|      0|		    R_makePartialMatchWarningCondition(call,
 1378|      0|						       input,
 1379|      0|						       target);
 1380|      0|		PROTECT(cond);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1381|      0|		R_signalWarningCondition(cond);
 1382|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1383|      0|	    }
 1384|      0|	    y = VECTOR_ELT(x, imatch);
 1385|      0|	    RAISE_NAMED(y, NAMED(x));
 1386|      0|	    UNPROTECT(2); /* input, x */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1387|      0|	    return y;
 1388|      0|	}
 1389|     57|	UNPROTECT(2); /* input, x */
  ------------------
  |  |  358|     57|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1390|     57|	return R_NilValue;
 1391|     57|    }
 1392|     44|    else if( isEnvironment(x) ){
  ------------------
  |  |  944|     44|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (1392:14): [True: 44, False: 0]
  ------------------
 1393|     44|	y = R_findVarInFrame(x, installTrChar(input));
  ------------------
  |  |  937|     44|#define installTrChar		Rf_installTrChar
  ------------------
 1394|     44|	if( TYPEOF(y) == PROMSXP ) {
  ------------------
  |  |  116|     44|#define PROMSXP	     5	  /* promises: [un]evaluated closure arguments */
  ------------------
  |  Branch (1394:6): [True: 12, False: 32]
  ------------------
 1395|     12|	    PROTECT(y);
  ------------------
  |  |  357|     12|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1396|     12|	    y = eval(y, R_GlobalEnv);
  ------------------
  |  |  913|     12|#define eval			Rf_eval
  ------------------
 1397|     12|	    UNPROTECT(1); /* y */
  ------------------
  |  |  358|     12|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1398|     12|	}
 1399|     44|	UNPROTECT(2); /* input, x */
  ------------------
  |  |  358|     44|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1400|     44|	if( y != R_UnboundValue ) {
  ------------------
  |  Branch (1400:6): [True: 44, False: 0]
  ------------------
 1401|     44|	    if (NAMED(y))
  ------------------
  |  Branch (1401:10): [True: 44, False: 0]
  ------------------
 1402|     44|		ENSURE_NAMEDMAX(y);
 1403|      0|	    else RAISE_NAMED(y, NAMED(x));
 1404|     44|	    return(y);
 1405|     44|	}
 1406|      0|	return R_NilValue;
 1407|     44|    }
 1408|      0|    else if( isVectorAtomic(x) ){
  ------------------
  |  |  975|      0|#define isVectorAtomic		Rf_isVectorAtomic
  ------------------
  |  Branch (1408:14): [True: 0, False: 0]
  ------------------
 1409|      0|	errorcall(call, "$ operator is invalid for atomic vectors");
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
 1410|      0|    }
 1411|      0|    else /* e.g. a function */
 1412|      0|	errorcallNotSubsettable(x, call);
 1413|      0|    UNPROTECT(2); /* input, x */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1414|      0|    return R_NilValue;
 1415|  8.63k|}
subset.c:VECTOR_ELT_FIX_NAMED:
   48|  6.54k|static R_INLINE SEXP VECTOR_ELT_FIX_NAMED(SEXP y, R_xlen_t i) {
   49|       |    /* if RHS (container or element) has NAMED > 0 set NAMED = NAMEDMAX.
   50|       |       Duplicating might be safer/more consistent (fix bug reported by
   51|       |       Radford Neal; similar to PR15098) */
   52|  6.54k|    SEXP val = VECTOR_ELT(y, i);
   53|  6.54k|    if ((NAMED(y) || NAMED(val)))
  ------------------
  |  Branch (53:10): [True: 6.30k, False: 245]
  |  Branch (53:22): [True: 245, False: 0]
  ------------------
   54|  6.54k|	ENSURE_NAMEDMAX(val);
   55|  6.54k|    return val;
   56|  6.54k|}
subset.c:R_DispatchOrEvalSP:
  654|  3.26k|{
  655|  3.26k|    SEXP prom = NULL;
  656|  3.26k|    if (args != R_NilValue && CAR(args) != R_DotsSymbol) {
  ------------------
  |  Branch (656:9): [True: 3.26k, False: 0]
  |  Branch (656:31): [True: 3.26k, False: 0]
  ------------------
  657|  3.26k|	SEXP x = eval(CAR(args), rho);
  ------------------
  |  |  913|  3.26k|#define eval			Rf_eval
  ------------------
  658|  3.26k|	PROTECT(x);
  ------------------
  |  |  357|  3.26k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  659|  3.26k|	INCREMENT_LINKS(x);
  ------------------
  |  |  540|  3.26k|#define INCREMENT_LINKS(x) do {			\
  |  |  541|  3.26k|	SEXP il__x__ = (x);			\
  |  |  542|  3.26k|	INCREMENT_NAMED(il__x__);		\
  |  |  ------------------
  |  |  |  |  222|  3.26k|# define INCREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:43): [Folded, False: 3.26k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  543|  3.26k|	INCREMENT_REFCNT(il__x__);		\
  |  |  544|  3.26k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (544:14): [Folded, False: 3.26k]
  |  |  ------------------
  ------------------
  660|  3.26k|	if (! OBJECT(x)) {
  ------------------
  |  Branch (660:6): [True: 2.43k, False: 824]
  ------------------
  661|  2.43k|	    *ans = CONS_NR(x, evalListKeepMissing(CDR(args), rho));
  ------------------
  |  | 1899|  2.43k|# define evalListKeepMissing	Rf_evalListKeepMissing
  ------------------
  662|  2.43k|	    DECREMENT_LINKS(x);
  ------------------
  |  |  545|  2.43k|#define DECREMENT_LINKS(x) do {			\
  |  |  546|  2.43k|	SEXP dl__x__ = (x);			\
  |  |  547|  2.43k|	DECREMENT_NAMED(dl__x__);		\
  |  |  ------------------
  |  |  |  |  223|  2.43k|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (223:43): [Folded, False: 2.43k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  548|  2.43k|	DECREMENT_REFCNT(dl__x__);		\
  |  |  549|  2.43k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (549:14): [Folded, False: 2.43k]
  |  |  ------------------
  ------------------
  663|  2.43k|	    UNPROTECT(1);
  ------------------
  |  |  358|  2.43k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  664|  2.43k|	    return FALSE;
  665|  2.43k|	}
  666|    824|	prom = R_mkEVPROMISE_NR(CAR(args), x);
  667|    824|	args = CONS(prom, CDR(args));
  ------------------
  |  |  309|    824|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  668|    824|	UNPROTECT(1);
  ------------------
  |  |  358|    824|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  669|    824|    }
  670|    824|    PROTECT(args);
  ------------------
  |  |  357|    824|#define PROTECT(s)	Rf_protect(s)
  ------------------
  671|    824|    int disp = DispatchOrEval(call, op, generic, args, rho, ans, 0, 0);
  ------------------
  |  | 1887|    824|# define DispatchOrEval		Rf_DispatchOrEval
  ------------------
  672|    824|    if (prom) DECREMENT_LINKS(PRVALUE(prom));
  ------------------
  |  |  545|    824|#define DECREMENT_LINKS(x) do {			\
  |  |  546|    824|	SEXP dl__x__ = (x);			\
  |  |  547|    824|	DECREMENT_NAMED(dl__x__);		\
  |  |  ------------------
  |  |  |  |  223|    824|# define DECREMENT_NAMED(x) do { } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (223:43): [Folded, False: 824]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  548|    824|	DECREMENT_REFCNT(dl__x__);		\
  |  |  549|    824|    } while (0)
  |  |  ------------------
  |  |  |  Branch (549:14): [Folded, False: 824]
  |  |  ------------------
  ------------------
  |  Branch (672:9): [True: 824, False: 0]
  ------------------
  673|    824|    UNPROTECT(1);
  ------------------
  |  |  358|    824|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  674|    824|    return disp;
  675|  3.26k|}
subset.c:scalarIndex:
  704|   389k|{
  705|   389k|    if (ATTRIB(s) == R_NilValue) {
  ------------------
  |  Branch (705:9): [True: 389k, False: 2]
  ------------------
  706|   389k|	if (IS_SCALAR(s, INTSXP)) {
  ------------------
  |  |  123|   389k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (706:6): [True: 387k, False: 2.29k]
  ------------------
  707|   387k|	    int ival = SCALAR_IVAL(s);
  708|   387k|	    if (ival != NA_INTEGER)
  ------------------
  |  |   56|   387k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (708:10): [True: 387k, False: 0]
  ------------------
  709|   387k|		return ival;
  710|      0|	    else return -1;
  711|   387k|	}
  712|  2.29k|	else if (IS_SCALAR(s, REALSXP)) {
  ------------------
  |  |  124|  2.29k|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (712:11): [True: 148, False: 2.14k]
  ------------------
  713|    148|	    double rval = SCALAR_DVAL(s);
  714|       |	    // treat infinite indices as NA, like asInteger
  715|    148|	    if (R_FINITE(rval))
  ------------------
  |  |   82|    148|# define R_FINITE(x)    isfinite(x)
  ------------------
  |  Branch (715:10): [True: 148, False: 0]
  ------------------
  716|    148|		return (R_xlen_t) rval;
  717|      0|	    else return -1;
  718|    148|	}
  719|  2.14k|	else return -1;
  720|   389k|    }
  721|      2|    else return -1;
  722|   389k|}
subset.c:ExtractDropArg:
  627|  1.17M|{
  628|  1.17M|    *drop = asLogical(ExtractArg(el, R_DropSymbol));
  ------------------
  |  |  886|  1.17M|#define asLogical		Rf_asLogical
  ------------------
  629|  1.17M|    if (*drop == NA_LOGICAL) *drop = 1;
  ------------------
  |  |   55|  1.17M|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (629:9): [True: 1.17M, False: 40]
  ------------------
  630|  1.17M|}
subset.c:ExtractArg:
  606|  1.94M|{
  607|  1.94M|    SEXP arg, prev_arg;
  608|  1.94M|    int found = 0;
  609|       |
  610|  6.62M|    for (arg = prev_arg = args; arg != R_NilValue; arg = CDR(arg)) {
  ------------------
  |  Branch (610:33): [True: 5.44M, False: 1.17M]
  ------------------
  611|  5.44M|	if(TAG(arg) == arg_sym) {
  ------------------
  |  Branch (611:5): [True: 770k, False: 4.67M]
  ------------------
  612|   770k|	    if (arg == prev_arg) /* found at head of args */
  ------------------
  |  Branch (612:10): [True: 0, False: 770k]
  ------------------
  613|      0|		args = CDR(args);
  614|   770k|	    else
  615|   770k|		SETCDR(prev_arg, CDR(arg));
  616|   770k|	    found = 1;
  617|   770k|	    break;
  618|   770k|	}
  619|  4.67M|	else  prev_arg = arg;
  620|  5.44M|    }
  621|  1.94M|    return found ? CAR(arg) : R_NilValue;
  ------------------
  |  Branch (621:12): [True: 770k, False: 1.17M]
  ------------------
  622|  1.94M|}
subset.c:VectorSubset:
  184|   389k|{
  185|   389k|    if (s == R_MissingArg) return duplicate(x);
  ------------------
  |  |  909|      0|#define duplicate		Rf_duplicate
  ------------------
  |  Branch (185:9): [True: 0, False: 389k]
  ------------------
  186|       |
  187|       |    /* Check to see if we have special matrix subscripting. */
  188|       |    /* If we do, make a real subscript vector and protect it. */
  189|       |
  190|   389k|    PROTECT(s);
  ------------------
  |  |  357|   389k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  191|   389k|    if (ATTRIB(s) != R_NilValue) { /* pretest to speed up simple case */
  ------------------
  |  Branch (191:9): [True: 508, False: 389k]
  ------------------
  192|    508|	SEXP dim = getAttrib(x, R_DimSymbol);
  ------------------
  |  |  924|    508|#define getAttrib		Rf_getAttrib
  ------------------
  193|    508|	if (isMatrix(s) && isArray(x) && ncols(s) == length(dim)) {
  ------------------
  |  |  954|    508|#define isMatrix		Rf_isMatrix
  ------------------
              	if (isMatrix(s) && isArray(x) && ncols(s) == length(dim)) {
  ------------------
  |  |  940|      0|#define isArray			Rf_isArray
  ------------------
              	if (isMatrix(s) && isArray(x) && ncols(s) == length(dim)) {
  ------------------
  |  | 1005|      0|#define ncols			Rf_ncols
  ------------------
              	if (isMatrix(s) && isArray(x) && ncols(s) == length(dim)) {
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (193:6): [True: 0, False: 508]
  |  Branch (193:21): [True: 0, False: 0]
  |  Branch (193:35): [True: 0, False: 0]
  ------------------
  194|      0|	    if (isString(s)) {
  ------------------
  |  |  966|      0|#define isString		Rf_isString
  ------------------
  |  Branch (194:10): [True: 0, False: 0]
  ------------------
  195|      0|		SEXP dnames = PROTECT(GetArrayDimnames(x));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  196|      0| 		s = strmat2intmat(s, dnames, call, x);
  ------------------
  |  | 1995|      0|# define strmat2intmat		Rf_strmat2intmat
  ------------------
  197|      0|		UNPROTECT(2); /* dnames, s */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  198|      0|		PROTECT(s);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  199|      0|	    }
  200|      0|	    if (isInteger(s) || isReal(s)) {
  ------------------
  |  |  949|      0|#define isInteger		Rf_isInteger
  ------------------
              	    if (isInteger(s) || isReal(s)) {
  ------------------
  |  |  963|      0|#define isReal			Rf_isReal
  ------------------
  |  Branch (200:10): [True: 0, False: 0]
  |  Branch (200:26): [True: 0, False: 0]
  ------------------
  201|      0|		s = mat2indsub(dim, s, call, x);
  ------------------
  |  | 1943|      0|# define mat2indsub		Rf_mat2indsub
  ------------------
  202|      0|		UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  203|      0|		PROTECT(s);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  204|      0|	    }
  205|      0|	}
  206|    508|    }
  207|       |
  208|       |    /* Convert to a vector of integer subscripts */
  209|       |    /* in the range 1:length(x). */
  210|   389k|    R_xlen_t stretch = 1;
  211|   389k|    SEXP indx = PROTECT(makeSubscript(x, s, &stretch, call));
  ------------------
  |  |  357|   389k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  212|       |
  213|       |    /* Allocate the result. */
  214|       |
  215|   389k|    int mode = TYPEOF(x);
  216|   389k|    SEXP result = PROTECT(ExtractSubset(x, indx, call));
  ------------------
  |  |  357|   389k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  217|   389k|    if (mode == VECSXP || mode == EXPRSXP)
  ------------------
  |  |  131|   779k|#define VECSXP	    19	  /* generic vectors */
  ------------------
                  if (mode == VECSXP || mode == EXPRSXP)
  ------------------
  |  |  132|   389k|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (217:9): [True: 190, False: 389k]
  |  Branch (217:27): [True: 12, False: 389k]
  ------------------
  218|       |	/* we do not duplicate the values when extracting the subset,
  219|       |	   so to be conservative mark the result as NAMED = NAMEDMAX */
  220|    202|	ENSURE_NAMEDMAX(result);
  221|       |
  222|   389k|    if (result != R_NilValue) {
  ------------------
  |  Branch (222:9): [True: 389k, False: 0]
  ------------------
  223|   389k|	SEXP attrib, nattrib;
  224|   389k|	if (
  225|   389k|	    ((attrib = getAttrib(x, R_NamesSymbol)) != R_NilValue) ||
  ------------------
  |  |  924|   389k|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (225:6): [True: 765, False: 389k]
  ------------------
  226|   389k|	    ( /* here we might have an array.  Use row names if 1D */
  227|   389k|		isArray(x) && length(getAttrib(x, R_DimNamesSymbol)) == 1 &&
  ------------------
  |  |  940|   389k|#define isArray			Rf_isArray
  ------------------
              		isArray(x) && length(getAttrib(x, R_DimNamesSymbol)) == 1 &&
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (227:3): [True: 0, False: 389k]
  |  Branch (227:17): [True: 0, False: 0]
  ------------------
  228|      0|		(attrib = getAttrib(x, R_DimNamesSymbol)) != R_NilValue &&
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (228:3): [True: 0, False: 0]
  ------------------
  229|      0|		(attrib = GetRowNames(attrib)) != R_NilValue
  ------------------
  |  |  931|      0|#define GetRowNames		Rf_GetRowNames
  ------------------
  |  Branch (229:3): [True: 0, False: 0]
  ------------------
  230|   389k|		)
  231|   389k|	    ) {
  232|    765|	    PROTECT(attrib);
  ------------------
  |  |  357|    765|#define PROTECT(s)	Rf_protect(s)
  ------------------
  233|    765|	    PROTECT(nattrib = ExtractSubset(attrib, indx, call));
  ------------------
  |  |  357|    765|#define PROTECT(s)	Rf_protect(s)
  ------------------
  234|    765|	    setAttrib(result, R_NamesSymbol, nattrib);
  ------------------
  |  | 1027|    765|#define setAttrib		Rf_setAttrib
  ------------------
  235|    765|	    UNPROTECT(2); /* attrib, nattrib */
  ------------------
  |  |  358|    765|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  236|    765|	}
  237|   389k|	if ((attrib = getAttrib(x, R_SrcrefSymbol)) != R_NilValue &&
  ------------------
  |  |  924|   389k|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (237:6): [True: 0, False: 389k]
  ------------------
  238|      0|	    TYPEOF(attrib) == VECSXP) {
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (238:6): [True: 0, False: 0]
  ------------------
  239|      0|	    PROTECT(nattrib = ExtractSubset(attrib, indx, call));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  240|      0|	    setAttrib(result, R_SrcrefSymbol, nattrib);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
  241|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  242|      0|	}
  243|       |	/* FIXME:  this is wrong, because the slots are gone, so result is an invalid object of the S4 class! JMC 3/3/09 */
  244|       |#ifdef _S4_subsettable
  245|       |	if(IS_S4_OBJECT(x)) { /* e.g. contains = "list" */
  246|       |	    setAttrib(result, R_ClassSymbol, getAttrib(x, R_ClassSymbol));
  247|       |	    SET_S4_OBJECT(result);
  248|       |	}
  249|       |#endif
  250|   389k|    }
  251|   389k|    UNPROTECT(3);
  ------------------
  |  |  358|   389k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  252|   389k|    return result;
  253|   389k|}
subset.c:MatrixSubset:
  309|  2.41k|{
  310|  2.41k|    SEXP attr, result, sr, sc, dim;
  311|  2.41k|    int nr, nc, nrs, ncs;
  312|  2.41k|    R_xlen_t i, j, ii, jj, ij, iijj;
  313|       |
  314|  2.41k|    nr = nrows(x);
  ------------------
  |  | 1008|  2.41k|#define nrows			Rf_nrows
  ------------------
  315|  2.41k|    nc = ncols(x);
  ------------------
  |  | 1005|  2.41k|#define ncols			Rf_ncols
  ------------------
  316|       |
  317|       |    /* Note that "s" is protected on entry. */
  318|       |    /* The following ensures that pointers remain protected. */
  319|  2.41k|    dim = getAttrib(x, R_DimSymbol);
  ------------------
  |  |  924|  2.41k|#define getAttrib		Rf_getAttrib
  ------------------
  320|       |
  321|  2.41k|    sr = SETCAR (s, int_arraySubscript(0, CAR(s),  dim, x, call));
  322|  2.41k|    sc = SETCADR(s, int_arraySubscript(1, CADR(s), dim, x, call));
  323|  2.41k|    nrs = LENGTH(sr);
  324|  2.41k|    ncs = LENGTH(sc);
  325|       |    /* Check this does not overflow: currently only possible on 32-bit */
  326|  2.41k|    if ((double)nrs * (double)ncs > R_XLEN_T_MAX)
  ------------------
  |  |   76|  2.41k|# define R_XLEN_T_MAX 4503599627370496
  ------------------
  |  Branch (326:9): [True: 0, False: 2.41k]
  ------------------
  327|      0|	error(_("dimensions would exceed maximum size of array"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("dimensions would exceed maximum size of array"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  328|  2.41k|    PROTECT(sr);
  ------------------
  |  |  357|  2.41k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  329|  2.41k|    PROTECT(sc);
  ------------------
  |  |  357|  2.41k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  330|  2.41k|    result = allocVector(TYPEOF(x), (R_xlen_t) nrs * (R_xlen_t) ncs);
  ------------------
  |  |  875|  2.41k|#define allocVector		Rf_allocVector
  ------------------
  331|  2.41k|    const int *psr = INTEGER_RO(sr);
  332|  2.41k|    const int *psc = INTEGER_RO(sc);
  333|  2.41k|    PROTECT(result);
  ------------------
  |  |  357|  2.41k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  334|  2.41k|    switch(TYPEOF(x)) {
  335|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (335:5): [True: 0, False: 2.41k]
  ------------------
  336|      0|	MATRIX_SUBSET_LOOP(LOGICAL0(result)[ij] = LOGICAL_ELT(x, iijj),
  ------------------
  |  |  282|      0|#define MATRIX_SUBSET_LOOP(STDCODE, NACODE) do {		\
  |  |  283|      0|	for (j = 0; j < ncs; j++) {				\
  |  |  ------------------
  |  |  |  Branch (283:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  284|      0|	    jj = psc[j];					\
  |  |  285|      0|	    if (jj != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (285:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|		if (jj < 1 || jj > nc)				\
  |  |  ------------------
  |  |  |  Branch (286:7): [True: 0, False: 0]
  |  |  |  Branch (286:17): [True: 0, False: 0]
  |  |  ------------------
  |  |  287|      0|		    errorcallOutOfBounds(x, 0, jj, call);	\
  |  |  288|      0|		jj--;						\
  |  |  289|      0|	    }							\
  |  |  290|      0|	    for (i = 0; i < nrs; i++) {				\
  |  |  ------------------
  |  |  |  Branch (290:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  291|      0|		ii = psr[i];					\
  |  |  292|      0|		if (ii != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (292:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  293|      0|		    if (ii < 1 || ii > nr)			\
  |  |  ------------------
  |  |  |  Branch (293:11): [True: 0, False: 0]
  |  |  |  Branch (293:21): [True: 0, False: 0]
  |  |  ------------------
  |  |  294|      0|			errorcallOutOfBounds(x, 1, ii, call);	\
  |  |  295|      0|		    ii--;					\
  |  |  296|      0|		}						\
  |  |  297|      0|		ij = i + j * nrs;				\
  |  |  298|      0|		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (298:7): [True: 0, False: 0]
  |  |  |  Branch (298:27): [True: 0, False: 0]
  |  |  ------------------
  |  |  299|      0|		    NACODE;					\
  |  |  300|      0|		else {						\
  |  |  301|      0|		    iijj = ii + jj * nr;			\
  |  |  302|      0|		    STDCODE;					\
  |  |  303|      0|		}						\
  |  |  304|      0|	    }							\
  |  |  305|      0|	}							\
  |  |  306|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (306:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  337|      0|			   LOGICAL0(result)[ij] = NA_LOGICAL);
  338|      0|	break;
  339|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (339:5): [True: 0, False: 2.41k]
  ------------------
  340|      0|	MATRIX_SUBSET_LOOP(INTEGER0(result)[ij] = INTEGER_ELT(x, iijj),
  ------------------
  |  |  282|      0|#define MATRIX_SUBSET_LOOP(STDCODE, NACODE) do {		\
  |  |  283|      0|	for (j = 0; j < ncs; j++) {				\
  |  |  ------------------
  |  |  |  Branch (283:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  284|      0|	    jj = psc[j];					\
  |  |  285|      0|	    if (jj != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (285:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|		if (jj < 1 || jj > nc)				\
  |  |  ------------------
  |  |  |  Branch (286:7): [True: 0, False: 0]
  |  |  |  Branch (286:17): [True: 0, False: 0]
  |  |  ------------------
  |  |  287|      0|		    errorcallOutOfBounds(x, 0, jj, call);	\
  |  |  288|      0|		jj--;						\
  |  |  289|      0|	    }							\
  |  |  290|      0|	    for (i = 0; i < nrs; i++) {				\
  |  |  ------------------
  |  |  |  Branch (290:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  291|      0|		ii = psr[i];					\
  |  |  292|      0|		if (ii != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (292:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  293|      0|		    if (ii < 1 || ii > nr)			\
  |  |  ------------------
  |  |  |  Branch (293:11): [True: 0, False: 0]
  |  |  |  Branch (293:21): [True: 0, False: 0]
  |  |  ------------------
  |  |  294|      0|			errorcallOutOfBounds(x, 1, ii, call);	\
  |  |  295|      0|		    ii--;					\
  |  |  296|      0|		}						\
  |  |  297|      0|		ij = i + j * nrs;				\
  |  |  298|      0|		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (298:7): [True: 0, False: 0]
  |  |  |  Branch (298:27): [True: 0, False: 0]
  |  |  ------------------
  |  |  299|      0|		    NACODE;					\
  |  |  300|      0|		else {						\
  |  |  301|      0|		    iijj = ii + jj * nr;			\
  |  |  302|      0|		    STDCODE;					\
  |  |  303|      0|		}						\
  |  |  304|      0|	    }							\
  |  |  305|      0|	}							\
  |  |  306|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (306:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  341|      0|			   INTEGER0(result)[ij] = NA_INTEGER);
  342|      0|	break;
  343|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (343:5): [True: 0, False: 2.41k]
  ------------------
  344|      0|	MATRIX_SUBSET_LOOP(REAL0(result)[ij] = REAL_ELT(x, iijj),
  ------------------
  |  |  282|      0|#define MATRIX_SUBSET_LOOP(STDCODE, NACODE) do {		\
  |  |  283|      0|	for (j = 0; j < ncs; j++) {				\
  |  |  ------------------
  |  |  |  Branch (283:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  284|      0|	    jj = psc[j];					\
  |  |  285|      0|	    if (jj != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (285:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|		if (jj < 1 || jj > nc)				\
  |  |  ------------------
  |  |  |  Branch (286:7): [True: 0, False: 0]
  |  |  |  Branch (286:17): [True: 0, False: 0]
  |  |  ------------------
  |  |  287|      0|		    errorcallOutOfBounds(x, 0, jj, call);	\
  |  |  288|      0|		jj--;						\
  |  |  289|      0|	    }							\
  |  |  290|      0|	    for (i = 0; i < nrs; i++) {				\
  |  |  ------------------
  |  |  |  Branch (290:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  291|      0|		ii = psr[i];					\
  |  |  292|      0|		if (ii != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (292:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  293|      0|		    if (ii < 1 || ii > nr)			\
  |  |  ------------------
  |  |  |  Branch (293:11): [True: 0, False: 0]
  |  |  |  Branch (293:21): [True: 0, False: 0]
  |  |  ------------------
  |  |  294|      0|			errorcallOutOfBounds(x, 1, ii, call);	\
  |  |  295|      0|		    ii--;					\
  |  |  296|      0|		}						\
  |  |  297|      0|		ij = i + j * nrs;				\
  |  |  298|      0|		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (298:7): [True: 0, False: 0]
  |  |  |  Branch (298:27): [True: 0, False: 0]
  |  |  ------------------
  |  |  299|      0|		    NACODE;					\
  |  |  300|      0|		else {						\
  |  |  301|      0|		    iijj = ii + jj * nr;			\
  |  |  302|      0|		    STDCODE;					\
  |  |  303|      0|		}						\
  |  |  304|      0|	    }							\
  |  |  305|      0|	}							\
  |  |  306|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (306:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  345|      0|			   REAL0(result)[ij] = NA_REAL);
  346|      0|	break;
  347|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (347:5): [True: 0, False: 2.41k]
  ------------------
  348|      0|	{
  349|      0|	    Rcomplex NA_CPLX = { .r = NA_REAL, .i = NA_REAL };
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
              	    Rcomplex NA_CPLX = { .r = NA_REAL, .i = NA_REAL };
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  350|      0|	    MATRIX_SUBSET_LOOP(COMPLEX0(result)[ij] = COMPLEX_ELT(x, iijj),
  ------------------
  |  |  282|      0|#define MATRIX_SUBSET_LOOP(STDCODE, NACODE) do {		\
  |  |  283|      0|	for (j = 0; j < ncs; j++) {				\
  |  |  ------------------
  |  |  |  Branch (283:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  284|      0|	    jj = psc[j];					\
  |  |  285|      0|	    if (jj != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (285:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|		if (jj < 1 || jj > nc)				\
  |  |  ------------------
  |  |  |  Branch (286:7): [True: 0, False: 0]
  |  |  |  Branch (286:17): [True: 0, False: 0]
  |  |  ------------------
  |  |  287|      0|		    errorcallOutOfBounds(x, 0, jj, call);	\
  |  |  288|      0|		jj--;						\
  |  |  289|      0|	    }							\
  |  |  290|      0|	    for (i = 0; i < nrs; i++) {				\
  |  |  ------------------
  |  |  |  Branch (290:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  291|      0|		ii = psr[i];					\
  |  |  292|      0|		if (ii != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (292:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  293|      0|		    if (ii < 1 || ii > nr)			\
  |  |  ------------------
  |  |  |  Branch (293:11): [True: 0, False: 0]
  |  |  |  Branch (293:21): [True: 0, False: 0]
  |  |  ------------------
  |  |  294|      0|			errorcallOutOfBounds(x, 1, ii, call);	\
  |  |  295|      0|		    ii--;					\
  |  |  296|      0|		}						\
  |  |  297|      0|		ij = i + j * nrs;				\
  |  |  298|      0|		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (298:7): [True: 0, False: 0]
  |  |  |  Branch (298:27): [True: 0, False: 0]
  |  |  ------------------
  |  |  299|      0|		    NACODE;					\
  |  |  300|      0|		else {						\
  |  |  301|      0|		    iijj = ii + jj * nr;			\
  |  |  302|      0|		    STDCODE;					\
  |  |  303|      0|		}						\
  |  |  304|      0|	    }							\
  |  |  305|      0|	}							\
  |  |  306|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (306:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  351|      0|			       COMPLEX0(result)[ij] = NA_CPLX);
  352|      0|	}
  353|      0|	break;
  354|  2.41k|    case STRSXP:
  ------------------
  |  |  126|  2.41k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (354:5): [True: 2.41k, False: 0]
  ------------------
  355|  2.41k|	MATRIX_SUBSET_LOOP(SET_STRING_ELT(result, ij, STRING_ELT(x, iijj)),
  ------------------
  |  |  282|  2.41k|#define MATRIX_SUBSET_LOOP(STDCODE, NACODE) do {		\
  |  |  283|  4.96k|	for (j = 0; j < ncs; j++) {				\
  |  |  ------------------
  |  |  |  Branch (283:14): [True: 2.55k, False: 2.41k]
  |  |  ------------------
  |  |  284|  2.55k|	    jj = psc[j];					\
  |  |  285|  2.55k|	    if (jj != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|  2.55k|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (285:10): [True: 2.55k, False: 0]
  |  |  ------------------
  |  |  286|  2.55k|		if (jj < 1 || jj > nc)				\
  |  |  ------------------
  |  |  |  Branch (286:7): [True: 0, False: 2.55k]
  |  |  |  Branch (286:17): [True: 0, False: 2.55k]
  |  |  ------------------
  |  |  287|  2.55k|		    errorcallOutOfBounds(x, 0, jj, call);	\
  |  |  288|  2.55k|		jj--;						\
  |  |  289|  2.55k|	    }							\
  |  |  290|  34.4k|	    for (i = 0; i < nrs; i++) {				\
  |  |  ------------------
  |  |  |  Branch (290:18): [True: 31.8k, False: 2.55k]
  |  |  ------------------
  |  |  291|  31.8k|		ii = psr[i];					\
  |  |  292|  31.8k|		if (ii != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|  31.8k|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (292:7): [True: 31.8k, False: 0]
  |  |  ------------------
  |  |  293|  31.8k|		    if (ii < 1 || ii > nr)			\
  |  |  ------------------
  |  |  |  Branch (293:11): [True: 0, False: 31.8k]
  |  |  |  Branch (293:21): [True: 0, False: 31.8k]
  |  |  ------------------
  |  |  294|  31.8k|			errorcallOutOfBounds(x, 1, ii, call);	\
  |  |  295|  31.8k|		    ii--;					\
  |  |  296|  31.8k|		}						\
  |  |  297|  31.8k|		ij = i + j * nrs;				\
  |  |  298|  31.8k|		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|  63.7k|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|  31.8k|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (298:7): [True: 0, False: 31.8k]
  |  |  |  Branch (298:27): [True: 0, False: 31.8k]
  |  |  ------------------
  |  |  299|  31.8k|		    NACODE;					\
  |  |  300|  31.8k|		else {						\
  |  |  301|  31.8k|		    iijj = ii + jj * nr;			\
  |  |  302|  31.8k|		    STDCODE;					\
  |  |  303|  31.8k|		}						\
  |  |  304|  31.8k|	    }							\
  |  |  305|  2.55k|	}							\
  |  |  306|  2.41k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (306:14): [Folded, False: 2.41k]
  |  |  ------------------
  ------------------
  356|  2.41k|			   SET_STRING_ELT(result, ij, NA_STRING));
  357|  2.41k|	break;
  358|      0|    case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (358:5): [True: 0, False: 2.41k]
  ------------------
  359|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (359:5): [True: 0, False: 2.41k]
  ------------------
  360|      0|	MATRIX_SUBSET_LOOP(SET_VECTOR_ELT(result, ij,
  ------------------
  |  |  282|      0|#define MATRIX_SUBSET_LOOP(STDCODE, NACODE) do {		\
  |  |  283|      0|	for (j = 0; j < ncs; j++) {				\
  |  |  ------------------
  |  |  |  Branch (283:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  284|      0|	    jj = psc[j];					\
  |  |  285|      0|	    if (jj != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (285:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|		if (jj < 1 || jj > nc)				\
  |  |  ------------------
  |  |  |  Branch (286:7): [True: 0, False: 0]
  |  |  |  Branch (286:17): [True: 0, False: 0]
  |  |  ------------------
  |  |  287|      0|		    errorcallOutOfBounds(x, 0, jj, call);	\
  |  |  288|      0|		jj--;						\
  |  |  289|      0|	    }							\
  |  |  290|      0|	    for (i = 0; i < nrs; i++) {				\
  |  |  ------------------
  |  |  |  Branch (290:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  291|      0|		ii = psr[i];					\
  |  |  292|      0|		if (ii != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (292:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  293|      0|		    if (ii < 1 || ii > nr)			\
  |  |  ------------------
  |  |  |  Branch (293:11): [True: 0, False: 0]
  |  |  |  Branch (293:21): [True: 0, False: 0]
  |  |  ------------------
  |  |  294|      0|			errorcallOutOfBounds(x, 1, ii, call);	\
  |  |  295|      0|		    ii--;					\
  |  |  296|      0|		}						\
  |  |  297|      0|		ij = i + j * nrs;				\
  |  |  298|      0|		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (298:7): [True: 0, False: 0]
  |  |  |  Branch (298:27): [True: 0, False: 0]
  |  |  ------------------
  |  |  299|      0|		    NACODE;					\
  |  |  300|      0|		else {						\
  |  |  301|      0|		    iijj = ii + jj * nr;			\
  |  |  302|      0|		    STDCODE;					\
  |  |  303|      0|		}						\
  |  |  304|      0|	    }							\
  |  |  305|      0|	}							\
  |  |  306|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (306:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  361|      0|					  VECTOR_ELT_FIX_NAMED(x, iijj)),
  362|      0|			   SET_VECTOR_ELT(result, ij, R_NilValue));
  363|      0|	break;
  364|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (364:5): [True: 0, False: 2.41k]
  ------------------
  365|      0|	MATRIX_SUBSET_LOOP(RAW0(result)[ij] = RAW_ELT(x, iijj),
  ------------------
  |  |  282|      0|#define MATRIX_SUBSET_LOOP(STDCODE, NACODE) do {		\
  |  |  283|      0|	for (j = 0; j < ncs; j++) {				\
  |  |  ------------------
  |  |  |  Branch (283:14): [True: 0, False: 0]
  |  |  ------------------
  |  |  284|      0|	    jj = psc[j];					\
  |  |  285|      0|	    if (jj != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (285:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|		if (jj < 1 || jj > nc)				\
  |  |  ------------------
  |  |  |  Branch (286:7): [True: 0, False: 0]
  |  |  |  Branch (286:17): [True: 0, False: 0]
  |  |  ------------------
  |  |  287|      0|		    errorcallOutOfBounds(x, 0, jj, call);	\
  |  |  288|      0|		jj--;						\
  |  |  289|      0|	    }							\
  |  |  290|      0|	    for (i = 0; i < nrs; i++) {				\
  |  |  ------------------
  |  |  |  Branch (290:18): [True: 0, False: 0]
  |  |  ------------------
  |  |  291|      0|		ii = psr[i];					\
  |  |  292|      0|		if (ii != NA_INTEGER) {				\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (292:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  293|      0|		    if (ii < 1 || ii > nr)			\
  |  |  ------------------
  |  |  |  Branch (293:11): [True: 0, False: 0]
  |  |  |  Branch (293:21): [True: 0, False: 0]
  |  |  ------------------
  |  |  294|      0|			errorcallOutOfBounds(x, 1, ii, call);	\
  |  |  295|      0|		    ii--;					\
  |  |  296|      0|		}						\
  |  |  297|      0|		ij = i + j * nrs;				\
  |  |  298|      0|		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               		if (ii == NA_INTEGER || jj == NA_INTEGER)	\
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |  |  Branch (298:7): [True: 0, False: 0]
  |  |  |  Branch (298:27): [True: 0, False: 0]
  |  |  ------------------
  |  |  299|      0|		    NACODE;					\
  |  |  300|      0|		else {						\
  |  |  301|      0|		    iijj = ii + jj * nr;			\
  |  |  302|      0|		    STDCODE;					\
  |  |  303|      0|		}						\
  |  |  304|      0|	    }							\
  |  |  305|      0|	}							\
  |  |  306|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (306:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
  366|      0|			   RAW0(result)[ij] = (Rbyte) 0);
  367|      0|	break;
  368|      0|    default:
  ------------------
  |  Branch (368:5): [True: 0, False: 2.41k]
  ------------------
  369|      0|	errorcall(call, _("matrix subscripting not handled for this type"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("matrix subscripting not handled for this type"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  370|      0|	break;
  371|  2.41k|    }
  372|       |
  373|  2.41k|    if(nrs >= 0 && ncs >= 0) {
  ------------------
  |  Branch (373:8): [True: 2.41k, False: 0]
  |  Branch (373:20): [True: 2.41k, False: 0]
  ------------------
  374|  2.41k|	PROTECT(attr = allocVector(INTSXP, 2));
  ------------------
  |  |  357|  2.41k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  375|  2.41k|	INTEGER0(attr)[0] = nrs;
  376|  2.41k|	INTEGER0(attr)[1] = ncs;
  377|  2.41k|	if(!isNull(getAttrib(dim, R_NamesSymbol)))
  ------------------
  |  |  956|  2.41k|#define isNull			Rf_isNull
  ------------------
              	if(!isNull(getAttrib(dim, R_NamesSymbol)))
  ------------------
  |  |  924|  2.41k|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (377:5): [True: 0, False: 2.41k]
  ------------------
  378|      0|	    setAttrib(attr, R_NamesSymbol, getAttrib(dim, R_NamesSymbol));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              	    setAttrib(attr, R_NamesSymbol, getAttrib(dim, R_NamesSymbol));
  ------------------
  |  |  924|      0|#define getAttrib		Rf_getAttrib
  ------------------
  379|  2.41k|	setAttrib(result, R_DimSymbol, attr);
  ------------------
  |  | 1027|  2.41k|#define setAttrib		Rf_setAttrib
  ------------------
  380|  2.41k|	UNPROTECT(1);
  ------------------
  |  |  358|  2.41k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  381|  2.41k|    }
  382|       |
  383|       |    /* The matrix elements have been transferred.  Now we need to */
  384|       |    /* transfer the attributes.	 Most importantly, we need to subset */
  385|       |    /* the dimnames of the returned value. */
  386|       |
  387|  2.41k|    if (nrs >= 0 && ncs >= 0) {
  ------------------
  |  Branch (387:9): [True: 2.41k, False: 0]
  |  Branch (387:21): [True: 2.41k, False: 0]
  ------------------
  388|  2.41k|	SEXP dimnames, dimnamesnames, newdimnames;
  389|  2.41k|	dimnames = getAttrib(x, R_DimNamesSymbol);
  ------------------
  |  |  924|  2.41k|#define getAttrib		Rf_getAttrib
  ------------------
  390|  2.41k|	PROTECT(dimnamesnames = getAttrib(dimnames, R_NamesSymbol));
  ------------------
  |  |  357|  2.41k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  391|  2.41k|	if (!isNull(dimnames)) {
  ------------------
  |  |  956|  2.41k|#define isNull			Rf_isNull
  ------------------
  |  Branch (391:6): [True: 2.36k, False: 48]
  ------------------
  392|  2.36k|	    PROTECT(newdimnames = allocVector(VECSXP, 2));
  ------------------
  |  |  357|  2.36k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  393|  2.36k|	    if (TYPEOF(dimnames) == VECSXP) {
  ------------------
  |  |  131|  2.36k|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (393:10): [True: 2.36k, False: 0]
  ------------------
  394|  2.36k|	      SET_VECTOR_ELT(newdimnames, 0,
  395|  2.36k|		    ExtractSubset(VECTOR_ELT(dimnames, 0), sr, call));
  ------------------
  |  |  914|  2.36k|#define ExtractSubset		Rf_ExtractSubset
  ------------------
  396|  2.36k|	      SET_VECTOR_ELT(newdimnames, 1,
  397|  2.36k|		    ExtractSubset(VECTOR_ELT(dimnames, 1), sc, call));
  ------------------
  |  |  914|  2.36k|#define ExtractSubset		Rf_ExtractSubset
  ------------------
  398|  2.36k|	    }
  399|      0|	    else {
  400|      0|	      SET_VECTOR_ELT(newdimnames, 0,
  401|      0|		    ExtractSubset(CAR(dimnames), sr, call));
  ------------------
  |  |  914|      0|#define ExtractSubset		Rf_ExtractSubset
  ------------------
  402|      0|	      SET_VECTOR_ELT(newdimnames, 1,
  403|      0|		    ExtractSubset(CADR(dimnames), sc, call));
  ------------------
  |  |  914|      0|#define ExtractSubset		Rf_ExtractSubset
  ------------------
  404|      0|	    }
  405|  2.36k|	    setAttrib(newdimnames, R_NamesSymbol, dimnamesnames);
  ------------------
  |  | 1027|  2.36k|#define setAttrib		Rf_setAttrib
  ------------------
  406|  2.36k|	    setAttrib(result, R_DimNamesSymbol, newdimnames);
  ------------------
  |  | 1027|  2.36k|#define setAttrib		Rf_setAttrib
  ------------------
  407|  2.36k|	    UNPROTECT(1); /* newdimnames */
  ------------------
  |  |  358|  2.36k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  408|  2.36k|	}
  409|  2.41k|	UNPROTECT(1); /* dimnamesnames */
  ------------------
  |  |  358|  2.41k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  410|  2.41k|    }
  411|       |    /*  Probably should not do this:
  412|       |    copyMostAttrib(x, result); */
  413|  2.41k|    if (drop)
  ------------------
  |  Branch (413:9): [True: 2.37k, False: 40]
  ------------------
  414|  2.37k|	DropDims(result);
  ------------------
  |  |  908|  2.37k|#define DropDims                Rf_DropDims
  ------------------
  415|  2.41k|    UNPROTECT(3);
  ------------------
  |  |  358|  2.41k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  416|  2.41k|    return result;
  417|  2.41k|}
subset.c:ExtractExactArg:
  641|   778k|{
  642|   778k|    SEXP argval = ExtractArg(args, R_ExactSymbol);
  643|   778k|    if(isNull(argval)) return 1; /* Default is true as from R 2.7.0 */
  ------------------
  |  |  956|   778k|#define isNull			Rf_isNull
  ------------------
  |  Branch (643:8): [True: 7.84k, False: 770k]
  ------------------
  644|   770k|    int exact = asLogical(argval);
  ------------------
  |  |  886|   770k|#define asLogical		Rf_asLogical
  ------------------
  645|   770k|    if (exact == NA_LOGICAL) exact = -1;
  ------------------
  |  |   55|   770k|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (645:9): [True: 0, False: 770k]
  ------------------
  646|   770k|    return exact;
  647|   778k|}
subset.c:pstrmatch:
 1181|  25.6k|{
 1182|  25.6k|    const char *st = "";
 1183|  25.6k|    const char *si = "";
 1184|  25.6k|    const void *vmax = vmaxget();
 1185|       |
 1186|  25.6k|    if(target == R_NilValue)
  ------------------
  |  Branch (1186:8): [True: 0, False: 25.6k]
  ------------------
 1187|      0|	return NO_MATCH;
 1188|       |
 1189|  25.6k|    switch (TYPEOF(target)) {
  ------------------
  |  Branch (1189:13): [True: 25.6k, False: 0]
  ------------------
 1190|      0|    case SYMSXP:
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (1190:5): [True: 0, False: 25.6k]
  ------------------
 1191|      0|	st = CHAR(PRINTNAME(target));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1192|      0|	break;
 1193|  25.6k|    case CHARSXP:
  ------------------
  |  |  120|  25.6k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (1193:5): [True: 25.6k, False: 0]
  ------------------
 1194|  25.6k|	st = translateChar(target);
  ------------------
  |  | 1037|  25.6k|#define translateChar		Rf_translateChar
  ------------------
 1195|  25.6k|	break;
 1196|  25.6k|    }
 1197|  25.6k|    si = translateChar(input);
  ------------------
  |  | 1037|  25.6k|#define translateChar		Rf_translateChar
  ------------------
 1198|  25.6k|    if(si[0] != '\0' && strncmp(st, si, slen) == 0) {
  ------------------
  |  Branch (1198:8): [True: 25.6k, False: 0]
  |  Branch (1198:25): [True: 8.47k, False: 17.1k]
  ------------------
 1199|  8.47k|	vmaxset(vmax);
 1200|  8.47k|	return (strlen(st) == slen) ?  EXACT_MATCH : PARTIAL_MATCH;
  ------------------
  |  Branch (1200:9): [True: 8.47k, False: 0]
  ------------------
 1201|  17.1k|    } else {
 1202|  17.1k|	vmaxset(vmax);
 1203|  17.1k|	return NO_MATCH;
 1204|  17.1k|    }
 1205|  25.6k|}

fixup_NaRm:
  411|  1.54M|{
  412|       |    /* Need to make sure na.rm is last and exists */
  413|  1.54M|    SEXP na_value = ScalarLogical(FALSE);
  ------------------
  |  | 1023|  1.54M|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  414|  1.54M|    bool seen_NaRm = false;
  415|  3.08M|    for(SEXP a = args, prev = R_NilValue; a != R_NilValue; a = CDR(a)) {
  ------------------
  |  Branch (415:43): [True: 1.54M, False: 1.54M]
  ------------------
  416|  1.54M|	if(TAG(a) == R_NaRmSymbol) {
  ------------------
  |  Branch (416:5): [True: 0, False: 1.54M]
  ------------------
  417|      0|	    if(seen_NaRm)
  ------------------
  |  Branch (417:9): [True: 0, False: 0]
  ------------------
  418|      0|	        error(_("formal argument \"%s\" matched by multiple actual arguments"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	        error(_("formal argument \"%s\" matched by multiple actual arguments"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  419|      0|		      "na.rm");
  420|      0|	    seen_NaRm = true;
  421|      0|	    if(CDR(a) == R_NilValue) return args;
  ------------------
  |  Branch (421:9): [True: 0, False: 0]
  ------------------
  422|      0|	    na_value = CAR(a);
  423|      0|	    if(prev == R_NilValue) args = CDR(a);
  ------------------
  |  Branch (423:9): [True: 0, False: 0]
  ------------------
  424|      0|	    else SETCDR(prev, CDR(a));
  425|      0|	}
  426|  1.54M|	prev = a;
  427|  1.54M|    }
  428|       |
  429|  1.54M|    PROTECT(na_value);
  ------------------
  |  |  357|  1.54M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  430|  1.54M|    SEXP t = CONS(na_value, R_NilValue);
  ------------------
  |  |  309|  1.54M|#define CONS(a, b)	Rf_cons((a), (b))		/* data lists */
  ------------------
  431|  1.54M|    UNPROTECT(1);
  ------------------
  |  |  358|  1.54M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  432|  1.54M|    PROTECT(t);
  ------------------
  |  |  357|  1.54M|#define PROTECT(s)	Rf_protect(s)
  ------------------
  433|  1.54M|    SET_TAG(t, R_NaRmSymbol);
  434|  1.54M|    if (args == R_NilValue)
  ------------------
  |  Branch (434:9): [True: 0, False: 1.54M]
  ------------------
  435|      0|	args = t;
  436|  1.54M|    else {
  437|  1.54M|	SEXP r = args;
  438|  1.54M|	while (CDR(r) != R_NilValue) r = CDR(r);
  ------------------
  |  Branch (438:9): [True: 1.00k, False: 1.54M]
  ------------------
  439|  1.54M|	SETCDR(r, t);
  440|  1.54M|    }
  441|  1.54M|    UNPROTECT(1);
  ------------------
  |  |  358|  1.54M|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  442|  1.54M|    return args;
  443|  1.54M|}
do_summary:
  545|  1.07k|{
  546|  1.07k|    checkArity(op, args);
  ------------------
  |  | 1788|  1.07k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  547|  1.07k|    if(PRIMVAL(op) == 1) { /* mean */
  ------------------
  |  | 1347|  1.07k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (547:8): [True: 0, False: 1.07k]
  ------------------
  548|      0|	SEXP x = CAR(args);
  549|      0|	switch(TYPEOF(x)) {
  550|      0|	case LGLSXP:  return logical_mean(x);
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (550:2): [True: 0, False: 0]
  ------------------
  551|      0|	case INTSXP:  return integer_mean(x);
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (551:2): [True: 0, False: 0]
  ------------------
  552|      0|	case REALSXP: return real_mean(x);
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (552:2): [True: 0, False: 0]
  ------------------
  553|      0|	case CPLXSXP: return complex_mean(x);
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (553:2): [True: 0, False: 0]
  ------------------
  554|      0|	default:
  ------------------
  |  Branch (554:2): [True: 0, False: 0]
  ------------------
  555|      0|	    error(R_MSG_type, R_typeToChar(x));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(R_MSG_type, R_typeToChar(x));
  ------------------
  |  |   33|      0|#define R_MSG_type	_("invalid 'type' (%s) of argument")
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  ------------------
  556|      0|	    return R_NilValue; // -Wall on clang 4.2
  557|      0|	}
  558|      0|    }
  559|       |
  560|  1.07k|    SEXP ans, call2;
  561|       |    /* match to foo(..., na.rm=FALSE) */
  562|  1.07k|    PROTECT(args = fixup_NaRm(args));
  ------------------
  |  |  357|  1.07k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  563|  1.07k|    PROTECT(call2 = shallow_duplicate(call));
  ------------------
  |  |  357|  1.07k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  564|  1.07k|    R_args_enable_refcnt(args);
  565|  1.07k|    SETCDR(call2, args);
  566|       |
  567|  1.07k|    if (DispatchGroup("Summary", call2, op, args, env, &ans)) {
  ------------------
  |  | 1886|  1.07k|# define DispatchGroup		Rf_DispatchGroup
  ------------------
  |  Branch (567:9): [True: 0, False: 1.07k]
  ------------------
  568|      0|	UNPROTECT(2); /* call2, args */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  569|      0|	SETCDR(call2, R_NilValue); /* clear refcnt on args */
  570|      0|	R_try_clear_args_refcnt(args);
  571|      0|	return(ans);
  572|      0|    }
  573|  1.07k|    UNPROTECT(1); /* call2 */
  ------------------
  |  |  358|  1.07k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  574|  1.07k|    SETCDR(call2, R_NilValue); /* clear refcnt on args */
  575|  1.07k|    R_try_clear_args_refcnt(args);
  576|       |
  577|       |#ifdef DEBUG_Summary
  578|       |    REprintf("C do_summary(op%s, *): did NOT dispatch\n", PRIMNAME(op));
  579|       |#endif
  580|       |
  581|  1.07k|    ans = matchArgExact(R_NaRmSymbol, &args);
  ------------------
  |  | 1945|  1.07k|# define matchArgExact		Rf_matchArgExact
  ------------------
  582|  1.07k|    bool narm = asBool2(ans, call);
  ------------------
  |  | 1860|  1.07k|# define asBool2	       	Rf_asBool2
  ------------------
  583|       |
  584|  1.07k|    if (ALTREP(CAR(args)) && CDDR(args) == R_NilValue &&
  ------------------
  |  Branch (584:9): [True: 0, False: 1.07k]
  |  Branch (584:30): [True: 0, False: 0]
  ------------------
  585|      0|	(CDR(args) == R_NilValue || TAG(CDR(args)) == R_NaRmSymbol)) {
  ------------------
  |  Branch (585:3): [True: 0, False: 0]
  |  Branch (585:30): [True: 0, False: 0]
  ------------------
  586|      0|	SEXP toret = NULL;
  587|      0|	SEXP vec = CAR(args);
  588|      0|	switch(PRIMVAL(op)) {
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  589|      0|	case 0:
  ------------------
  |  Branch (589:2): [True: 0, False: 0]
  ------------------
  590|      0|	    if(TYPEOF(vec) == INTSXP) 
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (590:9): [True: 0, False: 0]
  ------------------
  591|      0|		toret = ALTINTEGER_SUM(vec, narm);
  592|      0|	    else if (TYPEOF(vec) == REALSXP)
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (592:15): [True: 0, False: 0]
  ------------------
  593|      0|		toret = ALTREAL_SUM(vec, narm);
  594|      0|	    break; 
  595|      0|	case 2:
  ------------------
  |  Branch (595:2): [True: 0, False: 0]
  ------------------
  596|      0|	    if(TYPEOF(vec) == INTSXP) 
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (596:9): [True: 0, False: 0]
  ------------------
  597|      0|		toret = ALTINTEGER_MIN(vec, narm);
  598|      0|	    else if (TYPEOF(vec) == REALSXP)
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (598:15): [True: 0, False: 0]
  ------------------
  599|      0|		toret = ALTREAL_MIN(vec, narm);
  600|      0|	    break;
  601|      0|	case 3:
  ------------------
  |  Branch (601:2): [True: 0, False: 0]
  ------------------
  602|      0|	    if(TYPEOF(vec) == INTSXP) 
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (602:9): [True: 0, False: 0]
  ------------------
  603|      0|		toret = ALTINTEGER_MAX(vec, narm);
  604|      0|	    else if (TYPEOF(vec) == REALSXP)
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (604:15): [True: 0, False: 0]
  ------------------
  605|      0|		toret = ALTREAL_MAX(vec, narm);
  606|      0|	    break;
  607|      0|	default:
  ------------------
  |  Branch (607:2): [True: 0, False: 0]
  ------------------
  608|      0|	    break;
  609|      0|	}
  610|      0|	if(toret != NULL) {
  ------------------
  |  Branch (610:5): [True: 0, False: 0]
  ------------------
  611|      0|	    UNPROTECT(1); /* args */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  612|      0|	    return toret;
  613|      0|	}
  614|      0|    }
  615|       |
  616|  1.07k|    bool int_a, real_a, complex_a,
  617|  1.07k|	empty = true;// <==> only zero-length arguments, or NA with na.rm=T
  618|  1.07k|    int updated = 0; //
  619|       |	/* updated = NA_INTEGER if encountered NA,
  620|       |	   updated != 0 , as soon as (i)tmp (do_summary),
  621|       |	   or *value ([ir]min / max) is assigned;  */
  622|  1.07k|    SEXP a;
  623|  1.07k|    double tmp = 0.0, s;
  624|  1.07k|    Rcomplex ztmp, zcum={.r = 0.0, .i = 0.0} /* -Wall */;
  625|  1.07k|    int itmp = 0, icum = 0, warn = 0 /* dummy */;
  626|  1.07k|    bool use_isum = true; // indicating if isum() should used; otherwise irsum()
  627|  1.07k|    isum_INT iLtmp = (isum_INT)0, iLcum = iLtmp; // for isum() only
  ------------------
  |  |   51|  1.07k|# define isum_INT LONG_INT
  |  |  ------------------
  |  |  |  | 2587|  1.07k|# define LONG_INT int64_t
  |  |  ------------------
  ------------------
  628|  1.07k|    SEXPTYPE ans_type;/* only INTEGER, REAL, COMPLEX or STRSXP here */
  629|       |
  630|  1.07k|    int iop = PRIMVAL(op);
  ------------------
  |  | 1347|  1.07k|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  631|  1.07k|    switch(iop) {
  632|     66|    case 0:/* sum */
  ------------------
  |  Branch (632:5): [True: 66, False: 1.00k]
  ------------------
  633|       |    /* we need to find out if _all_ the arguments are integer or logical
  634|       |       in advance, as we might overflow before we find out.  NULL is
  635|       |       documented to be the same as integer(0).
  636|       |    */
  637|     66|	a = args;
  638|     66|        complex_a = real_a = false;
  639|    132|	while (a != R_NilValue) {
  ------------------
  |  Branch (639:9): [True: 66, False: 66]
  ------------------
  640|     66|            switch(TYPEOF(CAR(a))) {
  641|      0|	    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (641:6): [True: 0, False: 66]
  ------------------
  642|      2|	    case LGLSXP:
  ------------------
  |  |  121|      2|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (642:6): [True: 2, False: 64]
  ------------------
  643|      2|	    case NILSXP:
  ------------------
  |  |  111|      2|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (643:6): [True: 0, False: 66]
  ------------------
  644|      2|		break;
  645|     64|	    case REALSXP:
  ------------------
  |  |  124|     64|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (645:6): [True: 64, False: 2]
  ------------------
  646|     64|		real_a = true;
  647|     64|		break;
  648|      0|	    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (648:6): [True: 0, False: 66]
  ------------------
  649|      0|		complex_a = true;
  650|      0|		break;
  651|      0|	    default:
  ------------------
  |  Branch (651:6): [True: 0, False: 66]
  ------------------
  652|      0|		a = CAR(a); goto invalid_type;
  653|     66|            }
  654|     66|	    a = CDR(a);
  655|     66|	}
  656|     66|        if(complex_a) {
  ------------------
  |  Branch (656:12): [True: 0, False: 66]
  ------------------
  657|      0|            ans_type = CPLXSXP;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  658|     66|        } else if(real_a) {
  ------------------
  |  Branch (658:19): [True: 64, False: 2]
  ------------------
  659|     64|            ans_type = REALSXP;
  ------------------
  |  |  124|     64|#define REALSXP	    14	  /* real variables */
  ------------------
  660|     64|        } else {
  661|      2|            ans_type = INTSXP; iLcum = (isum_INT)0;
  ------------------
  |  |  123|      2|#define INTSXP	    13	  /* integer vectors */
  ------------------
  662|      2|        }
  663|     66|	DbgP3("do_summary: sum(.. na.rm=%d): ans_type = %s\n",
  664|     66|	      narm, type2char(ans_type));
  665|     66|	zcum.r = zcum.i = 0.; icum = 0;
  666|     66|	break;
  667|       |
  668|      0|    case 2:/* min */
  ------------------
  |  Branch (668:5): [True: 0, False: 1.07k]
  ------------------
  669|      0|	DbgP2("do_summary: min(.. na.rm=%d) ", narm);
  670|      0|	ans_type = INTSXP;
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  671|      0|	zcum.r = R_PosInf;
  672|      0|	icum = INT_MAX;
  673|      0|	break;
  674|       |
  675|  1.00k|    case 3:/* max */
  ------------------
  |  Branch (675:5): [True: 1.00k, False: 66]
  ------------------
  676|  1.00k|	DbgP2("do_summary: max(.. na.rm=%d) ", narm);
  677|  1.00k|	ans_type = INTSXP;
  ------------------
  |  |  123|  1.00k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  678|  1.00k|	zcum.r = R_NegInf;;
  679|  1.00k|	icum = R_INT_MIN;
  ------------------
  |  |   36|  1.00k|#define R_INT_MIN	(1+INT_MIN)
  ------------------
  680|  1.00k|	break;
  681|       |
  682|      0|    case 4:/* prod */
  ------------------
  |  Branch (682:5): [True: 0, False: 1.07k]
  ------------------
  683|      0|	ans_type = REALSXP;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  684|      0|	zcum.r = 1.;
  685|      0|	zcum.i = 0.;
  686|      0|	break;
  687|       |
  688|      0|    default:
  ------------------
  |  Branch (688:5): [True: 0, False: 1.07k]
  ------------------
  689|      0|	errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  690|      0|		  _("internal error ('op = %d' in do_summary).\t Call a Guru"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  691|      0|		  iop);
  692|      0|	return R_NilValue;/*-Wall */
  693|  1.07k|    }
  694|       |
  695|  1.07k|    SEXP stmp = NA_STRING,
  ------------------
  |  |  433|  1.07k|#define NA_STRING	R_NaString
  ------------------
  696|  1.07k|	 scum = PROTECT(NA_STRING);
  ------------------
  |  |  357|  1.07k|#define PROTECT(s)	Rf_protect(s)
  ------------------
  697|       |    /*-- now loop over all arguments.  Do the 'op' switch INSIDE : */
  698|  3.14k|    while (args != R_NilValue) {
  ------------------
  |  Branch (698:12): [True: 2.07k, False: 1.07k]
  ------------------
  699|  2.07k|	a = CAR(args);
  700|  2.07k|	int_a = false;// int_a = true  <-->  a is INTEGER
  701|  2.07k|	real_a = false;
  702|       |
  703|  2.07k|	if(xlength(a) > 0) {
  ------------------
  |  | 1049|  2.07k|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (703:5): [True: 2.07k, False: 0]
  ------------------
  704|  2.07k|	    updated = 0;/*- GLOBAL -*/
  705|       |
  706|  2.07k|	    switch(iop) {
  ------------------
  |  Branch (706:13): [True: 2.07k, False: 0]
  ------------------
  707|      0|	    case 2:/* min */
  ------------------
  |  Branch (707:6): [True: 0, False: 2.07k]
  ------------------
  708|  2.01k|	    case 3:/* max */
  ------------------
  |  Branch (708:6): [True: 2.01k, False: 66]
  ------------------
  709|       |
  710|  2.01k|		switch(TYPEOF(a)) {
  711|      0|		case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (711:3): [True: 0, False: 2.01k]
  ------------------
  712|  2.00k|		case INTSXP:
  ------------------
  |  |  123|  2.00k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (712:3): [True: 2.00k, False: 2]
  ------------------
  713|  2.00k|		    int_a = true;
  714|  2.00k|		    if (iop == 2) updated = imin(a, &itmp, narm);
  ------------------
  |  Branch (714:11): [True: 0, False: 2.00k]
  ------------------
  715|  2.00k|		    else	  updated = imax(a, &itmp, narm);
  716|  2.00k|		    break;
  717|      2|		case REALSXP:
  ------------------
  |  |  124|      2|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (717:3): [True: 2, False: 2.00k]
  ------------------
  718|      2|		    real_a = true;
  719|      2|		    if(ans_type == INTSXP) {/* change to REAL */
  ------------------
  |  |  123|      2|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (719:10): [True: 2, False: 0]
  ------------------
  720|      2|			ans_type = REALSXP;
  ------------------
  |  |  124|      2|#define REALSXP	    14	  /* real variables */
  ------------------
  721|      2|			if(!empty) zcum.r = Int2Real(icum);
  ------------------
  |  |   38|      2|#define Int2Real(i)	((i == NA_INTEGER) ? NA_REAL : (double)i)
  |  |  ------------------
  |  |  |  |   56|      2|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               #define Int2Real(i)	((i == NA_INTEGER) ? NA_REAL : (double)i)
  |  |  ------------------
  |  |  |  |   58|      0|#define NA_REAL		R_NaReal
  |  |  ------------------
  |  |  |  Branch (38:22): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  |  Branch (721:7): [True: 2, False: 0]
  ------------------
  722|      2|		    }
  723|      2|		    if (iop == 2) updated = rmin(a, &tmp, narm);
  ------------------
  |  Branch (723:11): [True: 0, False: 2]
  ------------------
  724|      2|		    else	  updated = rmax(a, &tmp, narm);
  725|      2|		    break;
  726|      0|		case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (726:3): [True: 0, False: 2.01k]
  ------------------
  727|      0|		    if(!empty && ans_type == INTSXP) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (727:10): [True: 0, False: 0]
  |  Branch (727:20): [True: 0, False: 0]
  ------------------
  728|      0|			scum = StringFromInteger(icum, &warn);
  ------------------
  |  | 1990|      0|# define StringFromInteger	Rf_StringFromInteger
  ------------------
  729|      0|			UNPROTECT(1); /* scum */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  730|      0|			PROTECT(scum);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  731|      0|		    } else if(!empty && ans_type == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (731:17): [True: 0, False: 0]
  |  Branch (731:27): [True: 0, False: 0]
  ------------------
  732|      0|			scum = StringFromReal(zcum.r, &warn);
  ------------------
  |  | 1992|      0|# define StringFromReal		Rf_StringFromReal
  ------------------
  733|      0|			UNPROTECT(1); /* scum */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  734|      0|			PROTECT(scum);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  735|      0|		    }
  736|      0|		    ans_type = STRSXP;
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  737|      0|		    if (iop == 2) updated = smin(a, &stmp, narm);
  ------------------
  |  Branch (737:11): [True: 0, False: 0]
  ------------------
  738|      0|		    else updated = smax(a, &stmp, narm);
  739|      0|		    break;
  740|      0|		default:
  ------------------
  |  Branch (740:3): [True: 0, False: 2.01k]
  ------------------
  741|      0|		    goto invalid_type;
  742|  2.01k|		}
  743|       |
  744|  2.01k|		if(updated) {/* 'a' had non-NA elements; --> "add" tmp or itmp*/
  ------------------
  |  Branch (744:6): [True: 2.01k, False: 0]
  ------------------
  745|  2.01k|		    DbgP1(" updated:");
  746|  2.01k|		    if(ans_type == INTSXP) {
  ------------------
  |  |  123|  2.01k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (746:10): [True: 2.00k, False: 2]
  ------------------
  747|  2.00k|			DbgP3(" INT: (old)icum= %ld, itmp=%ld\n", icum,itmp);
  748|  2.00k|			if (icum == NA_INTEGER); /* NA trumps anything */
  ------------------
  |  |   56|  2.00k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (748:8): [True: 0, False: 2.00k]
  ------------------
  749|  2.00k|			else if (itmp == NA_INTEGER ||
  ------------------
  |  |   56|  4.01k|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (749:13): [True: 0, False: 2.00k]
  ------------------
  750|  2.00k|			    (iop == 2 && itmp < icum) || /* min */
  ------------------
  |  Branch (750:9): [True: 0, False: 2.00k]
  |  Branch (750:21): [True: 0, False: 0]
  ------------------
  751|  2.00k|			    (iop == 3 && itmp > icum))   /* max */
  ------------------
  |  Branch (751:9): [True: 2.00k, False: 0]
  |  Branch (751:21): [True: 1.79k, False: 211]
  ------------------
  752|  1.79k|			    icum = itmp;
  753|  2.00k|		    } else if(ans_type == REALSXP) {
  ------------------
  |  |  124|      2|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (753:17): [True: 2, False: 0]
  ------------------
  754|      2|			if (int_a) tmp = Int2Real(itmp);
  ------------------
  |  |   38|      0|#define Int2Real(i)	((i == NA_INTEGER) ? NA_REAL : (double)i)
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               #define Int2Real(i)	((i == NA_INTEGER) ? NA_REAL : (double)i)
  |  |  ------------------
  |  |  |  |   58|      0|#define NA_REAL		R_NaReal
  |  |  ------------------
  |  |  |  Branch (38:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (754:8): [True: 0, False: 2]
  ------------------
  755|      2|			DbgP3(" REAL: (old)cum= %g, tmp=%g\n", zcum.r,tmp);
  756|      2|			if (ISNA(zcum.r)); /* NA trumps anything */
  ------------------
  |  |   64|      2|#define ISNA(x)	       R_IsNA(x)
  |  |  ------------------
  |  |  |  Branch (64:24): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  757|      2|			else if (ISNAN(tmp)) {
  ------------------
  |  |   76|      2|#  define ISNAN(x)     (isnan(x)!=0)
  |  |  ------------------
  |  |  |  Branch (76:24): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  758|      0|			    if (ISNA(tmp)) zcum.r = tmp;
  ------------------
  |  |   64|      0|#define ISNA(x)	       R_IsNA(x)
  |  |  ------------------
  |  |  |  Branch (64:24): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  759|      0|			    else zcum.r += tmp;/* NA or NaN */
  760|      2|			} else if(
  761|      2|			    (iop == 2 && tmp < zcum.r) ||
  ------------------
  |  Branch (761:9): [True: 0, False: 2]
  |  Branch (761:21): [True: 0, False: 0]
  ------------------
  762|      2|			    (iop == 3 && tmp > zcum.r))	zcum.r = tmp;
  ------------------
  |  Branch (762:9): [True: 2, False: 0]
  |  Branch (762:21): [True: 2, False: 0]
  ------------------
  763|      2|		    } else if(ans_type == STRSXP) {
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (763:17): [True: 0, False: 0]
  ------------------
  764|      0|			if(int_a)
  ------------------
  |  Branch (764:7): [True: 0, False: 0]
  ------------------
  765|      0|			   stmp = StringFromInteger(itmp, &warn);
  ------------------
  |  | 1990|      0|# define StringFromInteger	Rf_StringFromInteger
  ------------------
  766|      0|			else if(real_a)
  ------------------
  |  Branch (766:12): [True: 0, False: 0]
  ------------------
  767|      0|			   stmp = StringFromReal(tmp, &warn);
  ------------------
  |  | 1992|      0|# define StringFromReal		Rf_StringFromReal
  ------------------
  768|       |
  769|      0|			if(empty)
  ------------------
  |  Branch (769:7): [True: 0, False: 0]
  ------------------
  770|      0|			    scum = stmp;
  771|      0|			else if (scum != NA_STRING) {
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (771:13): [True: 0, False: 0]
  ------------------
  772|      0|			    PROTECT(stmp);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  773|      0|			    if(stmp == NA_STRING ||
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (773:11): [True: 0, False: 0]
  ------------------
  774|      0|			       (iop == 2 && stmp != scum && Scollate(stmp, scum) < 0) ||
  ------------------
  |  | 1985|      0|# define Scollate		Rf_Scollate
  ------------------
  |  Branch (774:12): [True: 0, False: 0]
  |  Branch (774:24): [True: 0, False: 0]
  |  Branch (774:40): [True: 0, False: 0]
  ------------------
  775|      0|			       (iop == 3 && stmp != scum && Scollate(stmp, scum) > 0) )
  ------------------
  |  | 1985|      0|# define Scollate		Rf_Scollate
  ------------------
  |  Branch (775:12): [True: 0, False: 0]
  |  Branch (775:24): [True: 0, False: 0]
  |  Branch (775:40): [True: 0, False: 0]
  ------------------
  776|      0|				scum = stmp;
  777|      0|			    UNPROTECT(1); /* stmp */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  778|      0|			}
  779|      0|			UNPROTECT(1); /* scum */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  780|      0|			PROTECT(scum);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  781|      0|		    }
  782|  2.01k|		}/*updated*/ else {
  783|       |		    /*-- in what cases does this happen here at all?
  784|       |		      -- if there are no non-missing elements.
  785|       |		     */
  786|      0|		    DbgP2(" NOT updated [!! RARE !!]: int_a=%s\n", int_a ? "TRUE" : "FALSE");
  787|      0|		}
  788|       |
  789|  2.01k|		break;/*--- end of  min() / max() ---*/
  790|       |
  791|     66|	    case 0:/* sum */
  ------------------
  |  Branch (791:6): [True: 66, False: 2.01k]
  ------------------
  792|     66|		switch(TYPEOF(a)) {
  793|      2|		case LGLSXP:
  ------------------
  |  |  121|      2|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (793:3): [True: 2, False: 64]
  ------------------
  794|      2|		case INTSXP:
  ------------------
  |  |  123|      2|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (794:3): [True: 0, False: 66]
  ------------------
  795|      2|#ifdef LONG_INT
  796|      2|		    updated = (use_isum ?
  ------------------
  |  Branch (796:18): [True: 2, False: 0]
  ------------------
  797|      2|			       isum(a, &iLtmp, narm, call) :
  798|      2|			       risum(a,  &tmp, narm));
  799|      2|		    DbgP2(" int|lgl: updated=%d ", updated);
  800|      2|		    if(updated == NA_INTEGER)
  ------------------
  |  |   56|      2|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (800:10): [True: 0, False: 2]
  ------------------
  801|      0|			goto na_answer;
  802|      2|		    else if(use_isum && updated == 42) {
  ------------------
  |  Branch (802:15): [True: 2, False: 0]
  |  Branch (802:27): [True: 0, False: 2]
  ------------------
  803|       |			// impending integer overflow --> switch to irsum()
  804|      0|			use_isum = false;
  805|      0|			if(ans_type == INTSXP) ans_type = REALSXP;
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
              			if(ans_type == INTSXP) ans_type = REALSXP;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (805:7): [True: 0, False: 0]
  ------------------
  806|       |			// re-sum() 'a' (a waste, rare; FIXME ?) :
  807|      0|			risum(a, &tmp, narm);
  808|      0|			zcum.r = (double) iLcum + tmp;
  809|      0|			DbgP3(" .. switching type to REAL, tmp=%g, zcum.r=%g",
  810|      0|			      tmp, zcum.r);
  811|      0|		    }
  812|      2|		    else if(updated) {
  ------------------
  |  Branch (812:15): [True: 2, False: 0]
  ------------------
  813|       |			// iLtmp is LONG_INT i.e. at least 64bit
  814|      2|			if(ans_type == INTSXP) {
  ------------------
  |  |  123|      2|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (814:7): [True: 2, False: 0]
  ------------------
  815|      2|			    s = (double) iLcum + (double) iLtmp;
  816|      2|			    if(s > INT_MAX || s < R_INT_MIN ||
  ------------------
  |  |   36|      4|#define R_INT_MIN	(1+INT_MIN)
  ------------------
  |  Branch (816:11): [True: 0, False: 2]
  |  Branch (816:26): [True: 0, False: 2]
  ------------------
  817|      2|			       iLtmp < -LONG_INT_MAX || LONG_INT_MAX < iLtmp) {
  ------------------
  |  | 2588|      4|# define LONG_INT_MAX INT64_MAX
  ------------------
              			       iLtmp < -LONG_INT_MAX || LONG_INT_MAX < iLtmp) {
  ------------------
  |  | 2588|      2|# define LONG_INT_MAX INT64_MAX
  ------------------
  |  Branch (817:11): [True: 0, False: 2]
  |  Branch (817:36): [True: 0, False: 2]
  ------------------
  818|      0|				ans_type = REALSXP;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  819|      0|				zcum.r = s;
  820|      0|				DbgP2(" int_1 switch: zcum.r = s = %g\n", s);
  821|      2|			    } else if(s < -(double)LONG_INT_MAX || (double)LONG_INT_MAX < s) {
  ------------------
  |  | 2588|      4|# define LONG_INT_MAX INT64_MAX
  ------------------
              			    } else if(s < -(double)LONG_INT_MAX || (double)LONG_INT_MAX < s) {
  ------------------
  |  | 2588|      2|# define LONG_INT_MAX INT64_MAX
  ------------------
  |  Branch (821:18): [True: 0, False: 2]
  |  Branch (821:47): [True: 0, False: 2]
  ------------------
  822|      0|				use_isum = false;
  823|      0|				ans_type = REALSXP;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  824|      0|				zcum.r = s;
  825|      0|				DbgP2(" int_2 switch: zcum.r = s = %g\n", s);
  826|      0|			    }
  827|      2|			    else {
  828|      2|				iLcum += iLtmp;
  829|      2|				DbgP3(" int_3: (iLtmp,iLcum) = (%ld,%ld)\n",
  830|      2|				      iLtmp, iLcum);
  831|      2|			    }
  832|      2|			} else { // dealt with NA_INTEGER already above
  833|      0|			    zcum.r += use_isum ? (double)iLtmp : tmp;
  ------------------
  |  Branch (833:18): [True: 0, False: 0]
  ------------------
  834|      0|			    DbgP3(" dbl: (*tmp, zcum.r) = (%g,%g)\n",
  835|      0|				  use_isum ? (double)iLtmp : tmp, zcum.r);
  836|      0|			}
  837|      2|		    }
  838|       |#else
  839|       |		    updated = isum(a, &iLtmp, narm, call);
  840|       |		    if(updated) {
  841|       |			if(iLtmp == NA_INTEGER) goto na_answer;
  842|       |			if(ans_type == INTSXP) {
  843|       |			    s = (double) icum + (double) iLtmp;
  844|       |			    if(s > INT_MAX || s < R_INT_MIN){
  845|       |				warningcall(call,_(
  846|       |				  "Integer overflow - use sum(as.numeric(.))"));
  847|       |				goto na_answer;
  848|       |			    }
  849|       |			    else icum += iLtmp;
  850|       |			} else
  851|       |			    zcum.r += Int2Real(iLtmp);
  852|       |		    }
  853|       |#endif
  854|      2|		    break;
  855|     64|		case REALSXP:
  ------------------
  |  |  124|     64|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (855:3): [True: 64, False: 2]
  ------------------
  856|     64|		    if(ans_type == INTSXP) {
  ------------------
  |  |  123|     64|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (856:10): [True: 0, False: 64]
  ------------------
  857|      0|			ans_type = REALSXP;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  858|      0|			if(!empty) zcum.r = Int2Real(iLcum);
  ------------------
  |  |   38|      0|#define Int2Real(i)	((i == NA_INTEGER) ? NA_REAL : (double)i)
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               #define Int2Real(i)	((i == NA_INTEGER) ? NA_REAL : (double)i)
  |  |  ------------------
  |  |  |  |   58|      0|#define NA_REAL		R_NaReal
  |  |  ------------------
  |  |  |  Branch (38:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (858:7): [True: 0, False: 0]
  ------------------
  859|      0|		    }
  860|     64|		    updated = rsum(a, &tmp, narm);
  861|     64|		    if(updated) {
  ------------------
  |  Branch (861:10): [True: 64, False: 0]
  ------------------
  862|     64|			zcum.r += tmp;
  863|     64|		    }
  864|     64|		    break;
  865|      0|		case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (865:3): [True: 0, False: 66]
  ------------------
  866|      0|		    if(ans_type == INTSXP) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (866:10): [True: 0, False: 0]
  ------------------
  867|      0|			ans_type = CPLXSXP;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  868|      0|			if(!empty) zcum.r = Int2Real(iLcum);
  ------------------
  |  |   38|      0|#define Int2Real(i)	((i == NA_INTEGER) ? NA_REAL : (double)i)
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               #define Int2Real(i)	((i == NA_INTEGER) ? NA_REAL : (double)i)
  |  |  ------------------
  |  |  |  |   58|      0|#define NA_REAL		R_NaReal
  |  |  ------------------
  |  |  |  Branch (38:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (868:7): [True: 0, False: 0]
  ------------------
  869|      0|		    } else if (ans_type == REALSXP)
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (869:18): [True: 0, False: 0]
  ------------------
  870|      0|			ans_type = CPLXSXP;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  871|      0|		    updated = csum(a, &ztmp, narm);
  872|      0|		    if(updated) {
  ------------------
  |  Branch (872:10): [True: 0, False: 0]
  ------------------
  873|      0|			zcum.r += ztmp.r;
  874|      0|			zcum.i += ztmp.i;
  875|      0|		    }
  876|      0|		    break;
  877|      0|		default:
  ------------------
  |  Branch (877:3): [True: 0, False: 66]
  ------------------
  878|      0|		    goto invalid_type;
  879|     66|		}
  880|       |
  881|     66|		break;/* sum() part */
  882|       |
  883|     66|	    case 4:/* prod */
  ------------------
  |  Branch (883:6): [True: 0, False: 2.07k]
  ------------------
  884|       |
  885|      0|		switch(TYPEOF(a)) {
  886|      0|		case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (886:3): [True: 0, False: 0]
  ------------------
  887|      0|		case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (887:3): [True: 0, False: 0]
  ------------------
  888|      0|		case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (888:3): [True: 0, False: 0]
  ------------------
  889|      0|		    if(TYPEOF(a) == REALSXP)
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (889:10): [True: 0, False: 0]
  ------------------
  890|      0|			updated = rprod(a, &tmp, narm);
  891|      0|		    else
  892|      0|			updated = iprod(a, &tmp, narm);
  893|      0|		    if(updated) {
  ------------------
  |  Branch (893:10): [True: 0, False: 0]
  ------------------
  894|      0|			zcum.r *= tmp;
  895|      0|			zcum.i *= tmp;
  896|      0|		    }
  897|      0|		    break;
  898|      0|		case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (898:3): [True: 0, False: 0]
  ------------------
  899|      0|		    ans_type = CPLXSXP;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  900|      0|		    updated = cprod(a, &ztmp, narm);
  901|      0|		    if(updated) {
  ------------------
  |  Branch (901:10): [True: 0, False: 0]
  ------------------
  902|      0|			Rcomplex z;
  903|      0|			z.r = zcum.r;
  904|      0|			z.i = zcum.i;
  905|      0|			zcum.r = z.r * ztmp.r - z.i * ztmp.i;
  906|      0|			zcum.i = z.r * ztmp.i + z.i * ztmp.r;
  907|      0|		    }
  908|      0|		    break;
  909|      0|		default:
  ------------------
  |  Branch (909:3): [True: 0, False: 0]
  ------------------
  910|      0|		    goto invalid_type;
  911|      0|		}
  912|       |
  913|      0|		break;/* prod() part */
  914|       |
  915|  2.07k|	    } /* switch(iop) */
  916|       |
  917|  2.07k|	} else { /* len(a)=0 */
  918|       |	    /* Even though this has length zero it can still be invalid,
  919|       |	       e.g. list() or raw() */
  920|      0|	    switch(TYPEOF(a)) {
  921|      0|	    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (921:6): [True: 0, False: 0]
  ------------------
  922|      0|	    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (922:6): [True: 0, False: 0]
  ------------------
  923|      0|	    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (923:6): [True: 0, False: 0]
  ------------------
  924|      0|	    case NILSXP:  /* OK historically, e.g. PR#1283 */
  ------------------
  |  |  111|      0|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (924:6): [True: 0, False: 0]
  ------------------
  925|      0|		break;
  926|      0|	    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (926:6): [True: 0, False: 0]
  ------------------
  927|      0|		if (iop == 2 || iop == 3) goto invalid_type;
  ------------------
  |  Branch (927:7): [True: 0, False: 0]
  |  Branch (927:19): [True: 0, False: 0]
  ------------------
  928|      0|		break;
  929|      0|	    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (929:6): [True: 0, False: 0]
  ------------------
  930|      0|		if (iop == 2 || iop == 3) {
  ------------------
  |  Branch (930:7): [True: 0, False: 0]
  |  Branch (930:19): [True: 0, False: 0]
  ------------------
  931|      0|		    if(!empty && ans_type == INTSXP) {
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (931:10): [True: 0, False: 0]
  |  Branch (931:20): [True: 0, False: 0]
  ------------------
  932|      0|			scum = StringFromInteger(icum, &warn);
  ------------------
  |  | 1990|      0|# define StringFromInteger	Rf_StringFromInteger
  ------------------
  933|      0|			UNPROTECT(1); /* scum */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  934|      0|			PROTECT(scum);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  935|      0|		    } else if(!empty && ans_type == REALSXP) {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (935:17): [True: 0, False: 0]
  |  Branch (935:27): [True: 0, False: 0]
  ------------------
  936|      0|			scum = StringFromReal(zcum.r, &warn);
  ------------------
  |  | 1992|      0|# define StringFromReal		Rf_StringFromReal
  ------------------
  937|      0|			UNPROTECT(1); /* scum */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  938|      0|			PROTECT(scum);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  939|      0|		    }
  940|      0|		    ans_type = STRSXP;
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  941|      0|		    break;
  942|      0|		}
  943|      0|	    default:
  ------------------
  |  Branch (943:6): [True: 0, False: 0]
  ------------------
  944|      0|		goto invalid_type;
  945|      0|	    }
  946|      0|	    if(ans_type < TYPEOF(a) && ans_type != CPLXSXP) {
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (946:9): [True: 0, False: 0]
  |  Branch (946:33): [True: 0, False: 0]
  ------------------
  947|      0|		if(!empty && ans_type == INTSXP)
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (947:6): [True: 0, False: 0]
  |  Branch (947:16): [True: 0, False: 0]
  ------------------
  948|      0|		    zcum.r = Int2Real(icum);
  ------------------
  |  |   38|      0|#define Int2Real(i)	((i == NA_INTEGER) ? NA_REAL : (double)i)
  |  |  ------------------
  |  |  |  |   56|      0|#define NA_INTEGER	R_NaInt
  |  |  ------------------
  |  |               #define Int2Real(i)	((i == NA_INTEGER) ? NA_REAL : (double)i)
  |  |  ------------------
  |  |  |  |   58|      0|#define NA_REAL		R_NaReal
  |  |  ------------------
  |  |  |  Branch (38:22): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  949|      0|		ans_type = TYPEOF(a);
  950|      0|	    }
  951|      0|	}
  952|  2.07k|	DbgP3(" .. upd.=%d, empty=%d", updated, (int)empty);
  953|  2.07k|	if(empty && updated) empty=false;
  ------------------
  |  Branch (953:5): [True: 1.07k, False: 1.00k]
  |  Branch (953:14): [True: 1.07k, False: 0]
  ------------------
  954|  2.07k|	DbgP2(", new empty=%d\n", (int)empty);
  955|  2.07k|	args = CDR(args);
  956|  2.07k|    } /*-- while(..) loop over args */
  957|       |
  958|       |    /*-------------------------------------------------------*/
  959|  1.07k|    if(empty && (iop == 2 || iop == 3)) {
  ------------------
  |  Branch (959:8): [True: 0, False: 1.07k]
  |  Branch (959:18): [True: 0, False: 0]
  |  Branch (959:30): [True: 0, False: 0]
  ------------------
  960|      0|	if(ans_type == STRSXP) {
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (960:5): [True: 0, False: 0]
  ------------------
  961|      0|	    warningcall(call, _("no non-missing arguments, returning NA"));
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              	    warningcall(call, _("no non-missing arguments, returning NA"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  962|      0|	} else {
  963|      0|	    if(iop == 2)
  ------------------
  |  Branch (963:9): [True: 0, False: 0]
  ------------------
  964|      0|		warningcall(call, _("no non-missing arguments to min; returning Inf"));
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              		warningcall(call, _("no non-missing arguments to min; returning Inf"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  965|      0|	    else
  966|      0|		warningcall(call, _("no non-missing arguments to max; returning -Inf"));
  ------------------
  |  | 2013|      0|# define warningcall		Rf_warningcall
  ------------------
              		warningcall(call, _("no non-missing arguments to max; returning -Inf"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  967|      0|	    ans_type = REALSXP;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  968|      0|	}
  969|      0|    }
  970|       |
  971|  1.07k|    ans = allocVector(ans_type, 1);
  ------------------
  |  |  875|  1.07k|#define allocVector		Rf_allocVector
  ------------------
  972|  1.07k|    switch(ans_type) {
  ------------------
  |  Branch (972:12): [True: 1.07k, False: 0]
  ------------------
  973|  1.00k|    case INTSXP:   INTEGER(ans)[0] = (iop == 0) ? (int)iLcum : icum; break;
  ------------------
  |  |  123|  1.00k|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (973:5): [True: 1.00k, False: 66]
  |  Branch (973:38): [True: 2, False: 1.00k]
  ------------------
  974|     66|    case REALSXP:  REAL(ans)[0] = zcum.r; break;
  ------------------
  |  |  124|     66|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (974:5): [True: 66, False: 1.00k]
  ------------------
  975|      0|    case CPLXSXP:  COMPLEX(ans)[0].r = zcum.r; COMPLEX(ans)[0].i = zcum.i;break;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (975:5): [True: 0, False: 1.07k]
  ------------------
  976|      0|    case STRSXP:   SET_STRING_ELT(ans, 0, scum); break;
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (976:5): [True: 0, False: 1.07k]
  ------------------
  977|  1.07k|    }
  978|  1.07k|    UNPROTECT(2); /* scum, args */
  ------------------
  |  |  358|  1.07k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  979|  1.07k|    return ans;
  980|       |
  981|      0|na_answer: /* only sum(INTSXP, ...) case currently used */
  982|      0|    ans = allocVector(ans_type, 1);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
  983|      0|    switch(ans_type) {
  ------------------
  |  Branch (983:12): [True: 0, False: 0]
  ------------------
  984|      0|    case INTSXP:	INTEGER(ans)[0] = NA_INTEGER; break;
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
                  case INTSXP:	INTEGER(ans)[0] = NA_INTEGER; break;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (984:5): [True: 0, False: 0]
  ------------------
  985|      0|    case REALSXP:	REAL(ans)[0] = NA_REAL; break;
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
                  case REALSXP:	REAL(ans)[0] = NA_REAL; break;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  |  Branch (985:5): [True: 0, False: 0]
  ------------------
  986|      0|    case CPLXSXP:	COMPLEX(ans)[0].r = COMPLEX(ans)[0].i = NA_REAL; break;
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
                  case CPLXSXP:	COMPLEX(ans)[0].r = COMPLEX(ans)[0].i = NA_REAL; break;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
  |  Branch (986:5): [True: 0, False: 0]
  ------------------
  987|      0|    case STRSXP:        SET_STRING_ELT(ans, 0, NA_STRING); break;
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
                  case STRSXP:        SET_STRING_ELT(ans, 0, NA_STRING); break;
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (987:5): [True: 0, False: 0]
  ------------------
  988|      0|    }
  989|      0|    UNPROTECT(2); /* scum, args */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  990|      0|    return ans;
  991|       |
  992|      0|invalid_type:
  993|      0|    errorcall(call, R_MSG_type, R_typeToChar(a));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
                  errorcall(call, R_MSG_type, R_typeToChar(a));
  ------------------
  |  |   33|      0|#define R_MSG_type	_("invalid 'type' (%s) of argument")
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  ------------------
  994|      0|    return R_NilValue;
  995|      0|}/* do_summary */
do_first_min:
 1029|      4|{
 1030|      4|    SEXP sx = CAR(args), ans;
 1031|      4|    int nprot = 1;
 1032|      4|    R_xlen_t i, n, indx = -1;
 1033|       |
 1034|      4|    checkArity(op, args);
  ------------------
  |  | 1788|      4|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1035|      4|    if (OBJECT(sx) && !isDataFrame(sx)) {
  ------------------
  |  |  943|      0|#define isDataFrame		Rf_isDataFrame
  ------------------
  |  Branch (1035:9): [True: 0, False: 4]
  |  Branch (1035:23): [True: 0, False: 0]
  ------------------
 1036|      0|	SEXP call = PROTECT(lang2(install("xtfrm"), sx)); nprot++;
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1037|      0|	PROTECT(sx = eval(call, rho)); nprot++;
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1038|      0|    } else
 1039|      4|    if (!isNumeric(sx)) {
  ------------------
  |  |  957|      4|#define isNumeric		Rf_isNumeric
  ------------------
  |  Branch (1039:9): [True: 0, False: 4]
  ------------------
 1040|      0|	PROTECT(sx = coerceVector(CAR(args), REALSXP)); nprot++;
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1041|      0|    }
 1042|      4|    n = XLENGTH(sx);
 1043|      4|    switch(TYPEOF(sx)) {
  ------------------
  |  Branch (1043:12): [True: 4, False: 0]
  ------------------
 1044|      4|    case LGLSXP: // with only (TRUE, FALSE, NA) -- may be fast
  ------------------
  |  |  121|      4|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1044:5): [True: 4, False: 0]
  ------------------
 1045|      4|    {
 1046|      4|	int *r = LOGICAL(sx);
 1047|      4|	if(PRIMVAL(op) == 0) { /* which.min */
  ------------------
  |  | 1347|      4|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1047:5): [True: 0, False: 4]
  ------------------
 1048|      0|	    for (i = 0; i < n; i++)
  ------------------
  |  Branch (1048:18): [True: 0, False: 0]
  ------------------
 1049|      0|		if (r[i] == FALSE) {
  ------------------
  |  Branch (1049:7): [True: 0, False: 0]
  ------------------
 1050|      0|		    indx = i; break; // found FALSE: done
 1051|      0|		} else if (indx == -1 && r[i] != NA_LOGICAL) {
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1051:14): [True: 0, False: 0]
  |  Branch (1051:28): [True: 0, False: 0]
  ------------------
 1052|      0|		    indx = i; // first TRUE
 1053|      0|		}
 1054|      4|	} else { /* which.max */
 1055|      4|	    for (i = 0; i < n; i++)
  ------------------
  |  Branch (1055:18): [True: 4, False: 0]
  ------------------
 1056|      4|		if (r[i] == TRUE) {
  ------------------
  |  Branch (1056:7): [True: 4, False: 0]
  ------------------
 1057|      4|		    indx = i; break; // found TRUE: done
 1058|      4|		} else if (indx == -1 && r[i] != NA_LOGICAL) {
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1058:14): [True: 0, False: 0]
  |  Branch (1058:28): [True: 0, False: 0]
  ------------------
 1059|      0|		    indx = i; // first FALSE
 1060|      0|		}
 1061|      4|	}
 1062|      4|    }
 1063|      4|    break;
 1064|       |
 1065|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1065:5): [True: 0, False: 4]
  ------------------
 1066|      0|    {
 1067|      0|	int s, *r = INTEGER(sx);
 1068|      0|	if(PRIMVAL(op) == 0) { /* which.min */
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1068:5): [True: 0, False: 0]
  ------------------
 1069|      0|	    s = INT_MAX;
 1070|      0|	    for (i = 0; i < n; i++)
  ------------------
  |  Branch (1070:18): [True: 0, False: 0]
  ------------------
 1071|      0|		if (r[i] != NA_INTEGER && (r[i] < s || indx == -1)) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1071:7): [True: 0, False: 0]
  |  Branch (1071:30): [True: 0, False: 0]
  |  Branch (1071:42): [True: 0, False: 0]
  ------------------
 1072|      0|		    s = r[i]; indx = i;
 1073|      0|		}
 1074|      0|	} else { /* which.max */
 1075|      0|	    s = INT_MIN;
 1076|      0|	    for (i = 0; i < n; i++)
  ------------------
  |  Branch (1076:18): [True: 0, False: 0]
  ------------------
 1077|      0|		if (r[i] != NA_INTEGER && (r[i] > s || indx == -1)) {
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1077:7): [True: 0, False: 0]
  |  Branch (1077:30): [True: 0, False: 0]
  |  Branch (1077:42): [True: 0, False: 0]
  ------------------
 1078|      0|		    s = r[i]; indx = i;
 1079|      0|		}
 1080|      0|	}
 1081|      0|    }
 1082|      0|    break;
 1083|       |
 1084|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1084:5): [True: 0, False: 4]
  ------------------
 1085|      0|    {
 1086|      0|	double s, *r = REAL(sx);
 1087|      0|	if(PRIMVAL(op) == 0) { /* which.min */
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1087:5): [True: 0, False: 0]
  ------------------
 1088|      0|	    s = R_PosInf;
 1089|      0|	    for (i = 0; i < n; i++)
  ------------------
  |  Branch (1089:18): [True: 0, False: 0]
  ------------------
 1090|      0|		if ( !ISNAN(r[i]) && (r[i] < s || indx == -1) ) {
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  ------------------
  |  Branch (1090:8): [True: 0, False: 0]
  |  Branch (1090:25): [True: 0, False: 0]
  |  Branch (1090:37): [True: 0, False: 0]
  ------------------
 1091|      0|		    s = r[i]; indx = i;
 1092|      0|		}
 1093|      0|	} else { /* which.max */
 1094|      0|	    s = R_NegInf;
 1095|      0|	    for (i = 0; i < n; i++)
  ------------------
  |  Branch (1095:18): [True: 0, False: 0]
  ------------------
 1096|      0|		if ( !ISNAN(r[i]) && (r[i] > s || indx == -1) ) {
  ------------------
  |  |   76|      0|#  define ISNAN(x)     (isnan(x)!=0)
  ------------------
  |  Branch (1096:8): [True: 0, False: 0]
  |  Branch (1096:25): [True: 0, False: 0]
  |  Branch (1096:37): [True: 0, False: 0]
  ------------------
 1097|      0|		    s = r[i]; indx = i;
 1098|      0|		}
 1099|      0|	}
 1100|      0|    }
 1101|      4|    } // switch()
 1102|       |
 1103|       |
 1104|      4|    i = (indx != -1);
 1105|      4|    bool large = (indx + 1) > INT_MAX;
 1106|      4|    PROTECT(ans = allocVector(large ? REALSXP : INTSXP, i ? 1 : 0));
  ------------------
  |  |  357|     16|#define PROTECT(s)	Rf_protect(s)
  |  |  ------------------
  |  |  |  Branch (357:31): [True: 0, False: 4]
  |  |  |  Branch (357:31): [True: 4, False: 0]
  |  |  ------------------
  ------------------
 1107|      4|    if (i) {
  ------------------
  |  Branch (1107:9): [True: 4, False: 0]
  ------------------
 1108|      4|	if(large)
  ------------------
  |  Branch (1108:5): [True: 0, False: 4]
  ------------------
 1109|      0|	    REAL(ans)[0] = (double)indx + 1;
 1110|      4|	else
 1111|      4|	    INTEGER(ans)[0] = (int)indx + 1;
 1112|      4|	if (getAttrib(sx, R_NamesSymbol) != R_NilValue) { /* preserve names */
  ------------------
  |  |  924|      4|#define getAttrib		Rf_getAttrib
  ------------------
  |  Branch (1112:6): [True: 4, False: 0]
  ------------------
 1113|      4|	    SEXP ansnam;
 1114|      4|	    PROTECT(ansnam =
  ------------------
  |  |  357|      4|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1115|      4|		    ScalarString(STRING_ELT(getAttrib(sx, R_NamesSymbol), indx)));
 1116|      4|	    setAttrib(ans, R_NamesSymbol, ansnam);
  ------------------
  |  | 1027|      4|#define setAttrib		Rf_setAttrib
  ------------------
 1117|      4|	    UNPROTECT(1);
  ------------------
  |  |  358|      4|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1118|      4|	}
 1119|      4|    }
 1120|      4|    UNPROTECT(nprot);
  ------------------
  |  |  358|      4|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1121|      4|    return ans;
 1122|      4|}
do_which:
 1127|      9|{
 1128|      9|    checkArity(op, args);
  ------------------
  |  | 1788|      9|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1129|      9|    SEXP v = CAR(args);
 1130|      9|    if (!isLogical(v))
  ------------------
  |  |  952|      9|#define isLogical		Rf_isLogical
  ------------------
  |  Branch (1130:9): [True: 0, False: 9]
  ------------------
 1131|      0|	error(_("argument to 'which' is not logical"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("argument to 'which' is not logical"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1132|      9|    R_xlen_t len = xlength(v), i, j = 0;
  ------------------
  |  | 1049|      9|#define xlength(x)		Rf_xlength(x)
  ------------------
 1133|      9|    SEXP ans;
 1134|      9|#ifdef LONG_VECTOR_SUPPORT
 1135|      9|    if (len > R_SHORT_LEN_MAX) {
  ------------------
  |  |   77|      9|# define R_SHORT_LEN_MAX 2147483647
  ------------------
  |  Branch (1135:9): [True: 0, False: 9]
  ------------------
 1136|      0|    R_xlen_t xoffset = 1; // 1 for 1-based indexing of response
 1137|      0|    double *buf = (double *) R_alloc(len, sizeof(double));
 1138|      0|    ITERATE_BY_REGION(v, ptr, idx, nb, int, LOGICAL, {
  ------------------
  |  |  251|      0|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|      0|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|      0|				  strt, nfull, expr) do {		\
  |  |  |  |  221|      0|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|      0|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|      0|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|      0|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|      0|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|      0|	    px += strt;							\
  |  |  |  |  227|      0|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|      0|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  229|      0|	    }                                                           \
  |  |  |  |  230|      0|	}								\
  |  |  |  |  231|      0|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|      0|					strt, nfull, expr);		\
  |  |  |  |  233|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|      0|				  0, XLENGTH(sx), expr);		\
  |  |  254|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1139|      0|	    for(R_xlen_t i = 0; i < nb; i++) {
 1140|      0|		if(ptr[i] == TRUE) {
 1141|      0|		    buf[j] = (double)(xoffset + i); // offset has +1 built in
 1142|      0|		    j++;
 1143|      0|		}
 1144|      0|	    }
 1145|      0|	    xoffset += nb; // move to beginning of next buffer (+1 since R-based)
 1146|      0|	});
 1147|       |
 1148|      0|    len = j;
 1149|      0|    PROTECT(ans = allocVector(REALSXP, len));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1150|       |    // buf has doubles in it, memcopy if we found any indices.
 1151|      0|    if(len) memcpy(REAL(ans), buf, sizeof(double) * len);
  ------------------
  |  Branch (1151:8): [True: 0, False: 0]
  ------------------
 1152|      0|    } else
 1153|      9|#endif
 1154|      9|    {
 1155|      9|    int ioffset = 1;
 1156|      9|    int *buf = (int *) R_alloc(len, sizeof(int));
 1157|       |    /* use iteration macros to be ALTREP safe and pull ptr retrieval out of tight loop */
 1158|      9|    ITERATE_BY_REGION(v, ptr, idx, nb, int, LOGICAL, {
  ------------------
  |  |  251|      9|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|      9|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|      9|				  strt, nfull, expr) do {		\
  |  |  |  |  221|      9|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|      9|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 9, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|      9|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|      9|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|      9|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|      9|	    px += strt;							\
  |  |  |  |  227|      9|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 9, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|  6.11k|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 828, False: 491]
  |  |  |  |  |  Branch (228:10): [True: 1.31k, False: 9]
  |  |  |  |  ------------------
  |  |  |  |  229|      9|	    }                                                           \
  |  |  |  |  230|      9|	}								\
  |  |  |  |  231|      9|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|      9|					strt, nfull, expr);		\
  |  |  |  |  233|      9|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 9]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|      9|				  0, XLENGTH(sx), expr);		\
  |  |  254|      9|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 9]
  |  |  ------------------
  ------------------
 1159|      9|	    for(int i = 0; i < nb; i++) {
 1160|      9|		if(ptr[i] == TRUE) {
 1161|      9|		    buf[j] = ioffset + i; // offset has +1 built in
 1162|      9|		    j++;
 1163|      9|		}
 1164|      9|	    }
 1165|      9|	    ioffset += nb; // move to beginning of next buffer
 1166|      9|	});
 1167|       |
 1168|      9|    len = j;
 1169|       |    // buf has ints in it and we're returning ints, memcopy if we found any indices;
 1170|      9|    PROTECT(ans = allocVector(INTSXP, len));
  ------------------
  |  |  357|      9|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1171|      9|    if(len) memcpy(INTEGER(ans), buf, sizeof(int) * len);
  ------------------
  |  Branch (1171:8): [True: 9, False: 0]
  ------------------
 1172|      9|    }
 1173|       |
 1174|      9|    SEXP v_nms = getAttrib(v, R_NamesSymbol);
  ------------------
  |  |  924|      9|#define getAttrib		Rf_getAttrib
  ------------------
 1175|      9|    if (v_nms != R_NilValue) {
  ------------------
  |  Branch (1175:9): [True: 0, False: 9]
  ------------------
 1176|      0|	SEXP ans_nms = PROTECT(allocVector(STRSXP, len));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1177|      0|#ifdef LONG_VECTOR_SUPPORT
 1178|      0|	if (TYPEOF(ans) == REALSXP)
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1178:6): [True: 0, False: 0]
  ------------------
 1179|      0|	for (i = 0; i < len; i++) {
  ------------------
  |  Branch (1179:14): [True: 0, False: 0]
  ------------------
 1180|      0|	    SET_STRING_ELT(ans_nms, i,
 1181|      0|			   STRING_ELT(v_nms, (R_xlen_t)REAL(ans)[i] - 1));
 1182|      0|	}
 1183|      0|	else
 1184|      0|#endif
 1185|      0|	for (i = 0; i < len; i++) {
  ------------------
  |  Branch (1185:14): [True: 0, False: 0]
  ------------------
 1186|      0|	    SET_STRING_ELT(ans_nms, i,
 1187|      0|			   STRING_ELT(v_nms, (R_xlen_t)INTEGER(ans)[i] - 1));
 1188|      0|	}
 1189|      0|	setAttrib(ans, R_NamesSymbol, ans_nms);
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
 1190|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1191|      0|    }
 1192|      9|    UNPROTECT(1);
  ------------------
  |  |  358|      9|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1193|      9|    return ans;
 1194|      9|}
summary.c:imax:
  265|  2.00k|{
  266|  2.00k|    int s = 0 /* -Wall */;
  267|  2.00k|    bool updated = false;
  268|       |
  269|  2.00k|    ITERATE_BY_REGION(sx, x, i, nbatch, int, INTEGER, {
  ------------------
  |  |  251|  2.00k|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|  2.00k|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|  2.00k|				  strt, nfull, expr) do {		\
  |  |  |  |  221|  2.00k|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|  2.00k|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 2.00k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|  2.00k|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|  2.00k|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|  2.00k|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|  2.00k|	    px += strt;							\
  |  |  |  |  227|  2.00k|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 2.00k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|  22.0k|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 2.00k, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 2.00k, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 2.00k, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 2.00k, False: 2.00k]
  |  |  |  |  ------------------
  |  |  |  |  229|  2.00k|	    }                                                           \
  |  |  |  |  230|  2.00k|	}								\
  |  |  |  |  231|  2.00k|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|  2.00k|					strt, nfull, expr);		\
  |  |  |  |  233|  2.00k|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 2.00k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|  2.00k|				  0, XLENGTH(sx), expr);		\
  |  |  254|  2.00k|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 2.00k]
  |  |  ------------------
  ------------------
  270|  2.00k|	    for (R_xlen_t k = 0; k < nbatch; k++) {
  271|  2.00k|		if (x[k] != NA_INTEGER) {
  272|  2.00k|		    if (!updated || s < x[k]) {
  273|  2.00k|			s = x[k];
  274|  2.00k|			if(!updated) updated = true;
  275|  2.00k|		    }
  276|  2.00k|		} else if (!narm) {
  277|  2.00k|		    *value = NA_INTEGER;
  278|  2.00k|		    return(true);
  279|  2.00k|		}
  280|  2.00k|	    }
  281|  2.00k|	});
  282|  2.00k|    *value = s;
  283|  2.00k|    return updated;
  284|  2.00k|}
summary.c:rmax:
  287|      2|{
  288|      2|    double s = 0.0 /* -Wall */;
  289|      2|    bool updated = false;
  290|       |
  291|       |    ITERATE_BY_REGION(sx, x, iii, nbatch, double, REAL, {
  ------------------
  |  |  251|      2|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|      2|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|      2|				  strt, nfull, expr) do {		\
  |  |  |  |  221|      2|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|      2|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|      2|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|      2|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|      2|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|      2|	    px += strt;							\
  |  |  |  |  227|      2|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|     70|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 2, False: 6]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 6]
  |  |  |  |  |  Branch (228:10): [True: 2, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 8]
  |  |  |  |  |  Branch (228:10): [True: 8, False: 2]
  |  |  |  |  ------------------
  |  |  |  |  229|      2|	    }                                                           \
  |  |  |  |  230|      2|	}								\
  |  |  |  |  231|      2|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|      2|					strt, nfull, expr);		\
  |  |  |  |  233|      2|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|      2|				  0, XLENGTH(sx), expr);		\
  |  |  254|      2|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 2]
  |  |  ------------------
  ------------------
  292|      2|	    for (R_xlen_t k = 0; k < nbatch; k++) {
  293|      2|		if (ISNAN(x[k])) {/* Na(N) */
  294|      2|		    if (!narm) {
  295|      2|			if(!ISNA(s)) s = x[k]; /* so any NA trumps all NaNs */
  296|      2|			if(!updated) updated = true;
  297|      2|		    }
  298|      2|		}
  299|      2|		else if (!updated || x[k] > s) { /* Never true if s is NA/NaN */
  300|      2|		    s = x[k];
  301|      2|		    if(!updated) updated = true;
  302|      2|		}
  303|      2|	    }
  304|      2|	});
  305|      2|    *value = s;
  306|      2|    return updated;
  307|      2|}
summary.c:isum:
   53|      2|{
   54|      2|    LONG_INT s = 0;  // at least 64-bit
  ------------------
  |  | 2587|      2|# define LONG_INT int64_t
  ------------------
   55|      2|    int updated = 0;
   56|      2|#ifdef LONG_VECTOR_SUPPORT
   57|      2|    int ii = R_INT_MIN; // need > 2^32 entries to overflow; checking earlier is a waste
  ------------------
  |  |   36|      2|#define R_INT_MIN	(1+INT_MIN)
  ------------------
   58|       |/* NOTE: cannot use 64-bit *value to pass NA_INTEGER: that is "regular" 64bit int
   59|       | *      -> pass the NA information via return value ('updated').
   60|       | * After the first 2^32 entries, only check every 1000th time (related to GET_REGION_BUFSIZE=512 ?)
   61|       | * Assume LONG_INT_MAX >= 2^63-1 >=~ 9.223e18 >  (1000 * 9000..0L = 9 * 10^18)
   62|       | */
   63|      2|# define ISUM_OVERFLOW_CHECK do {					\
   64|      2|	if (ii++ > 1000) {						\
   65|      2|	    if (s > 9000000000000000L || s < -9000000000000000L) {	\
   66|      2|		DbgP2("|OVERFLOW triggered: s=%ld|", s);		\
   67|       |		/* *value = s; no use, TODO continue from 'k' */	\
   68|      2|		return 42; /* was overflow, NA; now switch to irsum()*/ \
   69|      2|	    }								\
   70|      2|	    ii = 0;							\
   71|      2|	}								\
   72|      2|    } while (0)
   73|       |#else
   74|       |# define ISUM_OVERFLOW_CHECK do { } while(0)
   75|       |#endif
   76|       |
   77|       |    /**** assumes INTEGER(sx) and LOGICAL(sx) are identical!! */
   78|      2|    ITERATE_BY_REGION(sx, x, i, nbatch, int, INTEGER, {
  ------------------
  |  |  251|      2|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|      2|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|      2|				  strt, nfull, expr) do {		\
  |  |  |  |  221|      2|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|      2|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|      2|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|      2|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|      2|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|      2|	    px += strt;							\
  |  |  |  |  227|      2|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 2, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|     22|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 2, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 2]
  |  |  |  |  |  Branch (228:10): [Folded, False: 2]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 2, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 2, False: 2]
  |  |  |  |  ------------------
  |  |  |  |  229|      2|	    }                                                           \
  |  |  |  |  230|      2|	}								\
  |  |  |  |  231|      2|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [Folded, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|      2|					strt, nfull, expr);		\
  |  |  |  |  233|      2|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|      2|				  0, XLENGTH(sx), expr);		\
  |  |  254|      2|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 2]
  |  |  ------------------
  ------------------
   79|      2|	    for (R_xlen_t k = 0; k < nbatch; k++) {
   80|      2|		if (x[k] != NA_INTEGER) {
   81|      2|		    if(!updated) updated = 1;
   82|      2|		    s += x[k];
   83|      2|		    ISUM_OVERFLOW_CHECK;
   84|      2|		} else if (!narm) {
   85|       |		    // updated = NA_INTEGER;
   86|      2|		    return NA_INTEGER;
   87|      2|		}
   88|      2|	    }
   89|      2|	});
   90|      2|    *value = s;
   91|      2|    return updated;
   92|      2|#undef ISUM_OVERFLOW_CHECK
   93|      2|}
summary.c:rsum:
  153|     64|{
  154|     64|    LDOUBLE s = 0.0;
  ------------------
  |  | 2577|     64|# define LDOUBLE long double
  ------------------
  155|     64|    bool updated = false;
  156|       |
  157|     64|    ITERATE_BY_REGION(sx, x, i, nbatch, double, REAL, {
  ------------------
  |  |  251|     64|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|     64|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|     64|				  strt, nfull, expr) do {		\
  |  |  |  |  221|     64|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|     64|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 64, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|     64|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|     64|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|     64|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|     64|	    px += strt;							\
  |  |  |  |  227|     64|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 64, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|  1.92k|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 256, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 64, False: 192]
  |  |  |  |  |  Branch (228:10): [True: 256, False: 64]
  |  |  |  |  ------------------
  |  |  |  |  229|     64|	    }                                                           \
  |  |  |  |  230|     64|	}								\
  |  |  |  |  231|     64|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|     64|					strt, nfull, expr);		\
  |  |  |  |  233|     64|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 64]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|     64|				  0, XLENGTH(sx), expr);		\
  |  |  254|     64|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 64]
  |  |  ------------------
  ------------------
  158|     64|	    for (R_xlen_t k = 0; k < nbatch; k++) {
  159|     64|		if (!narm || !ISNAN(x[k])) {
  160|     64|		    if(!updated) updated = true;
  161|     64|		    s += x[k];
  162|     64|		}
  163|     64|	    }
  164|     64|	});
  165|     64|    if(s > DBL_MAX) *value = R_PosInf;
  ------------------
  |  Branch (165:8): [True: 0, False: 64]
  ------------------
  166|     64|    else if (s < -DBL_MAX) *value = R_NegInf;
  ------------------
  |  Branch (166:14): [True: 0, False: 64]
  ------------------
  167|     64|    else *value = (double) s;
  168|       |
  169|     64|    return updated;
  170|     64|}

R_FileExists:
   81|    158|{
   82|    158|    struct stat sb;
   83|    158|    return stat(R_ExpandFileName(path), &sb) == 0;
   84|    158|}
R_fopen:
  143|     36|{
  144|     36|    return(filename ? fopen(filename, fixmode(mode)) : NULL );
  ------------------
  |  |  138|     36|#define fixmode(mode) (mode)
  ------------------
  |  Branch (144:12): [True: 36, False: 0]
  ------------------
  145|     36|}
R_HomeDir:
  232|     14|{
  233|     14|    return getenv("R_HOME");
  234|     14|}
do_interactive:
  238|      8|{
  239|      8|    checkArity(op, args);
  ------------------
  |  | 1788|      8|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  240|      8|    return ScalarLogical( (R_Interactive) ? 1 : 0 );
  ------------------
  |  | 1023|      8|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  |  Branch (240:27): [True: 8, False: 0]
  ------------------
  241|      8|}
R_popen:
  295|      4|{
  296|      4|    FILE *fp;
  297|       |#ifdef OLD__APPLE__
  298|       |    /* Luke recommends this to fix PR#1140 */
  299|       |    /* As of 2016-01-06 on El Capitan this may no longer be needed -- LT */
  300|       |    sigset_t ss;
  301|       |    sigemptyset(&ss);
  302|       |    sigaddset(&ss, SIGPROF);
  303|       |    sigprocmask(SIG_BLOCK, &ss,  NULL);
  304|       |    fp = popen(command, type);
  305|       |    sigprocmask(SIG_UNBLOCK, &ss, NULL);
  306|       |#else
  307|      4|    fp = popen(command, type);
  308|      4|#endif
  309|      4|    return fp;
  310|      4|}
do_getenv:
  368|     80|{
  369|     80|    int i, j;
  370|     80|    SEXP ans;
  371|       |
  372|     80|    checkArity(op, args);
  ------------------
  |  | 1788|     80|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  373|       |
  374|     80|    if (!isString(CAR(args)))
  ------------------
  |  |  966|     80|#define isString		Rf_isString
  ------------------
  |  Branch (374:9): [True: 0, False: 80]
  ------------------
  375|      0|	error(_("wrong type for argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("wrong type for argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  376|       |
  377|     80|    if (!isString(CADR(args)) || LENGTH(CADR(args)) != 1)
  ------------------
  |  |  966|     80|#define isString		Rf_isString
  ------------------
  |  Branch (377:9): [True: 0, False: 80]
  |  Branch (377:34): [True: 0, False: 80]
  ------------------
  378|      0|	error(_("wrong type for argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("wrong type for argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  379|       |
  380|     80|    i = LENGTH(CAR(args));
  381|     80|    if (i == 0) { // full list of environment variables
  ------------------
  |  Branch (381:9): [True: 0, False: 80]
  ------------------
  382|       |#ifdef Win32
  383|       |	int n = 0, N;
  384|       |	wchar_t **w;
  385|       |	for (i = 0, w = _wenviron; *w != NULL; i++, w++)
  386|       |	    n = max(n, wcslen(*w));
  387|       |	N = 4*n+1;
  388|       |	char buf[N];
  389|       |	PROTECT(ans = allocVector(STRSXP, i));
  390|       |	for (i = 0, w = _wenviron; *w != NULL; i++, w++) {
  391|       |	    wcstoutf8(buf, *w, sizeof(buf));
  392|       |	    SET_STRING_ELT(ans, i, mkCharCE(buf, CE_UTF8));
  393|       |	}
  394|       |#else
  395|      0|	char **e;
  396|      0|	for (i = 0, e = environ; *e != NULL; i++, e++);
  ------------------
  |  Branch (396:27): [True: 0, False: 0]
  ------------------
  397|      0|	PROTECT(ans = allocVector(STRSXP, i));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  398|      0|	for (i = 0, e = environ; *e != NULL; i++, e++)
  ------------------
  |  Branch (398:27): [True: 0, False: 0]
  ------------------
  399|      0|	    SET_STRING_ELT(ans, i, mkChar(*e));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  400|      0|#endif
  401|     80|    } else {
  402|     80|	PROTECT(ans = allocVector(STRSXP, i));
  ------------------
  |  |  357|     80|#define PROTECT(s)	Rf_protect(s)
  ------------------
  403|    160|	for (j = 0; j < i; j++) {
  ------------------
  |  Branch (403:14): [True: 80, False: 80]
  ------------------
  404|       |#ifdef Win32
  405|       |	    const wchar_t *wnm = wtransChar(STRING_ELT(CAR(args), j));
  406|       |	    wchar_t *w = _wgetenv(wnm);
  407|       |	    if (w == NULL)
  408|       |		SET_STRING_ELT(ans, j, STRING_ELT(CADR(args), 0));
  409|       |	    else {
  410|       |		int n = wcslen(w), N = 4*n+1; /* UTF-16 maps to <= 4 UTF-8 */
  411|       |		R_CheckStack2(N);
  412|       |		char buf[N];
  413|       |		wcstoutf8(buf, w, sizeof(buf));
  414|       |		SET_STRING_ELT(ans, j, mkCharCE(buf, CE_UTF8));
  415|       |	    }
  416|       |#else
  417|     80|	    char *s = getenv(translateChar(STRING_ELT(CAR(args), j)));
  ------------------
  |  | 1037|     80|#define translateChar		Rf_translateChar
  ------------------
  418|     80|	    if (s == NULL)
  ------------------
  |  Branch (418:10): [True: 57, False: 23]
  ------------------
  419|     57|		SET_STRING_ELT(ans, j, STRING_ELT(CADR(args), 0));
  420|     23|	    else {
  421|     23|		SEXP tmp;
  422|     23|		if(known_to_be_latin1) tmp = mkCharCE(s, CE_LATIN1);
  ------------------
  |  |  999|      0|#define mkCharCE		Rf_mkCharCE
  ------------------
  |  Branch (422:6): [True: 0, False: 23]
  ------------------
  423|     23|		else if(known_to_be_utf8) tmp = mkCharCE(s, CE_UTF8);
  ------------------
  |  |  999|      0|#define mkCharCE		Rf_mkCharCE
  ------------------
  |  Branch (423:11): [True: 0, False: 23]
  ------------------
  424|     23|		else tmp = mkChar(s);
  ------------------
  |  |  998|     23|#define mkChar			Rf_mkChar
  ------------------
  425|     23|		SET_STRING_ELT(ans, j, tmp);
  426|     23|	    }
  427|     80|#endif
  428|     80|	}
  429|     80|    }
  430|     80|    UNPROTECT(1);
  ------------------
  |  |  358|     80|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  431|     80|    return (ans);
  432|     80|}
do_setenv:
  463|     30|{
  464|     30|#if defined(HAVE_PUTENV) || defined(HAVE_SETENV)
  465|       |
  466|     30|    checkArity(op, args);
  ------------------
  |  | 1788|     30|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  467|       |
  468|     30|    SEXP nm = CAR(args);
  469|     30|    if (!isString(nm))
  ------------------
  |  |  966|     30|#define isString		Rf_isString
  ------------------
  |  Branch (469:9): [True: 0, False: 30]
  ------------------
  470|      0|	error(_("wrong type for argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("wrong type for argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  471|     30|    SEXP val = CADR(args);
  472|     30|    if (!isString(val))
  ------------------
  |  |  966|     30|#define isString		Rf_isString
  ------------------
  |  Branch (472:9): [True: 0, False: 30]
  ------------------
  473|      0|	error(_("wrong type for argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("wrong type for argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  474|     30|    if(LENGTH(nm) != LENGTH(val))
  ------------------
  |  Branch (474:8): [True: 0, False: 30]
  ------------------
  475|      0|	error(_("'%s' and '%s' are of different lengths"), "names", "val");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'%s' and '%s' are of different lengths"), "names", "val");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  476|       |
  477|     30|    int i, n = LENGTH(val);
  478|     30|    SEXP ans = PROTECT(allocVector(LGLSXP, n));
  ------------------
  |  |  357|     30|#define PROTECT(s)	Rf_protect(s)
  ------------------
  479|     30|#ifdef HAVE_SETENV
  480|     60|    for (i = 0; i < n; i++)
  ------------------
  |  Branch (480:17): [True: 30, False: 30]
  ------------------
  481|     30|	LOGICAL(ans)[i] = setenv(translateChar(STRING_ELT(nm, i)),
  ------------------
  |  | 1037|     30|#define translateChar		Rf_translateChar
  ------------------
  482|     30|				 translateChar(STRING_ELT(val, i)),
  ------------------
  |  | 1037|     30|#define translateChar		Rf_translateChar
  ------------------
  483|     30|				 1) == 0;
  484|       |#elif defined(Win32)
  485|       |    for (i = 0; i < n; i++)
  486|       |	LOGICAL(ans)[i] = Rwputenv(wtransChar(STRING_ELT(nm, i)),
  487|       |				   wtransChar(STRING_ELT(val, i))) == 0;
  488|       |#else
  489|       |    for (i = 0; i < n; i++)
  490|       |	LOGICAL(ans)[i] = Rputenv(translateChar(STRING_ELT(nm, i)),
  491|       |				  translateChar(STRING_ELT(val, i))) == 0;
  492|       |#endif
  493|     30|    UNPROTECT(1);
  ------------------
  |  |  358|     30|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  494|     30|    return ans;
  495|       |#else
  496|       |    error(_("'Sys.setenv' is not available on this system"));
  497|       |    return R_NilValue; /* -Wall */
  498|       |#endif
  499|     30|}
do_unsetenv:
  503|     26|{
  504|     26|    checkArity(op, args);
  ------------------
  |  | 1788|     26|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  505|       |
  506|     26|    SEXP nm = CAR(args);
  507|     26|    if (!isString(nm))
  ------------------
  |  |  966|     26|#define isString		Rf_isString
  ------------------
  |  Branch (507:9): [True: 0, False: 26]
  ------------------
  508|      0|	error(_("wrong type for argument"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("wrong type for argument"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  509|     26|    int i, n = LENGTH(nm);
  510|       |
  511|     26|#if defined(HAVE_UNSETENV) || defined(HAVE_PUTENV_UNSET) || defined(HAVE_PUTENV_UNSET2)
  512|     26|#ifdef HAVE_UNSETENV
  513|     52|    for (i = 0; i < n; i++) unsetenv(translateChar(STRING_ELT(nm, i)));
  ------------------
  |  | 1037|     26|#define translateChar		Rf_translateChar
  ------------------
  |  Branch (513:17): [True: 26, False: 26]
  ------------------
  514|       |#elif defined(HAVE_PUTENV_UNSET)
  515|       |    for (i = 0; i < n; i++) {
  516|       |	char buf[1000];
  517|       |	snprintf(buf, 1000, "%s",  translateChar(STRING_ELT(nm, i)));
  518|       |	putenv(buf);
  519|       |    }
  520|       |#elif defined(HAVE_PUTENV_UNSET2)
  521|       |# ifdef Win32
  522|       |    for (i = 0; i < n; i++) {
  523|       |	const wchar_t *w = wtransChar(STRING_ELT(nm, i));
  524|       |	wchar_t buf[2*wcslen(w)];
  525|       |	wcscpy(buf, w);
  526|       |	wcscat(buf, L"=");
  527|       |	_wputenv(buf);
  528|       |    }
  529|       |# else
  530|       |    for (i = 0; i < n; i++) {
  531|       |	char buf[1000];
  532|       |	snprintf(buf, 1000, "%s=", translateChar(STRING_ELT(nm, i)));
  533|       |	putenv(buf);
  534|       |    }
  535|       |# endif
  536|       |#endif
  537|       |
  538|       |#elif defined(HAVE_PUTENV) || defined(HAVE_SETENV)
  539|       |    warning(_("this system cannot unset environment variables: setting to \"\""));
  540|       |    n = LENGTH(nm);
  541|       |    for (i = 0; i < n; i++) {
  542|       |#ifdef HAVE_SETENV
  543|       |	setenv(translateChar(STRING_ELT(nm, i)), "", 1);
  544|       |#else
  545|       |	Rputenv(translateChar(STRING_ELT(nm, i)), "");
  546|       |#endif
  547|       |    }
  548|       |
  549|       |#else
  550|       |    warning(_("'Sys.unsetenv' is not available on this system"));
  551|       |#endif
  552|       |
  553|     26|    SEXP ans = PROTECT(allocVector(LGLSXP, n));
  ------------------
  |  |  357|     26|#define PROTECT(s)	Rf_protect(s)
  ------------------
  554|     52|    for (i = 0; i < n; i++)
  ------------------
  |  Branch (554:17): [True: 26, False: 26]
  ------------------
  555|     26|	LOGICAL(ans)[i] = !getenv(translateChar(STRING_ELT(nm, i)));
  ------------------
  |  | 1037|     26|#define translateChar		Rf_translateChar
  ------------------
  556|     26|    UNPROTECT(1);
  ------------------
  |  |  358|     26|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  557|     26|    return ans;
  558|     26|}
Rf_getCharCE:
  982|  2.33M|{
  983|  2.33M|    CHECK_CHARSXP(x);
  ------------------
  |  |  974|  2.33M|#define CHECK_CHARSXP(x) do { \
  |  |  975|  2.33M|    SEXP __x__ = (x);            \
  |  |  976|  2.33M|    if(TYPEOF(__x__) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|  2.33M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (976:8): [True: 0, False: 2.33M]
  |  |  ------------------
  |  |  977|  2.33M|	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  978|      0|	      __func__, R_typeToChar(__x__));			   \
  |  |  979|  2.33M|} while(0);
  |  |  ------------------
  |  |  |  Branch (979:9): [Folded, False: 2.33M]
  |  |  ------------------
  ------------------
  984|  2.33M|    if(IS_UTF8(x)) return CE_UTF8;
  ------------------
  |  Branch (984:8): [True: 0, False: 2.33M]
  ------------------
  985|  2.33M|    else if(IS_LATIN1(x)) return CE_LATIN1;
  ------------------
  |  Branch (985:13): [True: 0, False: 2.33M]
  ------------------
  986|  2.33M|    else if(IS_BYTES(x)) return CE_BYTES;
  ------------------
  |  Branch (986:13): [True: 0, False: 2.33M]
  ------------------
  987|  2.33M|    else return CE_NATIVE;
  988|  2.33M|}
Rf_translateChar:
 1879|  2.94M|{
 1880|  2.94M|    CHECK_CHARSXP(x);
  ------------------
  |  |  974|  2.94M|#define CHECK_CHARSXP(x) do { \
  |  |  975|  2.94M|    SEXP __x__ = (x);            \
  |  |  976|  2.94M|    if(TYPEOF(__x__) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|  2.94M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (976:8): [True: 0, False: 2.94M]
  |  |  ------------------
  |  |  977|  2.94M|	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  978|      0|	      __func__, R_typeToChar(__x__));			   \
  |  |  979|  2.94M|} while(0);
  |  |  ------------------
  |  |  |  Branch (979:9): [Folded, False: 2.94M]
  |  |  ------------------
  ------------------
 1881|  2.94M|    nttype_t t = needsTranslation(x);
 1882|  2.94M|    const char *ans = CHAR(x);
  ------------------
  |  |  203|  2.94M|#define CHAR(x) R_CHAR(x)
  ------------------
 1883|  2.94M|    if (t == NT_NONE) return ans;
  ------------------
  |  Branch (1883:9): [True: 2.94M, False: 0]
  ------------------
 1884|       |
 1885|      0|    R_StringBuffer cbuff = {NULL, 0, MAXELTSIZE};
  ------------------
  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
 1886|      0|    translateToNative(ans, &cbuff, t, 0);
 1887|      0|    return copyAndFreeStringBuffer(&cbuff);
 1888|  2.94M|}
Rf_translateCharFP:
 1893|  3.05k|{
 1894|  3.05k|    CHECK_CHARSXP(x);
  ------------------
  |  |  974|  3.05k|#define CHECK_CHARSXP(x) do { \
  |  |  975|  3.05k|    SEXP __x__ = (x);            \
  |  |  976|  3.05k|    if(TYPEOF(__x__) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|  3.05k|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (976:8): [True: 0, False: 3.05k]
  |  |  ------------------
  |  |  977|  3.05k|	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  978|      0|	      __func__, R_typeToChar(__x__));			   \
  |  |  979|  3.05k|} while(0);
  |  |  ------------------
  |  |  |  Branch (979:9): [Folded, False: 3.05k]
  |  |  ------------------
  ------------------
 1895|  3.05k|    nttype_t t = needsTranslation(x);
 1896|  3.05k|    const char *ans = CHAR(x);
  ------------------
  |  |  203|  3.05k|#define CHAR(x) R_CHAR(x)
  ------------------
 1897|  3.05k|    if (t == NT_NONE) return ans;
  ------------------
  |  Branch (1897:9): [True: 3.05k, False: 0]
  ------------------
 1898|       |
 1899|      0|    R_StringBuffer cbuff = {NULL, 0, MAXELTSIZE};
  ------------------
  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
 1900|      0|    translateToNative(ans, &cbuff, t, 1);
 1901|      0|    return copyAndFreeStringBuffer(&cbuff);
 1902|  3.05k|}
Rf_translateCharFP2:
 1908|    850|{
 1909|    850|    CHECK_CHARSXP(x);
  ------------------
  |  |  974|    850|#define CHECK_CHARSXP(x) do { \
  |  |  975|    850|    SEXP __x__ = (x);            \
  |  |  976|    850|    if(TYPEOF(__x__) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|    850|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (976:8): [True: 0, False: 850]
  |  |  ------------------
  |  |  977|    850|	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  978|      0|	      __func__, R_typeToChar(__x__));			   \
  |  |  979|    850|} while(0);
  |  |  ------------------
  |  |  |  Branch (979:9): [Folded, False: 850]
  |  |  ------------------
  ------------------
 1910|    850|    nttype_t t = needsTranslation(x);
 1911|    850|    const char *ans = CHAR(x);
  ------------------
  |  |  203|    850|#define CHAR(x) R_CHAR(x)
  ------------------
 1912|    850|    if (t == NT_NONE) return ans;
  ------------------
  |  Branch (1912:9): [True: 850, False: 0]
  ------------------
 1913|       |
 1914|      0|    R_StringBuffer cbuff = {NULL, 0, MAXELTSIZE};
  ------------------
  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
 1915|      0|    if (translateToNative(ans, &cbuff, t, 2))
  ------------------
  |  Branch (1915:9): [True: 0, False: 0]
  ------------------
 1916|      0|	return NULL; /* buffer already released */
 1917|      0|    return copyAndFreeStringBuffer(&cbuff);
 1918|      0|}
Rf_installTrChar:
 1921|  1.60M|{
 1922|  1.60M|    CHECK_CHARSXP(x);
  ------------------
  |  |  974|  1.60M|#define CHECK_CHARSXP(x) do { \
  |  |  975|  1.60M|    SEXP __x__ = (x);            \
  |  |  976|  1.60M|    if(TYPEOF(__x__) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|  1.60M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (976:8): [True: 0, False: 1.60M]
  |  |  ------------------
  |  |  977|  1.60M|	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  978|      0|	      __func__, R_typeToChar(__x__));			   \
  |  |  979|  1.60M|} while(0);
  |  |  ------------------
  |  |  |  Branch (979:9): [Folded, False: 1.60M]
  |  |  ------------------
  ------------------
 1923|  1.60M|    nttype_t t = needsTranslation(x);
 1924|  1.60M|    if (t == NT_NONE) return installNoTrChar(x);
  ------------------
  |  |  936|  1.60M|#define installNoTrChar		Rf_installNoTrChar
  ------------------
  |  Branch (1924:9): [True: 1.60M, False: 0]
  ------------------
 1925|       |
 1926|      0|    R_StringBuffer cbuff = {NULL, 0, MAXELTSIZE};
  ------------------
  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
 1927|       |    // For back-compatibility this allows installing
 1928|       |    // symbols with escapes, with a warning.  The warning is signalled
 1929|       |    // once the buffer has been released, as options(warn = 2) makes it
 1930|       |    // an error.
 1931|      0|    bool failed = translateToNative(CHAR(x), &cbuff, t, 0);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1932|      0|    char err_buff[256];
 1933|      0|    if (failed)
  ------------------
  |  Branch (1933:9): [True: 0, False: 0]
  ------------------
 1934|      0|	truncateForMessage(err_buff, cbuff.data);
 1935|       |
 1936|       |    /* install() raises this itself, but then the buffer would leak. */
 1937|      0|    if (strlen(cbuff.data) > MAXIDSIZE) {
  ------------------
  |  | 1175|      0|#define MAXIDSIZE 10000	/* Largest symbol size,
  ------------------
  |  Branch (1937:9): [True: 0, False: 0]
  ------------------
 1938|      0|	R_FreeStringBuffer(&cbuff);
 1939|      0|	error(_("variable names are limited to %d bytes"), MAXIDSIZE);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("variable names are limited to %d bytes"), MAXIDSIZE);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              	error(_("variable names are limited to %d bytes"), MAXIDSIZE);
  ------------------
  |  | 1175|      0|#define MAXIDSIZE 10000	/* Largest symbol size,
  ------------------
 1940|      0|    }
 1941|      0|    SEXP Sans = install(cbuff.data);
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 1942|      0|    R_FreeStringBuffer(&cbuff);
 1943|      0|    if (failed)
  ------------------
  |  Branch (1943:9): [True: 0, False: 0]
  ------------------
 1944|      0|	warning(_("unable to translate '%s' to native encoding"), err_buff);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("unable to translate '%s' to native encoding"), err_buff);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1945|      0|    return Sans;
 1946|  1.60M|}
Rf_translateCharUTF8:
 2064|     24|{
 2065|     24|    CHECK_CHARSXP(x);
  ------------------
  |  |  974|     24|#define CHECK_CHARSXP(x) do { \
  |  |  975|     24|    SEXP __x__ = (x);            \
  |  |  976|     24|    if(TYPEOF(__x__) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|     24|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (976:8): [True: 0, False: 24]
  |  |  ------------------
  |  |  977|     24|	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  978|      0|	      __func__, R_typeToChar(__x__));			   \
  |  |  979|     24|} while(0);
  |  |  ------------------
  |  |  |  Branch (979:9): [Folded, False: 24]
  |  |  ------------------
  ------------------
 2066|     24|    nttype_t t = needsTranslationUTF8(x);
 2067|     24|    const char *ans = CHAR(x);
  ------------------
  |  |  203|     24|#define CHAR(x) R_CHAR(x)
  ------------------
 2068|     24|    if (t == NT_NONE) return ans;
  ------------------
  |  Branch (2068:9): [True: 24, False: 0]
  ------------------
 2069|       |
 2070|      0|    R_StringBuffer cbuff = {NULL, 0, MAXELTSIZE};
  ------------------
  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
 2071|      0|    translateToUTF8(ans, &cbuff, t, 0);
 2072|      0|    return copyAndFreeStringBuffer(&cbuff);
 2073|     24|}
Rf_trCharUTF8:
 2079|      4|{
 2080|      4|    CHECK_CHARSXP(x);
  ------------------
  |  |  974|      4|#define CHECK_CHARSXP(x) do { \
  |  |  975|      4|    SEXP __x__ = (x);            \
  |  |  976|      4|    if(TYPEOF(__x__) != CHARSXP) \
  |  |  ------------------
  |  |  |  |  120|      4|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  |  |  ------------------
  |  |  |  Branch (976:8): [True: 0, False: 4]
  |  |  ------------------
  |  |  977|      4|	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  |   88|      0|#define error Rf_error
  |  |  ------------------
  |  |               	error(_("'%s' must be called on a CHARSXP, but got '%s'"), \
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  978|      0|	      __func__, R_typeToChar(__x__));			   \
  |  |  979|      4|} while(0);
  |  |  ------------------
  |  |  |  Branch (979:9): [Folded, False: 4]
  |  |  ------------------
  ------------------
 2081|      4|    nttype_t t = needsTranslationUTF8(x);
 2082|      4|    const char *ans = CHAR(x);
  ------------------
  |  |  203|      4|#define CHAR(x) R_CHAR(x)
  ------------------
 2083|      4|    if (t == NT_NONE) return ans;
  ------------------
  |  Branch (2083:9): [True: 4, False: 0]
  ------------------
 2084|       |
 2085|      0|    R_StringBuffer cbuff = {NULL, 0, MAXELTSIZE};
  ------------------
  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
 2086|      0|    translateToUTF8(ans, &cbuff, t, 1);
 2087|      0|    return copyAndFreeStringBuffer(&cbuff);
 2088|      4|}
R_isWriteableDir:
 2650|      6|{
 2651|       |#ifdef Win32
 2652|       |    struct _stati64 sb;
 2653|       |#else
 2654|      6|    struct stat sb;
 2655|      6|#endif
 2656|      6|    int isdir = 0;
 2657|      6|    if(!path) return 0;
  ------------------
  |  Branch (2657:8): [True: 6, False: 0]
  ------------------
 2658|       |#ifdef Win32
 2659|       |    if(_stati64(path, &sb) == 0) {
 2660|       |#else
 2661|      0|    if(stat(path, &sb) == 0) {
  ------------------
  |  Branch (2661:8): [True: 0, False: 0]
  ------------------
 2662|      0|#endif
 2663|      0|	isdir = (sb.st_mode & S_IFDIR) > 0; /* is a directory */
 2664|      0|#ifdef HAVE_ACCESS
 2665|       |	/* We want to know if the directory is writable by this user,
 2666|       |	   which mode does not tell us */
 2667|       |	isdir &= (access(path, W_OK) == 0);
 2668|      0|#endif
 2669|      0|    }
 2670|      0|    return isdir;
 2671|      6|}
R_reInitTempDir:
 2689|      2|{
 2690|      2|    char *tmp = NULL, *tm;
 2691|      2|    size_t len;
 2692|       |
 2693|      2|#define ERROR_MAYBE_DIE(MSG_) do {		\
 2694|      2|    if(die_on_fail)				\
 2695|      2|	R_Suicide(MSG_);			\
 2696|      2|    else					\
 2697|      2|	errorcall(R_NilValue, MSG_);            \
 2698|      2|} while (0)
 2699|       |
 2700|      2|    if(R_TempDir) return; /* someone else set it */
  ------------------
  |  Branch (2700:8): [True: 0, False: 2]
  ------------------
 2701|       |    /* getenv("R_SESSION_TMPDIR");   no longer set in R.sh */
 2702|       |
 2703|      2|    tm = getenv("TMPDIR");
 2704|      2|    if (!R_isWriteableDir(tm)) {
  ------------------
  |  Branch (2704:9): [True: 2, False: 0]
  ------------------
 2705|      2|	tm = getenv("TMP");
 2706|      2|	if (!R_isWriteableDir(tm)) {
  ------------------
  |  Branch (2706:6): [True: 2, False: 0]
  ------------------
 2707|      2|	    tm = getenv("TEMP");
 2708|      2|	    if (!R_isWriteableDir(tm)) {
  ------------------
  |  Branch (2708:10): [True: 2, False: 0]
  ------------------
 2709|       |#ifdef Win32
 2710|       |		tm = getenv("R_USER"); /* this one will succeed */
 2711|       |		if (!tm)
 2712|       |		    ERROR_MAYBE_DIE(_("'R_USER' not set"));
 2713|       |#else
 2714|      2|		tm = "/tmp";
 2715|      2|#endif
 2716|      2|	    }
 2717|      2|	}
 2718|      2|    }
 2719|       |
 2720|       |    /* make sure no spaces in path */
 2721|      2|    int hasspace = 0;
 2722|      2|    char *p;
 2723|     10|    for (p = tm; *p; p++)
  ------------------
  |  Branch (2723:18): [True: 8, False: 2]
  ------------------
 2724|      8|	if (isspace(*p)) { hasspace = 1; break; }
  ------------------
  |  Branch (2724:6): [True: 0, False: 8]
  ------------------
 2725|       |#ifdef Win32
 2726|       |    char *suffix = "\\RtmpXXXXXX";
 2727|       |    if (hasspace) {
 2728|       |	DWORD res = GetShortPathName(tm, NULL, 0);
 2729|       |	if (res > 0) {
 2730|       |	    len = res + strlen(suffix);
 2731|       |	    tmp = (char *)malloc(len);
 2732|       |	    if (!tmp)
 2733|       |		ERROR_MAYBE_DIE(_("cannot allocate 'R_TempDir'"));
 2734|       |	    DWORD res1 = GetShortPathName(tm, tmp, res);
 2735|       |	    if (res1 > 0 && res1 < res)
 2736|       |		strcat(tmp, suffix);
 2737|       |	    else { /* very unlikely */
 2738|       |		free(tmp);
 2739|       |		tmp = NULL;
 2740|       |	    }
 2741|       |	}
 2742|       |	if (tmp) {
 2743|       |	    /* GetShortPathName may return a long name, so check again */
 2744|       |	    hasspace = 0;
 2745|       |	    for (p = tmp; *p; p++)
 2746|       |		if (isspace(*p)) { hasspace = 1; break; }
 2747|       |	}
 2748|       |    }
 2749|       |#else
 2750|      2|    char *suffix = "/RtmpXXXXXX";
 2751|      2|#endif
 2752|      2|    if (hasspace) {
  ------------------
  |  Branch (2752:9): [True: 0, False: 2]
  ------------------
 2753|      0|	if (tmp)
  ------------------
  |  Branch (2753:6): [True: 0, False: 0]
  ------------------
 2754|      0|	    free(tmp);
 2755|      0|	ERROR_MAYBE_DIE(_("'R_TempDir' contains space"));
  ------------------
  |  | 2693|      0|#define ERROR_MAYBE_DIE(MSG_) do {		\
  |  | 2694|      0|    if(die_on_fail)				\
  |  |  ------------------
  |  |  |  Branch (2694:8): [True: 0, False: 0]
  |  |  ------------------
  |  | 2695|      0|	R_Suicide(MSG_);			\
  |  | 2696|      0|    else					\
  |  | 2697|      0|	errorcall(R_NilValue, MSG_);            \
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  | 2698|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (2698:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2756|      0|    }
 2757|      2|    if (!tmp) {
  ------------------
  |  Branch (2757:9): [True: 2, False: 0]
  ------------------
 2758|      2|	len = strlen(tm) + strlen(suffix) + 1;
 2759|      2|	tmp = (char *)malloc(len);
 2760|      2|	if (!tmp)
  ------------------
  |  Branch (2760:6): [True: 0, False: 2]
  ------------------
 2761|      0|	    ERROR_MAYBE_DIE(_("cannot allocate 'R_TempDir'"));
  ------------------
  |  | 2693|      0|#define ERROR_MAYBE_DIE(MSG_) do {		\
  |  | 2694|      0|    if(die_on_fail)				\
  |  |  ------------------
  |  |  |  Branch (2694:8): [True: 0, False: 0]
  |  |  ------------------
  |  | 2695|      0|	R_Suicide(MSG_);			\
  |  | 2696|      0|    else					\
  |  | 2697|      0|	errorcall(R_NilValue, MSG_);            \
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  | 2698|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (2698:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2762|      2|	strcpy(tmp, tm);
 2763|      2|	strcat(tmp, suffix);
 2764|      2|    }
 2765|      2|    if(!mkdtemp(tmp)) {
  ------------------
  |  Branch (2765:8): [True: 0, False: 2]
  ------------------
 2766|      0|	free(tmp);
 2767|      0|	ERROR_MAYBE_DIE(_("cannot create 'R_TempDir'"));
  ------------------
  |  | 2693|      0|#define ERROR_MAYBE_DIE(MSG_) do {		\
  |  | 2694|      0|    if(die_on_fail)				\
  |  |  ------------------
  |  |  |  Branch (2694:8): [True: 0, False: 0]
  |  |  ------------------
  |  | 2695|      0|	R_Suicide(MSG_);			\
  |  | 2696|      0|    else					\
  |  | 2697|      0|	errorcall(R_NilValue, MSG_);            \
  |  |  ------------------
  |  |  |  |  912|      0|#define errorcall		Rf_errorcall
  |  |  ------------------
  |  | 2698|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (2698:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2768|      0|    }
 2769|      2|#ifndef Win32
 2770|      2|# ifdef HAVE_SETENV
 2771|      2|    if(setenv("R_SESSION_TMPDIR", tmp, 1)) {
  ------------------
  |  Branch (2771:8): [True: 0, False: 2]
  ------------------
 2772|      0|	free(tmp);
 2773|      0|	errorcall(R_NilValue, _("unable to set R_SESSION_TMPDIR"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(R_NilValue, _("unable to set R_SESSION_TMPDIR"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2774|      0|    }
 2775|       |# elif defined(HAVE_PUTENV)
 2776|       |    {
 2777|       |	len = strlen(tmp) + 20;
 2778|       |	char * buf = (char *) malloc((len) * sizeof(char));
 2779|       |	if(buf) {
 2780|       |	    snprintf(buf, len, "R_SESSION_TMPDIR=%s", tmp);
 2781|       |	    if(putenv(buf)) {
 2782|       |		free(tmp);
 2783|       |		free(buf);
 2784|       |		errorcall(R_NilValue, _("unable to set R_SESSION_TMPDIR"));
 2785|       |	    }
 2786|       |	    /* no free here: storage remains in use */
 2787|       |	} else {
 2788|       |	    free(tmp);
 2789|       |	    errorcall(R_NilValue, _("unable to set R_SESSION_TMPDIR"));
 2790|       |	}
 2791|       |    }
 2792|       |# endif
 2793|      2|#endif
 2794|      2|    R_TempDir = tmp;
 2795|      2|    Sys_TempDir = tmp;
 2796|      2|}
Rf_InitTempDir:
 2798|      2|attribute_hidden void InitTempDir(void) {
 2799|      2|    R_reInitTempDir(/* die_on_fail = */ TRUE);
 2800|      2|}
R_tmpnam2:
 2814|      2|{
 2815|      2|    unsigned int n, pid = getpid();
 2816|       |#ifdef Win32
 2817|       |    char filesep[] = "\\";
 2818|       |#else
 2819|      2|    char filesep[] = "/";
 2820|      2|#endif
 2821|       |
 2822|      2|    if(!prefix) prefix = "";	/* NULL */
  ------------------
  |  Branch (2822:8): [True: 2, False: 0]
  ------------------
 2823|      2|    if(!fileext) fileext = "";  /*  "   */
  ------------------
  |  Branch (2823:8): [True: 0, False: 2]
  ------------------
 2824|       |
 2825|      2|    for (n = 0; n < 100; n++) {
  ------------------
  |  Branch (2825:17): [True: 2, False: 0]
  ------------------
 2826|       |	/* try a random number at the end.  Need at least 6 hex digits */
 2827|      2|	int r1 = rand();
 2828|      2|#if RAND_MAX > 16777215
 2829|      2|# define TMPNAM2_SNPRINTF(BUF, SIZE) \
 2830|      2|	snprintf(BUF, SIZE, "%s%s%s%x%x%s", tempdir, filesep, prefix, pid, r1, fileext)
 2831|       |#else
 2832|       |	int r2 = rand();
 2833|       |# define TMPNAM2_SNPRINTF(BUF, SIZE) \
 2834|       |	snprintf(BUF, SIZE, "%s%s%s%x%x%x%s", tempdir, filesep, prefix, pid, r1, r2, fileext)
 2835|       |#endif
 2836|      2|	size_t needed = TMPNAM2_SNPRINTF(NULL, 0) + 1;
  ------------------
  |  | 2830|      2|	snprintf(BUF, SIZE, "%s%s%s%x%x%s", tempdir, filesep, prefix, pid, r1, fileext)
  ------------------
 2837|      2|#ifdef Unix
 2838|      2|	if (needed > R_PATH_MAX)
  ------------------
  |  | 1150|      2|# define R_PATH_MAX PATH_MAX
  ------------------
  |  Branch (2838:6): [True: 0, False: 2]
  ------------------
 2839|      0|	    error(_("temporary name too long"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("temporary name too long"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2840|      2|#endif
 2841|      2|	char *res = (char *) malloc(needed);
 2842|      2|	if(!res)
  ------------------
  |  Branch (2842:5): [True: 0, False: 2]
  ------------------
 2843|      0|	    error(_("allocation failed in R_tmpnam2"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("allocation failed in R_tmpnam2"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2844|      2|	TMPNAM2_SNPRINTF(res, needed);
  ------------------
  |  | 2830|      2|	snprintf(BUF, SIZE, "%s%s%s%x%x%s", tempdir, filesep, prefix, pid, r1, fileext)
  ------------------
 2845|      2|	if (!R_FileExists(res))
  ------------------
  |  Branch (2845:6): [True: 2, False: 0]
  ------------------
 2846|      2|	    return res;
 2847|      0|	free(res);
 2848|      0|    }
 2849|      0|    error(_("cannot find unused tempfile name"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  error(_("cannot find unused tempfile name"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2850|      0|}
resetTimeLimits:
 2877|    104|{
 2878|    104|    double data[5];
 2879|    104|    R_getProcTime(data);
 2880|       |
 2881|    104|    elapsedLimit = (elapsedLimitValue > 0) ? data[2] + elapsedLimitValue : -1.0;
  ------------------
  |  Branch (2881:20): [True: 0, False: 104]
  ------------------
 2882|    104|    if (elapsedLimit2 > 0.0 &&
  ------------------
  |  Branch (2882:9): [True: 0, False: 104]
  ------------------
 2883|      0|	(elapsedLimit <= 0.0 || elapsedLimit2 < elapsedLimit))
  ------------------
  |  Branch (2883:3): [True: 0, False: 0]
  |  Branch (2883:26): [True: 0, False: 0]
  ------------------
 2884|      0|	elapsedLimit = elapsedLimit2;
 2885|       |
 2886|       |#ifdef Win32
 2887|       |    cpuLimit = (cpuLimitValue > 0) ? data[0] + data[1] + cpuLimitValue : -1.0;
 2888|       |#else
 2889|    104|    cpuLimit = (cpuLimitValue > 0) ? data[0] + data[1] + data[3] + data[4] + cpuLimitValue : -1.0;
  ------------------
  |  Branch (2889:16): [True: 0, False: 104]
  ------------------
 2890|    104|#endif
 2891|    104|    if (cpuLimit2 > 0.0 && (cpuLimit <= 0.0 || cpuLimit2 < cpuLimit))
  ------------------
  |  Branch (2891:9): [True: 0, False: 104]
  |  Branch (2891:29): [True: 0, False: 0]
  |  Branch (2891:48): [True: 0, False: 0]
  ------------------
 2892|      0|	cpuLimit = cpuLimit2;
 2893|    104|}
do_glob:
 3013|      2|{
 3014|      2|    SEXP x, ans;
 3015|      2|    R_xlen_t i, n;
 3016|      2|    int res, dirmark;
 3017|      2|    bool initialized = false;
 3018|      2|    glob_t globbuf;
 3019|       |#ifdef Win32
 3020|       |    R_StringBuffer cbuff = {NULL, 0, MAXELTSIZE};
 3021|       |#endif
 3022|       |
 3023|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 3024|      2|    if (!isString(x = CAR(args)))
  ------------------
  |  |  966|      2|#define isString		Rf_isString
  ------------------
  |  Branch (3024:9): [True: 0, False: 2]
  ------------------
 3025|      0|	error(_("invalid '%s' argument"), "paths");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "paths");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3026|      2|    if (!XLENGTH(x)) return allocVector(STRSXP, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
                  if (!XLENGTH(x)) return allocVector(STRSXP, 0);
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (3026:9): [True: 0, False: 2]
  ------------------
 3027|      2|    dirmark = asLogical(CADR(args));
  ------------------
  |  |  886|      2|#define asLogical		Rf_asLogical
  ------------------
 3028|      2|    if (dirmark == NA_LOGICAL)
  ------------------
  |  |   55|      2|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (3028:9): [True: 0, False: 2]
  ------------------
 3029|      0|	error(_("invalid '%s' argument"), "dirmark");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "dirmark");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3030|       |#ifndef GLOB_MARK
 3031|       |    if (dirmark)
 3032|       |	error(_("'dirmark = TRUE' is not supported on this platform"));
 3033|       |#endif
 3034|       |
 3035|      4|    for (i = 0; i < XLENGTH(x); i++) {
  ------------------
  |  Branch (3035:17): [True: 2, False: 2]
  ------------------
 3036|      2|	SEXP el = STRING_ELT(x, i);
 3037|      2|	if (el == NA_STRING) continue;
  ------------------
  |  |  433|      2|#define NA_STRING	R_NaString
  ------------------
  |  Branch (3037:6): [True: 0, False: 2]
  ------------------
 3038|       |#ifdef Win32
 3039|       |	res = dos_wglob(filenameToWchar(el, FALSE),
 3040|       |			(dirmark ? GLOB_MARK : 0) |
 3041|       |			GLOB_QUOTE | (initialized ? GLOB_APPEND : 0),
 3042|       |			NULL, &globbuf);
 3043|       |	if (res == GLOB_NOSPACE)
 3044|       |	    error(_("internal out-of-memory condition"));
 3045|       |#else
 3046|      2|	res = glob(translateChar(el),
  ------------------
  |  | 1037|      2|#define translateChar		Rf_translateChar
  ------------------
 3047|      2|# ifdef GLOB_MARK
 3048|      2|		   (dirmark ? GLOB_MARK : 0) |
  ------------------
  |  Branch (3048:7): [True: 0, False: 2]
  ------------------
 3049|      2|# endif
 3050|      2|		   GLOB_QUOTE | (initialized ? GLOB_APPEND : 0),
  ------------------
  |  | 3009|      2|#  define GLOB_QUOTE 0
  ------------------
  |  Branch (3050:20): [True: 0, False: 2]
  ------------------
 3051|      2|		   NULL, &globbuf);
 3052|      2|# ifdef GLOB_ABORTED
 3053|      2|	if (res == GLOB_ABORTED)
  ------------------
  |  Branch (3053:6): [True: 0, False: 2]
  ------------------
 3054|      0|	    warning(_("read error on '%s'"), translateChar(el));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("read error on '%s'"), translateChar(el));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
              	    warning(_("read error on '%s'"), translateChar(el));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
 3055|      2|# endif
 3056|      2|# ifdef GLOB_NOSPACE
 3057|      2|	if (res == GLOB_NOSPACE)
  ------------------
  |  Branch (3057:6): [True: 0, False: 2]
  ------------------
 3058|      0|	    error(_("internal out-of-memory condition"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("internal out-of-memory condition"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3059|      2|# endif
 3060|      2|#endif
 3061|      2|	initialized = true;
 3062|      2|    }
 3063|      2|    n = initialized ? globbuf.gl_pathc : 0;
  ------------------
  |  Branch (3063:9): [True: 2, False: 0]
  ------------------
 3064|      2|    PROTECT(ans = allocVector(STRSXP, n));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3065|      2|    for (i = 0; i < n; i++)
  ------------------
  |  Branch (3065:17): [True: 0, False: 2]
  ------------------
 3066|       |#ifdef Win32
 3067|       |    {
 3068|       |	wchar_t *w = globbuf.gl_pathv[i];
 3069|       |	char *buf;
 3070|       |	size_t nb = wcstoutf8(NULL, w, (size_t)INT_MAX + 2);
 3071|       |	buf = R_AllocStringBuffer(nb, &cbuff);
 3072|       |	wcstoutf8(buf, w, nb);
 3073|       |	SET_STRING_ELT(ans, i, mkCharCE(buf, CE_UTF8));
 3074|       |    }
 3075|       |#else
 3076|      0|	SET_STRING_ELT(ans, i, mkChar(globbuf.gl_pathv[i]));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 3077|      2|#endif
 3078|      2|    UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3079|       |#ifdef Win32
 3080|       |    R_FreeStringBufferL(&cbuff);
 3081|       |#endif
 3082|      2|    if (initialized) globfree(&globbuf);
  ------------------
  |  Branch (3082:9): [True: 2, False: 0]
  ------------------
 3083|      2|    return ans;
 3084|      2|}
R_isatty:
 3141|      2|{
 3142|       |#ifdef Win32
 3143|       |    if (R_is_redirection_tty(fd))
 3144|       |	return 1;
 3145|       |#endif
 3146|      2|    return isatty(fd);
 3147|      2|}
sysutils.c:needsTranslation:
 1705|  4.55M|{
 1706|  4.55M|    if (IS_ASCII(x)) return NT_NONE;
  ------------------
  |  Branch (1706:9): [True: 4.54M, False: 3.24k]
  ------------------
 1707|  3.24k|    if (IS_UTF8(x)) {
  ------------------
  |  Branch (1707:9): [True: 0, False: 3.24k]
  ------------------
 1708|      0|	if (utf8locale || x == NA_STRING) return NT_NONE;
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1708:6): [True: 0, False: 0]
  |  Branch (1708:20): [True: 0, False: 0]
  ------------------
 1709|      0|	return NT_FROM_UTF8;
 1710|      0|    }
 1711|  3.24k|    if (IS_LATIN1(x)) {
  ------------------
  |  Branch (1711:9): [True: 0, False: 3.24k]
  ------------------
 1712|      0|	if (x == NA_STRING || latin1locale) return NT_NONE;
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1712:6): [True: 0, False: 0]
  |  Branch (1712:24): [True: 0, False: 0]
  ------------------
 1713|      0|	return NT_FROM_LATIN1;
 1714|      0|    }
 1715|  3.24k|    if (IS_BYTES(x))
  ------------------
  |  Branch (1715:9): [True: 0, False: 3.24k]
  ------------------
 1716|      0|	error(_("translating strings with \"bytes\" encoding is not allowed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("translating strings with \"bytes\" encoding is not allowed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1717|  3.24k|    return NT_NONE;
 1718|  3.24k|}
sysutils.c:needsTranslationUTF8:
 1971|     28|{
 1972|     28|    if (IS_UTF8(x) || IS_ASCII(x) || x == NA_STRING) return NT_NONE;
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1972:9): [True: 0, False: 28]
  |  Branch (1972:23): [True: 28, False: 0]
  |  Branch (1972:38): [True: 0, False: 0]
  ------------------
 1973|      0|    if (IS_BYTES(x))
  ------------------
  |  Branch (1973:9): [True: 0, False: 0]
  ------------------
 1974|      0|	error(_("translating strings with \"bytes\" encoding is not allowed"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("translating strings with \"bytes\" encoding is not allowed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1975|      0|    if (IS_LATIN1(x) || latin1locale) return NT_FROM_LATIN1;
  ------------------
  |  Branch (1975:9): [True: 0, False: 0]
  |  Branch (1975:25): [True: 0, False: 0]
  ------------------
 1976|      0|    if (utf8locale) return NT_NONE;
  ------------------
  |  Branch (1976:9): [True: 0, False: 0]
  ------------------
 1977|      0|    return NT_FROM_NATIVE;
 1978|      0|}

Rf_currentTime:
   94|    106|{
   95|    106|    double ans = NA_REAL;
  ------------------
  |  |   58|    106|#define NA_REAL		R_NaReal
  ------------------
   96|       |
   97|    106|#ifdef HAVE_TIMESPEC_GET
   98|    106|    struct timespec tp;
   99|    106|    int res = timespec_get(&tp, TIME_UTC);
  100|    106|    if(res != 0)
  ------------------
  |  Branch (100:8): [True: 106, False: 0]
  ------------------
  101|    106|	ans = (double) tp.tv_sec + 1e-9 * (double) tp.tv_nsec;
  102|       |#elif defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
  103|       |    /* Has 2038 issue if time_t: tv.tv_sec is 32-bit. */
  104|       |    struct timespec tp;
  105|       |    int res = clock_gettime(CLOCK_REALTIME, &tp);
  106|       |    if(res == 0)
  107|       |	ans = (double) tp.tv_sec + 1e-9 * (double) tp.tv_nsec;
  108|       |
  109|       |#elif defined(HAVE_GETTIMEOFDAY)
  110|       |    /* macOS , mingw.org, used on mingw-w64.
  111|       |       Has 2038 issue if time_t: tv.tv_sec is 32-bit.
  112|       |     */
  113|       |    struct timeval tv;
  114|       |    int res = gettimeofday(&tv, NULL);
  115|       |    if(res == 0)
  116|       |	ans = (double) tv.tv_sec + 1e-6 * (double) tv.tv_usec;
  117|       |
  118|       |#else
  119|       |    /* No known current OSes */
  120|       |    time_t res = time(NULL);
  121|       |    if(res != (time_t)(-1)) /* -1 must be an error as the real value -1
  122|       |			       was ca 1969 */
  123|       |	ans = (double) res;
  124|       |#endif
  125|       |
  126|       |#ifndef HAVE_POSIX_LEAPSECONDS
  127|       |    /* No known current OSes */
  128|       |    /* Disallowed by POSIX (1988-):
  129|       |       http://www.mail-archive.com/leapsecs@rom.usno.navy.mil/msg00109.html
  130|       |       https://en.wikipedia.org/wiki/Unix_time
  131|       |    */
  132|       |    if (!ISNAN(ans)) {
  133|       |	ans -= n_leapseconds;
  134|       |    }
  135|       |#endif
  136|    106|    return ans;
  137|    106|}
Rf_TimeToSeed:
  151|      2|{
  152|      2|    unsigned int seed, pid = getpid();
  153|      2|#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
  154|      2|    {
  155|      2|	struct timespec tp;
  156|      2|	clock_gettime(CLOCK_REALTIME, &tp);
  157|      2|	seed = (unsigned int)(((uint_least64_t) tp.tv_nsec << 16) ^ tp.tv_sec);
  158|      2|    }
  159|       |#elif defined(HAVE_GETTIMEOFDAY)
  160|       |    {
  161|       |	struct timeval tv;
  162|       |	gettimeofday (&tv, NULL);
  163|       |	seed = (unsigned int)(((uint_least64_t) tv.tv_usec << 16) ^ tv.tv_sec);
  164|       |    }
  165|       |#else
  166|       |    /* C89, so must work */
  167|       |    seed = (Int32) time(NULL);
  168|       |#endif
  169|      2|    seed ^= (pid <<16);
  170|      2|    return seed;
  171|      2|}

Rf_any_duplicated:
  983|     14|{
  984|     14|    R_xlen_t result = 0;
  985|     14|    int nmax = NA_INTEGER;
  ------------------
  |  |   56|     14|#define NA_INTEGER	R_NaInt
  ------------------
  986|       |
  987|     14|    if (!isVector(x)) error(_("'duplicated' applies only to vectors"));
  ------------------
  |  |  974|     14|#define isVector		Rf_isVector
  ------------------
                  if (!isVector(x)) error(_("'duplicated' applies only to vectors"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (!isVector(x)) error(_("'duplicated' applies only to vectors"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (987:9): [True: 0, False: 14]
  ------------------
  988|     14|    R_xlen_t i, n = XLENGTH(x);
  989|       |
  990|     14|    if(DUP_KNOWN_SORTED(x)) {
  ------------------
  |  |  824|     14|    ((TYPEOF(x) == INTSXP && KNOWN_SORTED(INTEGER_IS_SORTED(x))) ||	\
  |  |  ------------------
  |  |  |  |  123|     28|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |                   ((TYPEOF(x) == INTSXP && KNOWN_SORTED(INTEGER_IS_SORTED(x))) ||	\
  |  |  ------------------
  |  |  |  | 1162|      2|#define KNOWN_SORTED(sorted) (sorted == SORTED_DECR ||			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1162:31): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  | 1163|      2|			      sorted == SORTED_INCR ||			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1163:10): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  | 1164|      2|			      sorted == SORTED_DECR_NA_1ST ||		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1164:10): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  |  | 1165|      2|			      sorted == SORTED_INCR_NA_1ST)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1165:10): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (824:7): [True: 2, False: 12]
  |  |  ------------------
  |  |  825|     14|     (TYPEOF(x) == REALSXP && KNOWN_SORTED(REAL_IS_SORTED(x))))
  |  |  ------------------
  |  |  |  |  124|     28|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |                    (TYPEOF(x) == REALSXP && KNOWN_SORTED(REAL_IS_SORTED(x))))
  |  |  ------------------
  |  |  |  | 1162|      0|#define KNOWN_SORTED(sorted) (sorted == SORTED_DECR ||			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1162:31): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1163|      0|			      sorted == SORTED_INCR ||			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1163:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1164|      0|			      sorted == SORTED_DECR_NA_1ST ||		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1164:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1165|      0|			      sorted == SORTED_INCR_NA_1ST)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1165:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (825:7): [True: 0, False: 14]
  |  |  ------------------
  ------------------
  991|      0|    	return sorted_any_duplicated(x, from_last);
  992|      0|    }
  993|       |
  994|     14|    DUPLICATED_INIT;
  ------------------
  |  |  635|     14|    HashData data = { 0 };					\
  |  |  636|     14|    HashTableSetup(x, &data, nmax);				\
  |  |  637|     14|    data.useUTF8 = FALSE; data.useCache = TRUE;			\
  |  |  638|     14|    duplicatedInit(x, &data);
  ------------------
  995|     14|    PROTECT(data.HashTable);
  ------------------
  |  |  357|     14|#define PROTECT(s)	Rf_protect(s)
  ------------------
  996|       |
  997|     14|    if(from_last) {
  ------------------
  |  Branch (997:8): [True: 0, False: 14]
  ------------------
  998|      0|	for (i = n-1; i >= 0; i--) {
  ------------------
  |  Branch (998:16): [True: 0, False: 0]
  ------------------
  999|      0|	    if(isDuplicated(x, i, &data)) { result = ++i; break; }
  ------------------
  |  Branch (999:9): [True: 0, False: 0]
  ------------------
 1000|      0|	}
 1001|     14|    } else {
 1002|    520|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (1002:14): [True: 506, False: 14]
  ------------------
 1003|    506|	    if(isDuplicated(x, i, &data)) { result = ++i; break; }
  ------------------
  |  Branch (1003:9): [True: 0, False: 506]
  ------------------
 1004|    506|	}
 1005|     14|    }
 1006|     14|    UNPROTECT(1);
  ------------------
  |  |  358|     14|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1007|     14|    return result;
 1008|     14|}
do_duplicated:
 1102|    106|{
 1103|    106|    checkArity(op, args);
  ------------------
  |  | 1788|    106|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1104|    106|    SEXP x = CAR(args);
 1105|    106|    SEXP incomp = CADR(args);
 1106|    106|    if (length(CADDR(args)) < 1)
  ------------------
  |  |  987|    106|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1106:9): [True: 0, False: 106]
  ------------------
 1107|      0|	error(_("'fromLast' must be length 1"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'fromLast' must be length 1"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1108|    106|    int fromLast = asLogical(CADDR(args));
  ------------------
  |  |  886|    106|#define asLogical		Rf_asLogical
  ------------------
 1109|    106|    if (fromLast == NA_LOGICAL)
  ------------------
  |  |   55|    106|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1109:9): [True: 0, False: 106]
  ------------------
 1110|      0|	error(_("'fromLast' must be TRUE or FALSE"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'fromLast' must be TRUE or FALSE"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1111|    106|    Rboolean fL = (Rboolean) fromLast;
 1112|       |
 1113|       |    /* handle zero length vectors, and NULL */
 1114|    106|    R_xlen_t n = xlength(x);
  ------------------
  |  | 1049|    106|#define xlength(x)		Rf_xlength(x)
  ------------------
 1115|    106|    if (n == 0)
  ------------------
  |  Branch (1115:9): [True: 25, False: 81]
  ------------------
 1116|     25|	return(PRIMVAL(op) <= 1
  ------------------
  |  | 1347|     25|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1116:9): [True: 25, False: 0]
  ------------------
 1117|     25|	       ? allocVector(PRIMVAL(op) != 1 ? LGLSXP : TYPEOF(x), 0)
  ------------------
  |  |  875|     25|#define allocVector		Rf_allocVector
  ------------------
              	       ? allocVector(PRIMVAL(op) != 1 ? LGLSXP : TYPEOF(x), 0)
  ------------------
  |  | 1347|     25|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
              	       ? allocVector(PRIMVAL(op) != 1 ? LGLSXP : TYPEOF(x), 0)
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1117:23): [True: 0, False: 25]
  ------------------
 1118|     25|	       : ScalarInteger(0));
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
 1119|       |
 1120|     81|    if (!isVector(x)) {
  ------------------
  |  |  974|     81|#define isVector		Rf_isVector
  ------------------
  |  Branch (1120:9): [True: 0, False: 81]
  ------------------
 1121|      0|	error(_("%s() applies only to vectors"),
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("%s() applies only to vectors"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1122|      0|	      (PRIMVAL(op) == 0 ? "duplicated" :
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1122:9): [True: 0, False: 0]
  ------------------
 1123|      0|	       (PRIMVAL(op) == 1 ? "unique" : /* 2 */ "anyDuplicated")));
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1123:10): [True: 0, False: 0]
  ------------------
 1124|      0|    }
 1125|     81|    int nmax = NA_INTEGER;
  ------------------
  |  |   56|     81|#define NA_INTEGER	R_NaInt
  ------------------
 1126|     81|    if (PRIMVAL(op) <= 1) {
  ------------------
  |  | 1347|     81|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1126:9): [True: 67, False: 14]
  ------------------
 1127|     67|	nmax = asInteger(CADDDR(args));
  ------------------
  |  |  885|     67|#define asInteger		Rf_asInteger
  ------------------
 1128|     67|	if (nmax != NA_INTEGER && nmax <= 0)
  ------------------
  |  |   56|    134|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (1128:6): [True: 0, False: 67]
  |  Branch (1128:28): [True: 0, False: 0]
  ------------------
 1129|      0|	    error(_("'nmax' must be positive"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	    error(_("'nmax' must be positive"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1130|     67|    }
 1131|       |
 1132|     81|    SEXP dup;
 1133|     81|    if(length(incomp) && /* S has FALSE to mean empty */
  ------------------
  |  |  987|    162|#define length(x)		Rf_length(x)
  |  |  ------------------
  |  |  |  Branch (987:20): [True: 81, False: 0]
  |  |  ------------------
  ------------------
 1134|     81|       !(isLogical(incomp) && length(incomp) == 1 &&
  ------------------
  |  |  952|     81|#define isLogical		Rf_isLogical
  ------------------
                     !(isLogical(incomp) && length(incomp) == 1 &&
  ------------------
  |  |  987|     81|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1134:10): [True: 81, False: 0]
  |  Branch (1134:31): [True: 81, False: 0]
  ------------------
 1135|     81|	 LOGICAL_ELT(incomp, 0) == 0)) {
  ------------------
  |  Branch (1135:3): [True: 81, False: 0]
  ------------------
 1136|      0|	if(PRIMVAL(op) == 2) {
  ------------------
  |  | 1347|      0|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1136:5): [True: 0, False: 0]
  ------------------
 1137|       |	    /* return R's 1-based index :*/
 1138|      0|	    R_xlen_t ind  = any_duplicated3(x, incomp, fL);
  ------------------
  |  |  878|      0|#define any_duplicated3		Rf_any_duplicated3
  ------------------
 1139|      0|	    if(ind > INT_MAX) return ScalarReal((double) ind);
  ------------------
  |  | 1024|      0|#define ScalarReal		Rf_ScalarReal
  ------------------
  |  Branch (1139:9): [True: 0, False: 0]
  ------------------
 1140|      0|	    else return ScalarInteger((int)ind);
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
 1141|      0|	} else
 1142|      0|	    dup = duplicated3(x, incomp, fL, nmax);
 1143|      0|    }
 1144|     81|    else {
 1145|     81|	if(PRIMVAL(op) == 2) {
  ------------------
  |  | 1347|     81|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1145:5): [True: 14, False: 67]
  ------------------
 1146|     14|	    R_xlen_t ind  = any_duplicated(x, fL);
  ------------------
  |  |  877|     14|#define any_duplicated		Rf_any_duplicated
  ------------------
 1147|     14|	    if(ind > INT_MAX) return ScalarReal((double) ind);
  ------------------
  |  | 1024|      0|#define ScalarReal		Rf_ScalarReal
  ------------------
  |  Branch (1147:9): [True: 0, False: 14]
  ------------------
 1148|     14|	    else return ScalarInteger((int)ind);
  ------------------
  |  | 1022|     14|#define ScalarInteger		Rf_ScalarInteger
  ------------------
 1149|     14|	} else
 1150|     67|	    dup = Duplicated(x, fL, nmax);
 1151|     81|    }
 1152|     67|    if (PRIMVAL(op) == 0) /* "duplicated()" */
  ------------------
  |  | 1347|     67|#define PRIMVAL(x)	(R_FunTab[PRIMOFFSET(x)].code)
  ------------------
  |  Branch (1152:9): [True: 0, False: 67]
  ------------------
 1153|      0|	return dup;
 1154|       |    /*	ELSE
 1155|       |	use the results of "duplicated" to get "unique" */
 1156|       |
 1157|       |    /* count unique entries */
 1158|     67|    R_xlen_t i, k = 0;
 1159|     67|    PROTECT(dup);
  ------------------
  |  |  357|     67|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1160|     67|    ITERATE_BY_REGION(dup, duptr, idx, nb, int, LOGICAL, {
  ------------------
  |  |  251|     67|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|     67|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|     67|				  strt, nfull, expr) do {		\
  |  |  |  |  221|     67|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|     67|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 67, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|     67|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|     67|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|     67|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|     67|	    px += strt;							\
  |  |  |  |  227|     67|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 67, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|  13.4k|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 2.68k, False: 2]
  |  |  |  |  |  Branch (228:10): [True: 2.68k, False: 67]
  |  |  |  |  ------------------
  |  |  |  |  229|     67|	    }                                                           \
  |  |  |  |  230|     67|	}								\
  |  |  |  |  231|     67|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|     67|					strt, nfull, expr);		\
  |  |  |  |  233|     67|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 67]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|     67|				  0, XLENGTH(sx), expr);		\
  |  |  254|     67|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 67]
  |  |  ------------------
  ------------------
 1161|     67|	    for(R_xlen_t j=0; j < nb; j++)
 1162|     67|		if(duptr[j] == 0) k++;
 1163|     67|	});
 1164|       |
 1165|     67|    SEXP ans = PROTECT(allocVector(TYPEOF(x), k));
  ------------------
  |  |  357|     67|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1166|       |
 1167|     67|    k = 0;
 1168|     67|    switch (TYPEOF(x)) {
 1169|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1169:5): [True: 0, False: 67]
  ------------------
 1170|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (1170:14): [True: 0, False: 0]
  ------------------
 1171|      0|	    if (LOGICAL_ELT(dup, i) == 0)
  ------------------
  |  Branch (1171:10): [True: 0, False: 0]
  ------------------
 1172|      0|		LOGICAL0(ans)[k++] = LOGICAL_ELT(x, i);
 1173|      0|	break;
 1174|      8|    case INTSXP:
  ------------------
  |  |  123|      8|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1174:5): [True: 8, False: 59]
  ------------------
 1175|      8|	ITERATE_BY_REGION(dup, duptr, idx, nb, int, LOGICAL, {
  ------------------
  |  |  251|      8|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|      8|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|      8|				  strt, nfull, expr) do {		\
  |  |  |  |  221|      8|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|      8|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 8, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|      8|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|      8|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|      8|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|      8|	    px += strt;							\
  |  |  |  |  227|      8|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 8, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|     48|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 8, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 8, False: 8]
  |  |  |  |  ------------------
  |  |  |  |  229|      8|	    }                                                           \
  |  |  |  |  230|      8|	}								\
  |  |  |  |  231|      8|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|      8|					strt, nfull, expr);		\
  |  |  |  |  233|      8|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 8]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|      8|				  0, XLENGTH(sx), expr);		\
  |  |  254|      8|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 8]
  |  |  ------------------
  ------------------
 1176|      8|		for(R_xlen_t j = 0; j < nb; j++) {
 1177|      8|		    if(duptr[j] == 0)
 1178|      8|			INTEGER0(ans)[k++] = INTEGER_ELT(x, idx + j);
 1179|      8|		}
 1180|      8|	    });
 1181|      8|	break;
 1182|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1182:5): [True: 0, False: 67]
  ------------------
 1183|      0|	ITERATE_BY_REGION(dup, duptr, idx, nb, int, LOGICAL, {
  ------------------
  |  |  251|      0|#define ITERATE_BY_REGION(sx, px, idx, nb, etype, vtype, expr) do {	\
  |  |  252|      0|	ITERATE_BY_REGION_PARTIAL(sx, px, idx, nb, etype, vtype,	\
  |  |  ------------------
  |  |  |  |  220|      0|				  strt, nfull, expr) do {		\
  |  |  |  |  221|      0|	const etype *px = (etype *) DATAPTR_OR_NULL(sx);		\
  |  |  |  |  222|      0|	if (px != NULL) {						\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (222:6): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  223|      0|	    R_xlen_t idx = strt;					\
  |  |  |  |  224|      0|	    (void) idx; /* variable may be unused in expr */		\
  |  |  |  |  225|      0|	    R_xlen_t nb = nfull;					\
  |  |  |  |  226|      0|	    px += strt;							\
  |  |  |  |  227|      0|	    if (nb > 0) {                                               \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (227:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  228|      0|	        expr							\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  |  Branch (228:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  229|      0|	    }                                                           \
  |  |  |  |  230|      0|	}								\
  |  |  |  |  231|      0|	else ITERATE_BY_REGION_PARTIAL0(sx, px, idx, nb, etype, vtype,	\
  |  |  |  |  ------------------
  |  |  |  |  |  |  191|      0|				   strt, nfull, expr) do {		\
  |  |  |  |  |  |  192|      0|	etype __ibr_buf__[GET_REGION_BUFSIZE];				\
  |  |  |  |  |  |  193|      0|	R_xlen_t __ibr_n__ = strt + nfull;				\
  |  |  |  |  |  |  194|      0|	R_xlen_t nb;							\
  |  |  |  |  |  |  195|      0|	for (R_xlen_t idx = strt; idx < __ibr_n__; idx += nb) {		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (195:28): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  196|      0|	    nb = __ibr_n__  - idx > GET_REGION_BUFSIZE ?		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (196:11): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  197|      0|		GET_REGION_BUFSIZE :  __ibr_n__ - idx;			\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  181|      0|#define GET_REGION_BUFSIZE 512
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  198|      0|	    etype *px = (etype *) GET_REGION_PTR(sx, idx, nb,		\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  187|      0|    (ALTREP(x) == 0 ? type(x) + (i) : (type##_GET_REGION(x, i, n, buf), buf))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (187:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  199|      0|	                                         __ibr_buf__, vtype);	\
  |  |  |  |  |  |  200|      0|	    expr							\
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (200:6): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  201|      0|	 }							        \
  |  |  |  |  |  |  202|      0|    } while (0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (202:14): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  232|      0|					strt, nfull, expr);		\
  |  |  |  |  233|      0|    } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (233:14): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  253|      0|				  0, XLENGTH(sx), expr);		\
  |  |  254|      0|    } while (0)
  |  |  ------------------
  |  |  |  Branch (254:14): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1184|      0|		for(R_xlen_t j = 0; j < nb; j++) {
 1185|      0|		    if(duptr[j] == 0)
 1186|      0|			REAL0(ans)[k++] = REAL_ELT(x, idx + j);
 1187|      0|		}
 1188|      0|	    });
 1189|      0|	break;
 1190|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1190:5): [True: 0, False: 67]
  ------------------
 1191|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (1191:14): [True: 0, False: 0]
  ------------------
 1192|      0|	    if (LOGICAL_ELT(dup, i) == 0)
  ------------------
  |  Branch (1192:10): [True: 0, False: 0]
  ------------------
 1193|      0|		COMPLEX0(ans)[k++] = COMPLEX_ELT(x, i);
 1194|      0|	break;
 1195|     59|    case STRSXP:
  ------------------
  |  |  126|     59|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1195:5): [True: 59, False: 8]
  ------------------
 1196|  2.73k|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (1196:14): [True: 2.67k, False: 59]
  ------------------
 1197|  2.67k|	    if (LOGICAL_ELT(dup, i) == 0)
  ------------------
  |  Branch (1197:10): [True: 2.67k, False: 2]
  ------------------
 1198|  2.67k|		SET_STRING_ELT(ans, k++, STRING_ELT(x, i));
 1199|     59|	break;
 1200|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1200:5): [True: 0, False: 67]
  ------------------
 1201|      0|    case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (1201:5): [True: 0, False: 67]
  ------------------
 1202|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (1202:14): [True: 0, False: 0]
  ------------------
 1203|      0|	    if (LOGICAL_ELT(dup, i) == 0)
  ------------------
  |  Branch (1203:10): [True: 0, False: 0]
  ------------------
 1204|      0|		SET_VECTOR_ELT(ans, k++, VECTOR_ELT(x, i));
 1205|      0|	break;
 1206|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1206:5): [True: 0, False: 67]
  ------------------
 1207|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (1207:14): [True: 0, False: 0]
  ------------------
 1208|      0|	    if (LOGICAL_ELT(dup, i) == 0)
  ------------------
  |  Branch (1208:10): [True: 0, False: 0]
  ------------------
 1209|      0|		RAW0(ans)[k++] = RAW_ELT(x, i);
 1210|      0|	break;
 1211|      0|    default:
  ------------------
  |  Branch (1211:5): [True: 0, False: 67]
  ------------------
 1212|      0|	UNIMPLEMENTED_TYPE("duplicated", x);
 1213|     67|    }
 1214|     67|    UNPROTECT(2);
  ------------------
  |  |  358|     67|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1215|     67|    return ans;
 1216|     67|}
Rf_match:
 1519|    130|{
 1520|       |    return match5(itable, ix, nmatch, NULL, R_BaseEnv);
 1521|    130|}
do_match:
 1526|   771k|{
 1527|   771k|    checkArity(op, args);
  ------------------
  |  | 1788|   771k|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1528|       |
 1529|   771k|    if ((!OBJECT(CAR (args)) && !isVector(CAR (args)) && !isNull(CAR (args))) ||
  ------------------
  |  |  974|   771k|#define isVector		Rf_isVector
  ------------------
                  if ((!OBJECT(CAR (args)) && !isVector(CAR (args)) && !isNull(CAR (args))) ||
  ------------------
  |  |  956|     16|#define isNull			Rf_isNull
  ------------------
  |  Branch (1529:10): [True: 771k, False: 0]
  |  Branch (1529:33): [True: 16, False: 771k]
  |  Branch (1529:58): [True: 0, False: 16]
  ------------------
 1530|   771k|	(!OBJECT(CADR(args)) && !isVector(CADR(args)) && !isNull(CADR(args))))
  ------------------
  |  |  974|   771k|#define isVector		Rf_isVector
  ------------------
              	(!OBJECT(CADR(args)) && !isVector(CADR(args)) && !isNull(CADR(args))))
  ------------------
  |  |  956|     42|#define isNull			Rf_isNull
  ------------------
  |  Branch (1530:3): [True: 771k, False: 0]
  |  Branch (1530:26): [True: 42, False: 771k]
  |  Branch (1530:51): [True: 0, False: 42]
  ------------------
 1531|      0|	error(_("'match' requires vector arguments"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'match' requires vector arguments"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1532|       |
 1533|   771k|    int nomatch = asInteger(CADDR(args));
  ------------------
  |  |  885|   771k|#define asInteger		Rf_asInteger
  ------------------
 1534|   771k|    SEXP incomp = CADDDR(args);
 1535|       |
 1536|   771k|    if (isNull(incomp) || /* S has FALSE to mean empty */
  ------------------
  |  |  956|   771k|#define isNull			Rf_isNull
  ------------------
  |  Branch (1536:9): [True: 771k, False: 0]
  ------------------
 1537|      0|	(length(incomp) == 1 && isLogical(incomp) &&
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
              	(length(incomp) == 1 && isLogical(incomp) &&
  ------------------
  |  |  952|      0|#define isLogical		Rf_isLogical
  ------------------
  |  Branch (1537:3): [True: 0, False: 0]
  |  Branch (1537:26): [True: 0, False: 0]
  ------------------
 1538|      0|	 LOGICAL_ELT(incomp, 0) == 0))
  ------------------
  |  Branch (1538:3): [True: 0, False: 0]
  ------------------
 1539|   771k|	return match5(CADR(args), CAR(args), nomatch, NULL, env);
 1540|      0|    else
 1541|      0|	return match5(CADR(args), CAR(args), nomatch, incomp, env);
 1542|   771k|}
do_pmatch:
 1560|     96|{
 1561|     96|    checkArity(op, args);
  ------------------
  |  | 1788|     96|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1562|     96|    SEXP input  = CAR(args), // = x     in R
 1563|     96|	target = CADR(args), // = table  "
 1564|     96|	ans;
 1565|     96|    R_xlen_t n_input = XLENGTH(input);
 1566|       |
 1567|     96|    int n_target = LENGTH(target), // not allowed to be long
 1568|     96|	no_match = asInteger(CADDR(args)),
  ------------------
  |  |  885|     96|#define asInteger		Rf_asInteger
  ------------------
 1569|     96|	dups_ok  = asLogical(CADDDR(args));
  ------------------
  |  |  886|     96|#define asLogical		Rf_asLogical
  ------------------
 1570|     96|    if (dups_ok == NA_LOGICAL)
  ------------------
  |  |   55|     96|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1570:9): [True: 0, False: 96]
  ------------------
 1571|      0|	error(_("invalid '%s' argument"), "duplicates.ok");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "duplicates.ok");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1572|     96|    Rboolean no_dups = !dups_ok;
 1573|       |
 1574|     96|    if (!isString(input) || !isString(target))
  ------------------
  |  |  966|     96|#define isString		Rf_isString
  ------------------
                  if (!isString(input) || !isString(target))
  ------------------
  |  |  966|     96|#define isString		Rf_isString
  ------------------
  |  Branch (1574:9): [True: 0, False: 96]
  |  Branch (1574:29): [True: 0, False: 96]
  ------------------
 1575|      0|	error(_("argument is not of mode character"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("argument is not of mode character"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1576|       |
 1577|     96|    int *used = NULL;
 1578|     96|    if(no_dups) {
  ------------------
  |  Branch (1578:8): [True: 68, False: 28]
  ------------------
 1579|     68|	used = (int *) R_alloc((size_t) n_target, sizeof(int));
 1580|    940|	for (int j = 0; j < n_target; j++) used[j] = 0;
  ------------------
  |  Branch (1580:18): [True: 872, False: 68]
  ------------------
 1581|     68|    }
 1582|       |
 1583|     96|    Rboolean useBytes = FALSE, useUTF8 = FALSE;
 1584|    384|    for(R_xlen_t i = 0; i < n_input; i++) {
  ------------------
  |  Branch (1584:25): [True: 288, False: 96]
  ------------------
 1585|    288|	if(IS_BYTES(STRING_ELT(input, i))) {
  ------------------
  |  Branch (1585:5): [True: 0, False: 288]
  ------------------
 1586|      0|	    useBytes = TRUE;
 1587|      0|	    useUTF8 = FALSE;
 1588|      0|	    break;
 1589|    288|	} else if(ENC_KNOWN(STRING_ELT(input, i))) {
  ------------------
  |  Branch (1589:12): [True: 0, False: 288]
  ------------------
 1590|      0|	    useUTF8 = TRUE;
 1591|      0|	}
 1592|    288|    }
 1593|     96|    if(!useBytes) {
  ------------------
  |  Branch (1593:8): [True: 96, False: 0]
  ------------------
 1594|  1.07k|	for(R_xlen_t i = 0; i < n_target; i++) {
  ------------------
  |  Branch (1594:22): [True: 982, False: 96]
  ------------------
 1595|    982|	    if(IS_BYTES(STRING_ELT(target, i))) {
  ------------------
  |  Branch (1595:9): [True: 0, False: 982]
  ------------------
 1596|      0|		useBytes = TRUE;
 1597|      0|		useUTF8 = FALSE;
 1598|      0|		break;
 1599|    982|	    } else if(ENC_KNOWN(STRING_ELT(target, i))) {
  ------------------
  |  Branch (1599:16): [True: 0, False: 982]
  ------------------
 1600|      0|		useUTF8 = TRUE;
 1601|      0|	    }
 1602|    982|	}
 1603|     96|    }
 1604|       |
 1605|     96|    const char **in, **tar;
 1606|     96|    in  = (const char **) R_alloc((size_t) n_input,  sizeof(char *));
 1607|     96|    tar = (const char **) R_alloc((size_t) n_target, sizeof(char *));
 1608|     96|    PROTECT(ans = allocVector(INTSXP, n_input));
  ------------------
  |  |  357|     96|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1609|     96|    int *ians = INTEGER0(ans);
 1610|     96|    if(useBytes) {
  ------------------
  |  Branch (1610:8): [True: 0, False: 96]
  ------------------
 1611|      0|	for(R_xlen_t i = 0; i < n_input; i++) {
  ------------------
  |  Branch (1611:22): [True: 0, False: 0]
  ------------------
 1612|      0|	    in[i] = CHAR(STRING_ELT(input, i));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1613|      0|	    ians[i] = 0;
 1614|      0|	}
 1615|      0|	for(int j = 0; j < n_target; j++)
  ------------------
  |  Branch (1615:17): [True: 0, False: 0]
  ------------------
 1616|      0|	    tar[j] = CHAR(STRING_ELT(target, j));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
 1617|      0|    }
 1618|     96|    else if(useUTF8) {
  ------------------
  |  Branch (1618:13): [True: 0, False: 96]
  ------------------
 1619|      0|	for(R_xlen_t i = 0; i < n_input; i++) {
  ------------------
  |  Branch (1619:22): [True: 0, False: 0]
  ------------------
 1620|      0|	    in[i] = translateCharUTF8(STRING_ELT(input, i));
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
 1621|      0|	    ians[i] = 0;
 1622|      0|	}
 1623|      0|	for(int j = 0; j < n_target; j++)
  ------------------
  |  Branch (1623:17): [True: 0, False: 0]
  ------------------
 1624|      0|	    tar[j] = translateCharUTF8(STRING_ELT(target, j));
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
 1625|     96|    } else {
 1626|    384|	for(R_xlen_t i = 0; i < n_input; i++) {
  ------------------
  |  Branch (1626:22): [True: 288, False: 96]
  ------------------
 1627|    288|	    in[i] = translateChar(STRING_ELT(input, i));
  ------------------
  |  | 1037|    288|#define translateChar		Rf_translateChar
  ------------------
 1628|    288|	    ians[i] = 0;
 1629|    288|	}
 1630|  1.07k|	for(int j = 0; j < n_target; j++)
  ------------------
  |  Branch (1630:17): [True: 982, False: 96]
  ------------------
 1631|    982|	    tar[j] = translateChar(STRING_ELT(target, j));
  ------------------
  |  | 1037|    982|#define translateChar		Rf_translateChar
  ------------------
 1632|     96|    }
 1633|       |    /* First pass, exact matching */
 1634|     96|    R_xlen_t nexact = 0;
 1635|       |    /* Compromise when hashing used changed in 3.2.0 (PR#15697) */
 1636|     96|    if (n_input <= 100 || n_target <= 100) {
  ------------------
  |  Branch (1636:9): [True: 96, False: 0]
  |  Branch (1636:27): [True: 0, False: 0]
  ------------------
 1637|    384|	for (R_xlen_t i = 0; i < n_input; i++) {
  ------------------
  |  Branch (1637:23): [True: 288, False: 96]
  ------------------
 1638|    288|	    const char *ss = in[i];
 1639|    288|	    if (strlen(ss) == 0) continue;
  ------------------
  |  Branch (1639:10): [True: 0, False: 288]
  ------------------
 1640|  1.74k|	    for (int j = 0; j < n_target; j++) {
  ------------------
  |  Branch (1640:22): [True: 1.74k, False: 2]
  ------------------
 1641|  1.74k|		if (no_dups && used[j]) continue;
  ------------------
  |  Branch (1641:7): [True: 1.70k, False: 42]
  |  Branch (1641:18): [True: 192, False: 1.50k]
  ------------------
 1642|  1.55k|		if (strcmp(ss, tar[j]) == 0) {
  ------------------
  |  Branch (1642:7): [True: 286, False: 1.26k]
  ------------------
 1643|    286|		    ians[i] = j + 1;
 1644|    286|		    if (no_dups) used[j] = 1;
  ------------------
  |  Branch (1644:11): [True: 258, False: 28]
  ------------------
 1645|    286|		    nexact++;
 1646|    286|		    break;
 1647|    286|		}
 1648|  1.55k|	    }
 1649|    288|	}
 1650|     96|    } else {
 1651|      0|	HashData data = { 0 };
 1652|      0|	HashTableSetup(target, &data, NA_INTEGER);
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
 1653|       |	/* the table is only referenced from the C struct, and shash() can
 1654|       |	   allocate via translateCharUTF8() -> R_alloc() */
 1655|      0|	PROTECT(data.HashTable);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1656|      0|	data.useUTF8 = useUTF8;
 1657|      0|	data.nomatch = 0;
 1658|      0|	DoHashing(target, &data);
 1659|      0|	for (R_xlen_t i = 0; i < n_input; i++) {
  ------------------
  |  Branch (1659:23): [True: 0, False: 0]
  ------------------
 1660|      0|	    if (strlen(in[i]) == 0) /* don't look up "" */
  ------------------
  |  Branch (1660:10): [True: 0, False: 0]
  ------------------
 1661|      0|		continue;
 1662|      0|	    int j = Lookup(target, input, i, &data);
 1663|      0|	    if ((j == 0) || (no_dups && used[j - 1])) continue;
  ------------------
  |  Branch (1663:10): [True: 0, False: 0]
  |  Branch (1663:23): [True: 0, False: 0]
  |  Branch (1663:34): [True: 0, False: 0]
  ------------------
 1664|      0|	    if (no_dups) used[j - 1] = 1;
  ------------------
  |  Branch (1664:10): [True: 0, False: 0]
  ------------------
 1665|      0|	    ians[i] = j;
 1666|      0|	    nexact++;
 1667|      0|	}
 1668|      0|	UNPROTECT(1); /* data.HashTable */
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1669|      0|    }
 1670|       |
 1671|     96|    if(nexact < n_input) {
  ------------------
  |  Branch (1671:8): [True: 2, False: 94]
  ------------------
 1672|       |	/* Second pass, partial matching */
 1673|      4|	for (R_xlen_t i = 0; i < n_input; i++) {
  ------------------
  |  Branch (1673:23): [True: 2, False: 2]
  ------------------
 1674|      2|	    const char *ss;
 1675|      2|	    if (ians[i]) continue;
  ------------------
  |  Branch (1675:10): [True: 0, False: 2]
  ------------------
 1676|      2|	    ss = in[i];
 1677|      2|	    size_t temp = strlen(ss);
 1678|      2|	    if (temp == 0) continue;
  ------------------
  |  Branch (1678:10): [True: 0, False: 2]
  ------------------
 1679|      2|	    int mtch = 0,
 1680|      2|		mtch_count = 0;
 1681|      6|	    for (int j = 0; j < n_target; j++) {
  ------------------
  |  Branch (1681:22): [True: 4, False: 2]
  ------------------
 1682|      4|		if (!(((size_t)i * n_target + j) & 0x1fff))
  ------------------
  |  Branch (1682:7): [True: 2, False: 2]
  ------------------
 1683|      2|		    R_CheckUserInterrupt();
 1684|      4|		if (no_dups && used[j]) continue;
  ------------------
  |  Branch (1684:7): [True: 4, False: 0]
  |  Branch (1684:18): [True: 0, False: 4]
  ------------------
 1685|      4|		if (strncmp(ss, tar[j], temp) == 0) {
  ------------------
  |  Branch (1685:7): [True: 0, False: 4]
  ------------------
 1686|      0|		    mtch = j + 1;
 1687|      0|		    mtch_count++;
 1688|      0|		}
 1689|      4|	    }
 1690|      2|	    if (mtch > 0 && mtch_count == 1) {
  ------------------
  |  Branch (1690:10): [True: 0, False: 2]
  |  Branch (1690:22): [True: 0, False: 0]
  ------------------
 1691|      0|		if(no_dups) used[mtch - 1] = 1;
  ------------------
  |  Branch (1691:6): [True: 0, False: 0]
  ------------------
 1692|      0|		ians[i] = mtch;
 1693|      0|	    }
 1694|      2|	}
 1695|       |	/* Third pass, set no matches */
 1696|      4|	for (R_xlen_t i = 0; i < n_input; i++)
  ------------------
  |  Branch (1696:23): [True: 2, False: 2]
  ------------------
 1697|      2|	    if(ians[i] == 0) ians[i] = no_match;
  ------------------
  |  Branch (1697:9): [True: 2, False: 0]
  ------------------
 1698|       |
 1699|      2|    }
 1700|     96|    UNPROTECT(1);
  ------------------
  |  |  358|     96|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1701|     96|    return ans;
 1702|     96|}
do_matchcall:
 1872|      7|{
 1873|      7|    SEXP formals, actuals, rlist;
 1874|      7|    SEXP funcall, f, b, rval, sysp, t1, t2, tail;
 1875|       |//    RCNTXT *cptr;
 1876|      7|    int expdots;
 1877|       |
 1878|      7|    checkArity(op,args);
  ------------------
  |  | 1788|      7|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1879|       |
 1880|      7|    funcall = CADR(args);
 1881|       |
 1882|      7|    if (TYPEOF(funcall) == EXPRSXP)
  ------------------
  |  |  132|      7|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (1882:9): [True: 0, False: 7]
  ------------------
 1883|      0|	funcall = VECTOR_ELT(funcall, 0);
 1884|       |
 1885|      7|    if (TYPEOF(funcall) != LANGSXP)
  ------------------
  |  |  117|      7|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
  |  Branch (1885:9): [True: 0, False: 7]
  ------------------
 1886|      0|	error(_("invalid '%s' argument"), "call");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "call");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1887|       |
 1888|      7|    b = CAR(args);
 1889|      7|    if (TYPEOF(b) != CLOSXP)
  ------------------
  |  |  114|      7|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (1889:9): [True: 0, False: 7]
  ------------------
 1890|      0|	error(_("invalid '%s' argument"), "definition");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "definition");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1891|       |
 1892|      7|    sysp = CAR(CDDDR(args));
 1893|      7|    if (!isEnvironment(sysp))
  ------------------
  |  |  944|      7|#define isEnvironment		Rf_isEnvironment
  ------------------
  |  Branch (1893:9): [True: 0, False: 7]
  ------------------
 1894|      0|	error(_("'envir' must be an environment"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'envir' must be an environment"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1895|       |
 1896|       |    /* Do we expand ... ? */
 1897|       |
 1898|      7|    expdots = asLogical(CAR(CDDR(args)));
  ------------------
  |  |  886|      7|#define asLogical		Rf_asLogical
  ------------------
 1899|      7|    if (expdots == NA_LOGICAL)
  ------------------
  |  |   55|      7|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1899:9): [True: 0, False: 7]
  ------------------
 1900|      0|	error(_("invalid '%s' argument"), "expand.dots");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "expand.dots");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1901|       |
 1902|       |    /* Get the formals and match the actual args */
 1903|       |
 1904|      7|    formals = FORMALS(b);
 1905|      7|    PROTECT(actuals = shallow_duplicate(CDR(funcall)));
  ------------------
  |  |  357|      7|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1906|       |
 1907|       |    /* If there is a ... symbol then expand it out in the sysp env
 1908|       |       We need to take some care since the ... might be in the middle
 1909|       |       of the actuals  */
 1910|       |
 1911|      7|    t2 = R_MissingArg;
 1912|     19|    for (t1=actuals ; t1!=R_NilValue ; t1 = CDR(t1) ) {
  ------------------
  |  Branch (1912:23): [True: 12, False: 7]
  ------------------
 1913|     12|	if (CAR(t1) == R_DotsSymbol) {
  ------------------
  |  Branch (1913:6): [True: 0, False: 12]
  ------------------
 1914|      0|	    t2 = subDots(sysp);
 1915|      0|	    break;
 1916|      0|	}
 1917|     12|    }
 1918|       |    /* now to splice t2 into the correct spot in actuals */
 1919|      7|    if (t2 != R_MissingArg ) {	/* so we did something above */
  ------------------
  |  Branch (1919:9): [True: 0, False: 7]
  ------------------
 1920|      0|	if( CAR(actuals) == R_DotsSymbol ) {
  ------------------
  |  Branch (1920:6): [True: 0, False: 0]
  ------------------
 1921|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1922|      0|	    actuals = listAppend(t2, CDR(actuals));
  ------------------
  |  |  995|      0|#define listAppend		Rf_listAppend
  ------------------
 1923|      0|	    PROTECT(actuals);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1924|      0|	}
 1925|      0|	else {
 1926|      0|	    for(t1=actuals; t1!=R_NilValue; t1=CDR(t1)) {
  ------------------
  |  Branch (1926:22): [True: 0, False: 0]
  ------------------
 1927|      0|		if( CADR(t1) == R_DotsSymbol ) {
  ------------------
  |  Branch (1927:7): [True: 0, False: 0]
  ------------------
 1928|      0|		    tail = CDDR(t1);
 1929|      0|		    SETCDR(t1, t2);
 1930|      0|		    listAppend(actuals,tail);
  ------------------
  |  |  995|      0|#define listAppend		Rf_listAppend
  ------------------
 1931|      0|		    break;
 1932|      0|		}
 1933|      0|	    }
 1934|      0|	}
 1935|      7|    } else { /* get rid of it */
 1936|      7|	if( CAR(actuals) == R_DotsSymbol ) {
  ------------------
  |  Branch (1936:6): [True: 0, False: 7]
  ------------------
 1937|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1938|      0|	    actuals = CDR(actuals);
 1939|      0|	    PROTECT(actuals);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1940|      0|	}
 1941|      7|	else {
 1942|     19|	    for(t1=actuals; t1!=R_NilValue; t1=CDR(t1)) {
  ------------------
  |  Branch (1942:22): [True: 12, False: 7]
  ------------------
 1943|     12|		if( CADR(t1) == R_DotsSymbol ) {
  ------------------
  |  Branch (1943:7): [True: 0, False: 12]
  ------------------
 1944|      0|		    tail = CDDR(t1);
 1945|      0|		    SETCDR(t1, tail);
 1946|      0|		    break;
 1947|      0|		}
 1948|     12|	    }
 1949|      7|	}
 1950|      7|    }
 1951|      7|    rlist = matchArgs_RC(formals, actuals, call);
  ------------------
  |  | 1947|      7|# define matchArgs_RC		Rf_matchArgs_RC
  ------------------
 1952|       |
 1953|       |    /* Attach the argument names as tags */
 1954|       |
 1955|     25|    for (f = formals, b = rlist; b != R_NilValue; b = CDR(b), f = CDR(f)) {
  ------------------
  |  Branch (1955:34): [True: 18, False: 7]
  ------------------
 1956|     18|	SET_TAG(b, TAG(f));
 1957|     18|    }
 1958|       |
 1959|       |
 1960|       |    /* Handle the dots */
 1961|       |
 1962|      7|    PROTECT(rlist = ExpandDots(rlist, expdots));
  ------------------
  |  |  357|      7|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1963|       |
 1964|       |    /* Eliminate any unmatched formals and any that match R_DotSymbol */
 1965|       |    /* This needs to be after ExpandDots as the DOTSXP might match ... */
 1966|       |
 1967|      7|    rlist = StripUnmatched(rlist);
 1968|       |
 1969|      7|    PROTECT(rval = allocSExp(LANGSXP));
  ------------------
  |  |  357|      7|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1970|      7|    SETCAR(rval, lazy_duplicate(CAR(funcall)));
  ------------------
  |  |  985|      7|#define lazy_duplicate		Rf_lazy_duplicate
  ------------------
 1971|      7|    SETCDR(rval, rlist);
 1972|      7|    UNPROTECT(3);
  ------------------
  |  |  358|      7|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1973|      7|    return rval;
 1974|      7|}
do_makeunique:
 2179|      2|{
 2180|      2|    SEXP names, sep, ans, dup, newx;
 2181|      2|    int i, cnt, *cnts, dp;
 2182|      2|    int n, len, maxlen = 0;
 2183|      2|    HashData data = { 0 };
 2184|      2|    const char *csep, *ss;
 2185|      2|    const void *vmax;
 2186|       |
 2187|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 2188|      2|    names = CAR(args);
 2189|      2|    if(!isString(names))
  ------------------
  |  |  966|      2|#define isString		Rf_isString
  ------------------
  |  Branch (2189:8): [True: 0, False: 2]
  ------------------
 2190|      0|	error(_("'names' must be a character vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'names' must be a character vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2191|      2|    n = LENGTH(names);
 2192|      2|    sep = CADR(args);
 2193|      2|    if(!isString(sep) || LENGTH(sep) != 1)
  ------------------
  |  |  966|      2|#define isString		Rf_isString
  ------------------
  |  Branch (2193:8): [True: 0, False: 2]
  |  Branch (2193:26): [True: 0, False: 2]
  ------------------
 2194|      0|	error(_("'%s' must be a character string"), "sep");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'%s' must be a character string"), "sep");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 2195|      2|    csep = translateChar(STRING_ELT(sep, 0));
  ------------------
  |  | 1037|      2|#define translateChar		Rf_translateChar
  ------------------
 2196|      2|    PROTECT(ans = allocVector(STRSXP, n));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2197|      2|    vmax = vmaxget();
 2198|     14|    for(i = 0; i < n; i++) {
  ------------------
  |  Branch (2198:16): [True: 12, False: 2]
  ------------------
 2199|     12|	SET_STRING_ELT(ans, i, STRING_ELT(names, i));
 2200|     12|	len = (int) strlen(translateChar(STRING_ELT(names, i)));
  ------------------
  |  | 1037|     12|#define translateChar		Rf_translateChar
  ------------------
 2201|     12|	if(len > maxlen) maxlen = len;
  ------------------
  |  Branch (2201:5): [True: 4, False: 8]
  ------------------
 2202|     12|	vmaxset(vmax);
 2203|     12|    }
 2204|      2|    if(n > 1) {
  ------------------
  |  Branch (2204:8): [True: 2, False: 0]
  ------------------
 2205|       |	/* +2 for terminator and rounding error */
 2206|      2|	size_t sz = maxlen + (int) strlen(csep)
 2207|      2|	    + (int) (log((double)n)/log(10.0)) + 2;
 2208|      2|	char buf[sz];
 2209|      2|	if(n < 10000) {
  ------------------
  |  Branch (2209:5): [True: 2, False: 0]
  ------------------
 2210|      2|	    R_CheckStack2((size_t)n * sizeof(int));
 2211|      2|	    cnts = (int *) alloca(((size_t) n) * sizeof(int));
  ------------------
  |  | 2562|      2|# define alloca(x) __builtin_alloca((x))
  ------------------
 2212|      2|	} else {
 2213|       |	    /* This is going to be slow so use expensive allocation
 2214|       |	       that will be recovered if interrupted. */
 2215|      0|	    cnts = (int *) R_alloc((size_t) n,	sizeof(int));
 2216|      0|	}
 2217|     14|	for(i = 0; i < n; i++) cnts[i] = 1;
  ------------------
  |  Branch (2217:13): [True: 12, False: 2]
  ------------------
 2218|      2|	data.nomatch = 0;
 2219|      2|	PROTECT(newx = allocVector(STRSXP, 1));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2220|      2|	PROTECT(dup = duplicated2(names, &data));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2221|      2|	PROTECT(data.HashTable);
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2222|      2|	vmax = vmaxget();
 2223|     12|	for(i = 1; i < n; i++) { /* first cannot be a duplicate */
  ------------------
  |  Branch (2223:13): [True: 10, False: 2]
  ------------------
 2224|     10|	    dp = INTEGER_ELT(dup, i); /* 1-based number of first occurrence */
 2225|     10|	    if(dp == 0) continue;
  ------------------
  |  Branch (2225:9): [True: 10, False: 0]
  ------------------
 2226|      0|	    ss = translateChar(STRING_ELT(names, i));
  ------------------
  |  | 1037|      0|#define translateChar		Rf_translateChar
  ------------------
 2227|       |	    /* Try appending 1,2,3, ..., n-1 until it is not already in use */
 2228|      0|	    for(cnt = cnts[dp - 1]; cnt < n; cnt++) {
  ------------------
  |  Branch (2228:30): [True: 0, False: 0]
  ------------------
 2229|      0|		snprintf(buf, sz, "%s%s%d", ss, csep, cnt);
 2230|      0|		SET_STRING_ELT(newx, 0, mkChar(buf));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 2231|      0|		if(Lookup(ans, newx, 0, &data) == data.nomatch) break;
  ------------------
  |  Branch (2231:6): [True: 0, False: 0]
  ------------------
 2232|      0|	    }
 2233|      0|	    SET_STRING_ELT(ans, i, STRING_ELT(newx, 0));
 2234|      0|	    /* insert it */ (void) isDuplicated(ans, i, &data);
 2235|      0|	    cnts[dp - 1] = cnt+1; /* cache the first unused cnt value */
 2236|      0|	    vmaxset(vmax);
 2237|      0|	}
 2238|      2|	UNPROTECT(3);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2239|      2|    }
 2240|      2|    UNPROTECT(1);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2241|      2|    return ans;
 2242|      2|}
unique.c:HashTableSetup:
  464|    131|{
  465|    131|    d->useUTF8 = FALSE;
  466|    131|    d->useCache = TRUE;
  467|    131|    switch (TYPEOF(x)) {
  468|      0|    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (468:5): [True: 0, False: 131]
  ------------------
  469|      0|	d->hash = lhash;
  470|      0|	d->equal = lequal;
  471|      0|	d->nmax = d->M = 4;
  472|      0|	d->K = 2; /* unused */
  473|      0|	break;
  474|      2|    case INTSXP:
  ------------------
  |  |  123|      2|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (474:5): [True: 2, False: 129]
  ------------------
  475|      2|    {
  476|      2|	d->hash = ihash;
  477|      2|	d->equal = iequal;
  478|      2|#ifdef LONG_VECTOR_SUPPORT
  479|      2|	R_xlen_t nn = XLENGTH(x);
  480|      2|	if (nn > IMAX) nn = IMAX;
  ------------------
  |  |  462|      2|#define IMAX 4294967296L
  ------------------
              	if (nn > IMAX) nn = IMAX;
  ------------------
  |  |  462|      0|#define IMAX 4294967296L
  ------------------
  |  Branch (480:6): [True: 0, False: 2]
  ------------------
  481|      2|	MKsetup(nn, d, nmax);
  482|       |#else
  483|       |	MKsetup(LENGTH(x), d, nmax);
  484|       |#endif
  485|      2|    }
  486|      2|	break;
  487|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (487:5): [True: 0, False: 131]
  ------------------
  488|      0|	d->hash = rhash;
  489|      0|	d->equal = requal;
  490|      0|	MKsetup(XLENGTH(x), d, nmax);
  491|      0|	break;
  492|      0|    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (492:5): [True: 0, False: 131]
  ------------------
  493|      0|	d->hash = chash;
  494|      0|	d->equal = cequal;
  495|      0|	MKsetup(XLENGTH(x), d, nmax);
  496|      0|	break;
  497|    129|    case STRSXP:
  ------------------
  |  |  126|    129|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (497:5): [True: 129, False: 2]
  ------------------
  498|    129|	d->hash = shash;
  499|    129|	d->equal = sequal;
  500|    129|	MKsetup(XLENGTH(x), d, nmax);
  501|    129|	break;
  502|      0|    case RAWSXP:
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (502:5): [True: 0, False: 131]
  ------------------
  503|      0|	d->hash = rawhash;
  504|      0|	d->equal = rawequal;
  505|      0|	d->nmax = d->M = 256;
  506|      0|	d->K = 8; /* unused */
  507|      0|	break;
  508|      0|    case EXPRSXP:
  ------------------
  |  |  132|      0|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (508:5): [True: 0, False: 131]
  ------------------
  509|      0|    case VECSXP:
  ------------------
  |  |  131|      0|#define VECSXP	    19	  /* generic vectors */
  ------------------
  |  Branch (509:5): [True: 0, False: 131]
  ------------------
  510|      0|	d->hash = vhash;
  511|      0|	d->equal = vequal;
  512|      0|	MKsetup(XLENGTH(x), d, nmax);
  513|      0|	break;
  514|      0|    default:
  ------------------
  |  Branch (514:5): [True: 0, False: 131]
  ------------------
  515|      0|	UNIMPLEMENTED_TYPE("HashTableSetup", x);
  516|    131|    }
  517|    131|#ifdef LONG_VECTOR_SUPPORT
  518|    131|    d->isLong = IS_LONG_VEC(x);
  519|    131|    if (d->isLong) {
  ------------------
  |  Branch (519:9): [True: 0, False: 131]
  ------------------
  520|      0|	d->HashTable = allocVector(REALSXP, (R_xlen_t) d->M);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	d->HashTable = allocVector(REALSXP, (R_xlen_t) d->M);
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  521|      0|	for (R_xlen_t i = 0; i < d->M; i++) HTDATA_DBL(d)[i] = NIL;
  ------------------
  |  |   83|      0|#define HTDATA_DBL(d) (REAL0((d)->HashTable))
  ------------------
              	for (R_xlen_t i = 0; i < d->M; i++) HTDATA_DBL(d)[i] = NIL;
  ------------------
  |  |   51|      0|#define NIL -1
  ------------------
  |  Branch (521:23): [True: 0, False: 0]
  ------------------
  522|      0|    } else
  523|    131|#endif
  524|    131|    {
  525|    131|	d->HashTable = allocVector(INTSXP, (R_xlen_t) d->M);
  ------------------
  |  |  875|    131|#define allocVector		Rf_allocVector
  ------------------
              	d->HashTable = allocVector(INTSXP, (R_xlen_t) d->M);
  ------------------
  |  |  123|    131|#define INTSXP	    13	  /* integer vectors */
  ------------------
  526|  52.8k|	for (R_xlen_t i = 0; i < d->M; i++) HTDATA_INT(d)[i] = NIL;
  ------------------
  |  |   82|  52.7k|#define HTDATA_INT(d) (INTEGER0((d)->HashTable))
  ------------------
              	for (R_xlen_t i = 0; i < d->M; i++) HTDATA_INT(d)[i] = NIL;
  ------------------
  |  |   51|  52.7k|#define NIL -1
  ------------------
  |  Branch (526:23): [True: 52.7k, False: 131]
  ------------------
  527|    131|    }
  528|    131|}
unique.c:ihash:
  119|      2|{
  120|      2|    int xi = INTEGER_ELT(x, indx);
  121|      2|    if (xi == NA_INTEGER) return 0;
  ------------------
  |  |   56|      2|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (121:9): [True: 0, False: 2]
  ------------------
  122|      2|    return scatter((unsigned int) xi, d);
  123|      2|}
unique.c:scatter:
  107|  26.9k|{
  108|  26.9k|    return 3141592653U * key >> (32 - d->K);
  109|  26.9k|}
unique.c:MKsetup:
  441|    131|{
  442|    131|#ifdef LONG_VECTOR_SUPPORT
  443|       |    /* M = 2^32 is safe, hence n <= 2^31 -1 */
  444|    131|    if(n < 0) /* protect against overflow to -ve */
  ------------------
  |  Branch (444:8): [True: 0, False: 131]
  ------------------
  445|      0|	error(_("length %lld is too large for hashing"), (long long)n);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("length %lld is too large for hashing"), (long long)n);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  446|       |#else
  447|       |    if(n < 0 || n >= 1073741824) /* protect against overflow to -ve */
  448|       |	error(_("length %d is too large for hashing"), n);
  449|       |#endif
  450|       |
  451|    131|    if (nmax != NA_INTEGER && nmax != 1) n = nmax;
  ------------------
  |  |   56|    262|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (451:9): [True: 0, False: 131]
  |  Branch (451:31): [True: 0, False: 0]
  ------------------
  452|    131|    size_t n2 = 2U * (size_t) n;
  453|    131|    d->M = 2;
  454|    131|    d->K = 1;
  455|    770|    while (d->M < n2) {
  ------------------
  |  Branch (455:12): [True: 639, False: 131]
  ------------------
  456|    639|	d->M *= 2;
  457|    639|	d->K++;
  458|    639|    }
  459|    131|    d->nmax = n;
  460|    131|}
unique.c:shash:
  211|  26.9k|{
  212|  26.9k|    unsigned int k;
  213|  26.9k|    const char *p;
  214|  26.9k|    if (d->inHashtab) {
  ------------------
  |  Branch (214:9): [True: 0, False: 26.9k]
  ------------------
  215|      0|	SEXP xi = STRING_ELT(x, indx);
  216|      0|	int noTrans = (IS_BYTES(xi) || IS_ASCII(xi)) ? TRUE : FALSE;
  ------------------
  |  Branch (216:17): [True: 0, False: 0]
  |  Branch (216:33): [True: 0, False: 0]
  ------------------
  217|      0|	if (d->useCache && noTrans)
  ------------------
  |  Branch (217:6): [True: 0, False: 0]
  |  Branch (217:21): [True: 0, False: 0]
  ------------------
  218|      0|	    return scatter(PTRHASH(xi), d);
  219|      0|	const void *vmax = vmaxget();
  220|      0|	p = noTrans ? CHAR(xi) : translateCharUTF8(xi);
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
              	p = noTrans ? CHAR(xi) : translateCharUTF8(xi);
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  |  Branch (220:6): [True: 0, False: 0]
  ------------------
  221|      0|	k = 0;
  222|      0|	while (*p++)
  ------------------
  |  Branch (222:9): [True: 0, False: 0]
  ------------------
  223|       |	    /* multiplier was 8 but 11 isn't a power of 2 */
  224|      0|	    k = 11 * k + (unsigned int) *p;
  225|      0|	vmaxset(vmax); /* discard any memory used by translateChar */
  226|      0|	return scatter(k, d);
  227|      0|    }
  228|  26.9k|    if(!d->useUTF8 && d->useCache) return cshash(x, indx, d);
  ------------------
  |  Branch (228:8): [True: 26.9k, False: 0]
  |  Branch (228:23): [True: 26.9k, False: 0]
  ------------------
  229|      0|    const void *vmax = vmaxget();
  230|       |    /* Not having d->useCache really should not happen anymore. */
  231|      0|    p = translateCharUTF8(STRING_ELT(x, indx));
  ------------------
  |  | 1039|      0|#define translateCharUTF8      	Rf_translateCharUTF8
  ------------------
  232|      0|    k = 0;
  233|      0|    while (*p++)
  ------------------
  |  Branch (233:12): [True: 0, False: 0]
  ------------------
  234|      0|	k = 11 * k + (unsigned int) *p; /* was 8 but 11 isn't a power of 2 */
  235|      0|    vmaxset(vmax); /* discard any memory used by translateChar */
  236|      0|    return scatter(k, d);
  237|  26.9k|}
unique.c:PTRHASH:
  195|  26.9k|{
  196|  26.9k|    intptr_t z = (intptr_t) x;
  197|  26.9k|    unsigned int z1 = (unsigned int)(z & 0xffffffff), z2 = 0;
  198|  26.9k|#if SIZEOF_LONG == 8
  199|  26.9k|    z2 = (unsigned int)(z/0x100000000L);
  200|  26.9k|#endif
  201|  26.9k|    return z1 ^ z2;
  202|  26.9k|}
unique.c:cshash:
  206|  26.9k|{
  207|  26.9k|    return scatter(PTRHASH(STRING_ELT(x, indx)), d);
  208|  26.9k|}
unique.c:sequal:
  289|  12.5k|{
  290|  12.5k|    if (i < 0 || j < 0) return 0;
  ------------------
  |  Branch (290:9): [True: 0, False: 12.5k]
  |  Branch (290:18): [True: 0, False: 12.5k]
  ------------------
  291|  12.5k|    SEXP xi = STRING_ELT(x, i);
  292|  12.5k|    SEXP yj = STRING_ELT(y, j);
  293|       |    /* Two strings which have the same address must be the same,
  294|       |       so avoid looking at the contents */
  295|  12.5k|    if (xi == yj) return 1;
  ------------------
  |  Branch (295:9): [True: 4.80k, False: 7.72k]
  ------------------
  296|       |    /* Then if either is NA the other cannot be */
  297|       |    /* Once all CHARSXPs are cached, Seql will handle this */
  298|  7.72k|    if (xi == NA_STRING || yj == NA_STRING)
  ------------------
  |  |  433|  15.4k|#define NA_STRING	R_NaString
  ------------------
                  if (xi == NA_STRING || yj == NA_STRING)
  ------------------
  |  |  433|  7.72k|#define NA_STRING	R_NaString
  ------------------
  |  Branch (298:9): [True: 0, False: 7.72k]
  |  Branch (298:28): [True: 0, False: 7.72k]
  ------------------
  299|      0|	return 0;
  300|       |    /* another pre-test to avoid the call to Seql */
  301|  7.72k|    if (IS_CACHED(xi) && IS_CACHED(yj) && ENC_KNOWN(xi) == ENC_KNOWN(yj))
  ------------------
  |  Branch (301:9): [True: 7.72k, False: 0]
  |  Branch (301:26): [True: 7.72k, False: 0]
  |  Branch (301:43): [True: 7.72k, False: 0]
  ------------------
  302|  7.72k|	return 0;
  303|      0|    return Seql(xi, yj);
  ------------------
  |  | 1983|      0|# define Seql			Rf_Seql
  ------------------
  304|  7.72k|}
unique.c:duplicatedInit:
  564|     41|{
  565|     41|    Rboolean stop = FALSE;
  566|       |
  567|     41|    if(TYPEOF(x) == STRSXP) {
  ------------------
  |  |  126|     41|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (567:8): [True: 39, False: 2]
  ------------------
  568|     39|	R_xlen_t i, n = XLENGTH(x);
  569|  3.18k|	for(i = 0; i < n; i++) {
  ------------------
  |  Branch (569:13): [True: 3.14k, False: 39]
  ------------------
  570|  3.14k|	    if(IS_BYTES(STRING_ELT(x, i))) {
  ------------------
  |  Branch (570:9): [True: 0, False: 3.14k]
  ------------------
  571|      0|		d->useUTF8 = FALSE;
  572|      0|		stop = TRUE;
  573|      0|		break;
  574|      0|	    }
  575|  3.14k|	    if(ENC_KNOWN(STRING_ELT(x, i))) {
  ------------------
  |  Branch (575:9): [True: 0, False: 3.14k]
  ------------------
  576|      0|		d->useUTF8 = TRUE;
  577|      0|	    }
  578|       |	    /* uncached strings are currently not properly supported */
  579|  3.14k|	    if(!IS_CACHED(STRING_ELT(x, i))) {
  ------------------
  |  Branch (579:9): [True: 0, False: 3.14k]
  ------------------
  580|      0|		d->useCache = FALSE;
  581|      0|		stop = TRUE;
  582|      0|		break;
  583|      0|	    }
  584|  3.14k|	}
  585|     39|    } else if (TYPEOF(x) == VECSXP || TYPEOF(x) == EXPRSXP) {
  ------------------
  |  |  131|      4|#define VECSXP	    19	  /* generic vectors */
  ------------------
                  } else if (TYPEOF(x) == VECSXP || TYPEOF(x) == EXPRSXP) {
  ------------------
  |  |  132|      2|#define EXPRSXP	    20	  /* expressions vectors */
  ------------------
  |  Branch (585:16): [True: 0, False: 2]
  |  Branch (585:39): [True: 0, False: 2]
  ------------------
  586|      0|	R_xlen_t i, n = XLENGTH(x);
  587|      0|	for(i = 0; i < n; i++)
  ------------------
  |  Branch (587:13): [True: 0, False: 0]
  ------------------
  588|      0|	    if (duplicatedInit(VECTOR_ELT(x, i), d)) {
  ------------------
  |  Branch (588:10): [True: 0, False: 0]
  ------------------
  589|      0|		stop = TRUE;
  590|      0|		break;
  591|      0|	    }
  592|      2|    } else if (TYPEOF(x) == LANGSXP || TYPEOF(x) == LISTSXP) {
  ------------------
  |  |  117|      4|#define LANGSXP	     6	  /* language constructs (special lists) */
  ------------------
                  } else if (TYPEOF(x) == LANGSXP || TYPEOF(x) == LISTSXP) {
  ------------------
  |  |  113|      2|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
  |  Branch (592:16): [True: 0, False: 2]
  |  Branch (592:40): [True: 0, False: 2]
  ------------------
  593|      0|	for(SEXP head = x; head != R_NilValue; head = CDR(head))
  ------------------
  |  Branch (593:21): [True: 0, False: 0]
  ------------------
  594|      0|	    if (duplicatedInit(CAR(head), d)) {
  ------------------
  |  Branch (594:10): [True: 0, False: 0]
  ------------------
  595|      0|		stop = TRUE;
  596|      0|		break;
  597|      0|	    }
  598|       |
  599|      2|    } else if (TYPEOF(x) == CLOSXP) {
  ------------------
  |  |  114|      2|#define CLOSXP	     3	  /* closures */
  ------------------
  |  Branch (599:16): [True: 0, False: 2]
  ------------------
  600|      0|	if (duplicatedInit(BODY_EXPR(x), d))
  ------------------
  |  | 1220|      0|#define BODY_EXPR(e) R_ClosureExpr(e)
  ------------------
  |  Branch (600:6): [True: 0, False: 0]
  ------------------
  601|      0|	    stop = TRUE;
  602|      0|    }
  603|     41|    return stop;
  604|     41|}
unique.c:isDuplicated:
  535|  18.4k|{
  536|  18.4k|#ifdef LONG_VECTOR_SUPPORT
  537|  18.4k|    if (d->isLong) {
  ------------------
  |  Branch (537:9): [True: 0, False: 18.4k]
  ------------------
  538|      0|	double *h = HTDATA_DBL(d);
  ------------------
  |  |   83|      0|#define HTDATA_DBL(d) (REAL0((d)->HashTable))
  ------------------
  539|      0|	hlen i = d->hash(x, indx, d);
  540|      0|	while (h[i] != NIL) {
  ------------------
  |  |   51|      0|#define NIL -1
  ------------------
  |  Branch (540:9): [True: 0, False: 0]
  ------------------
  541|      0|	    if (d->equal(x, (R_xlen_t) h[i], x, indx))
  ------------------
  |  Branch (541:10): [True: 0, False: 0]
  ------------------
  542|      0|		return h[i] >= 0 ? 1 : 0;
  ------------------
  |  Branch (542:10): [True: 0, False: 0]
  ------------------
  543|      0|	    i = (i + 1) % d->M;
  544|      0|	}
  545|      0|	if (d->nmax-- < 0) error("hash table is full");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (545:6): [True: 0, False: 0]
  ------------------
  546|      0|	h[i] = (double) indx;
  547|      0|    } else
  548|  18.4k|#endif
  549|  18.4k|    {
  550|  18.4k|	int *h = HTDATA_INT(d);
  ------------------
  |  |   82|  18.4k|#define HTDATA_INT(d) (INTEGER0((d)->HashTable))
  ------------------
  551|  18.4k|	hlen i = d->hash(x, indx, d);
  552|  22.9k|	while (h[i] != NIL) {
  ------------------
  |  |   51|  22.9k|#define NIL -1
  ------------------
  |  Branch (552:9): [True: 4.49k, False: 18.4k]
  ------------------
  553|  4.49k|	    if (d->equal(x, h[i], x, indx))
  ------------------
  |  Branch (553:10): [True: 2, False: 4.49k]
  ------------------
  554|      2|		return h[i] >= 0 ? 1 : 0;
  ------------------
  |  Branch (554:10): [True: 2, False: 0]
  ------------------
  555|  4.49k|	    i = (i + 1) % d->M;
  556|  4.49k|	}
  557|  18.4k|	if (d->nmax-- < 0) error("hash table is full");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (557:6): [True: 0, False: 18.4k]
  ------------------
  558|  18.4k|	h[i] = (int) indx;
  559|  18.4k|    }
  560|  18.4k|    return 0;
  561|  18.4k|}
unique.c:Duplicated:
  828|     67|{
  829|     67|    SEXP ans;
  830|     67|    int *v;
  831|       |
  832|     67|    if (!isVector(x)) error(_("'duplicated' applies only to vectors"));
  ------------------
  |  |  974|     67|#define isVector		Rf_isVector
  ------------------
                  if (!isVector(x)) error(_("'duplicated' applies only to vectors"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  if (!isVector(x)) error(_("'duplicated' applies only to vectors"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (832:9): [True: 0, False: 67]
  ------------------
  833|     67|    R_xlen_t i, n = XLENGTH(x);
  834|     67|    if(n == 0)
  ------------------
  |  Branch (834:8): [True: 0, False: 67]
  ------------------
  835|      0|	return allocVector(LGLSXP, 0);
  ------------------
  |  |  875|      0|#define allocVector		Rf_allocVector
  ------------------
              	return allocVector(LGLSXP, 0);
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  836|     67|    else if (n == 1)
  ------------------
  |  Branch (836:14): [True: 40, False: 27]
  ------------------
  837|     40|	return ScalarLogical(FALSE);
  ------------------
  |  | 1023|     40|#define ScalarLogical		Rf_ScalarLogical
  ------------------
  838|       |
  839|     27|    if(DUP_KNOWN_SORTED(x)) {
  ------------------
  |  |  824|     27|    ((TYPEOF(x) == INTSXP && KNOWN_SORTED(INTEGER_IS_SORTED(x))) ||	\
  |  |  ------------------
  |  |  |  |  123|     54|#define INTSXP	    13	  /* integer vectors */
  |  |  ------------------
  |  |                   ((TYPEOF(x) == INTSXP && KNOWN_SORTED(INTEGER_IS_SORTED(x))) ||	\
  |  |  ------------------
  |  |  |  | 1162|      0|#define KNOWN_SORTED(sorted) (sorted == SORTED_DECR ||			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1162:31): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1163|      0|			      sorted == SORTED_INCR ||			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1163:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1164|      0|			      sorted == SORTED_DECR_NA_1ST ||		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1164:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1165|      0|			      sorted == SORTED_INCR_NA_1ST)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1165:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (824:7): [True: 0, False: 27]
  |  |  ------------------
  |  |  825|     27|     (TYPEOF(x) == REALSXP && KNOWN_SORTED(REAL_IS_SORTED(x))))
  |  |  ------------------
  |  |  |  |  124|     54|#define REALSXP	    14	  /* real variables */
  |  |  ------------------
  |  |                    (TYPEOF(x) == REALSXP && KNOWN_SORTED(REAL_IS_SORTED(x))))
  |  |  ------------------
  |  |  |  | 1162|      0|#define KNOWN_SORTED(sorted) (sorted == SORTED_DECR ||			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1162:31): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1163|      0|			      sorted == SORTED_INCR ||			\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1163:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1164|      0|			      sorted == SORTED_DECR_NA_1ST ||		\
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1164:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  | 1165|      0|			      sorted == SORTED_INCR_NA_1ST)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (1165:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (825:7): [True: 0, False: 27]
  |  |  ------------------
  ------------------
  840|      0|    	return sorted_Duplicated(x, from_last, nmax);
  841|      0|    }
  842|     27|    DUPLICATED_INIT;
  ------------------
  |  |  635|     27|    HashData data = { 0 };					\
  |  |  636|     27|    HashTableSetup(x, &data, nmax);				\
  |  |  637|     27|    data.useUTF8 = FALSE; data.useCache = TRUE;			\
  |  |  638|     27|    duplicatedInit(x, &data);
  ------------------
  843|       |
  844|     27|    PROTECT(data.HashTable);
  ------------------
  |  |  357|     27|#define PROTECT(s)	Rf_protect(s)
  ------------------
  845|     27|    PROTECT(ans = allocVector(LGLSXP, n));
  ------------------
  |  |  357|     27|#define PROTECT(s)	Rf_protect(s)
  ------------------
  846|       |
  847|     27|    v = LOGICAL(ans);
  848|       |
  849|     27|    if(from_last)
  ------------------
  |  Branch (849:8): [True: 0, False: 27]
  ------------------
  850|      0|	for (i = n-1; i >= 0; i--) {
  ------------------
  |  Branch (850:16): [True: 0, False: 0]
  ------------------
  851|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  852|      0|	    v[i] = isDuplicated(x, i, &data);
  853|      0|	}
  854|     27|    else
  855|  2.67k|	for (i = 0; i < n; i++) {
  ------------------
  |  Branch (855:14): [True: 2.64k, False: 27]
  ------------------
  856|       |//	    if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
  857|  2.64k|	    v[i] = isDuplicated(x, i, &data);
  858|  2.64k|	}
  859|       |
  860|     27|    UNPROTECT(2);
  ------------------
  |  |  358|     27|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  861|     27|    return ans;
  862|     27|}
unique.c:match5:
 1341|   771k|{
 1342|   771k|    R_xlen_t n = xlength(ix);
  ------------------
  |  | 1049|   771k|#define xlength(x)		Rf_xlength(x)
  ------------------
 1343|       |    /* handle zero length arguments */
 1344|   771k|    if (n == 0) return allocVector(INTSXP, 0);
  ------------------
  |  |  875|     42|#define allocVector		Rf_allocVector
  ------------------
                  if (n == 0) return allocVector(INTSXP, 0);
  ------------------
  |  |  123|     42|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1344:9): [True: 42, False: 771k]
  ------------------
 1345|       |
 1346|   771k|    SEXP ans;
 1347|   771k|    if (length(itable) == 0) {
  ------------------
  |  |  987|   771k|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (1347:9): [True: 161, False: 771k]
  ------------------
 1348|    161|	ans = allocVector(INTSXP, n);
  ------------------
  |  |  875|    161|#define allocVector		Rf_allocVector
  ------------------
              	ans = allocVector(INTSXP, n);
  ------------------
  |  |  123|    161|#define INTSXP	    13	  /* integer vectors */
  ------------------
 1349|    161|	int *pa = INTEGER0(ans);
 1350|  29.8k|	for (R_xlen_t i = 0; i < n; i++) pa[i] = nmatch;
  ------------------
  |  Branch (1350:23): [True: 29.6k, False: 161]
  ------------------
 1351|    161|	return ans;
 1352|    161|    }
 1353|       |
 1354|   771k|    SEXP x, table;
 1355|   771k|    int nprot = 2; /* x, table */
 1356|   771k|    PROTECT_INDEX xpi, tbpi;
 1357|       |
 1358|   771k|    bool D1; /* special case  <Date> o <character> */
 1359|   771k|    if ((D1 = isObject(ix)     && inherits(ix,     "Date") && isValidString(itable)) ||
  ------------------
  |  |  959|   771k|#define isObject		Rf_isObject
  ------------------
                  if ((D1 = isObject(ix)     && inherits(ix,     "Date") && isValidString(itable)) ||
  ------------------
  |  |  933|      0|#define inherits		Rf_inherits
  ------------------
                  if ((D1 = isObject(ix)     && inherits(ix,     "Date") && isValidString(itable)) ||
  ------------------
  |  |  972|      0|#define isValidString		Rf_isValidString
  ------------------
  |  Branch (1359:9): [True: 0, False: 771k]
  |  Branch (1359:15): [True: 0, False: 771k]
  |  Branch (1359:35): [True: 0, False: 0]
  |  Branch (1359:63): [True: 0, False: 0]
  ------------------
 1360|   771k|	(     isObject(itable) && inherits(itable, "Date") && isValidString(ix))) {
  ------------------
  |  |  959|   771k|#define isObject		Rf_isObject
  ------------------
              	(     isObject(itable) && inherits(itable, "Date") && isValidString(ix))) {
  ------------------
  |  |  933|      0|#define inherits		Rf_inherits
  ------------------
              	(     isObject(itable) && inherits(itable, "Date") && isValidString(ix))) {
  ------------------
  |  |  972|      0|#define isValidString		Rf_isValidString
  ------------------
  |  Branch (1360:8): [True: 0, False: 771k]
  |  Branch (1360:28): [True: 0, False: 0]
  |  Branch (1360:56): [True: 0, False: 0]
  ------------------
 1361|       |	/* Do *not* translate the <Date> to integer below (which later would be coerced
 1362|       |	 * to character: e.g, as.character(as.vector(as.Date("2025-06-26"))) |--> "20265"
 1363|       |	 * but rather *do*  as.Date(<character>) for the other, and then compare (the numbers of)
 1364|       |	 * as.vector(<Date>).
 1365|       |	*/
 1366|      0|	SEXP call, form_Ymd = PROTECT(mkString("%Y-%m-%d"));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1367|      0|	nprot += 2; /* form_Ymd, call */
 1368|      0|	if(D1) { // table := as.Date.character(itable, "%Y-%m-%d")
  ------------------
  |  Branch (1368:5): [True: 0, False: 0]
  ------------------
 1369|      0|	    PROTECT(call = lang3(install("as.Date.character"), itable, form_Ymd));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1370|      0|	    PROTECT_WITH_INDEX(table = eval(call, env), &tbpi);
  ------------------
  |  |  366|      0|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
 1371|       |
 1372|      0|	    REPROTECT(         table = match_transform(table, env), tbpi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 1373|      0|	    PROTECT_WITH_INDEX(x     = match_transform(ix,    env), &xpi);
  ------------------
  |  |  366|      0|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
 1374|      0|	} else { // x := as.Date.character(ix, "%Y-%m-%d")
 1375|      0|	    PROTECT(call = lang3(install("as.Date.character"), ix, form_Ymd));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1376|      0|	    PROTECT_WITH_INDEX(x = eval(call, env), &xpi);
  ------------------
  |  |  366|      0|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
 1377|       |
 1378|      0|	    REPROTECT(         x     = match_transform(x,      env),   xpi);
  ------------------
  |  |  367|      0|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 1379|      0|	    PROTECT_WITH_INDEX(table = match_transform(itable, env), &tbpi);
  ------------------
  |  |  366|      0|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
 1380|      0|	}
 1381|   771k|    } else { /* regular cases */
 1382|   771k|	PROTECT_WITH_INDEX(x     = match_transform(ix,     env),  &xpi);
  ------------------
  |  |  366|   771k|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
 1383|   771k|        PROTECT_WITH_INDEX(table = match_transform(itable, env), &tbpi);
  ------------------
  |  |  366|   771k|#define PROTECT_WITH_INDEX(x,i) R_ProtectWithIndex(x,i)
  ------------------
 1384|   771k|    }
 1385|       |
 1386|   771k|    SEXPTYPE type;
 1387|       |    /* Coerce to a common type; type == NILSXP is ok here.
 1388|       |     * Note that above we coerce factors and "POSIXlt", only to character.
 1389|       |     * Hence, coerce to character or to `higher' type
 1390|       |     * (given that we have "Vector" or NULL) */
 1391|   771k|    if(TYPEOF(x) >= STRSXP || TYPEOF(table) >= STRSXP) type = STRSXP;
  ------------------
  |  |  126|  1.54M|#define STRSXP	    16	  /* string vectors */
  ------------------
                  if(TYPEOF(x) >= STRSXP || TYPEOF(table) >= STRSXP) type = STRSXP;
  ------------------
  |  |  126|     72|#define STRSXP	    16	  /* string vectors */
  ------------------
                  if(TYPEOF(x) >= STRSXP || TYPEOF(table) >= STRSXP) type = STRSXP;
  ------------------
  |  |  126|   771k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1391:8): [True: 771k, False: 72]
  |  Branch (1391:31): [True: 0, False: 72]
  ------------------
 1392|     72|    else type = TYPEOF(x) < TYPEOF(table) ? TYPEOF(table) : TYPEOF(x);
  ------------------
  |  Branch (1392:17): [True: 0, False: 72]
  ------------------
 1393|   771k|    REPROTECT(x	    = coerceVector(x,	  type),  xpi);
  ------------------
  |  |  367|   771k|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 1394|   771k|    REPROTECT(table = coerceVector(table, type), tbpi);
  ------------------
  |  |  367|   771k|#define REPROTECT(x,i) R_Reprotect(x,i)
  ------------------
 1395|       |
 1396|       |    // special case scalar x -- for speed only :
 1397|   771k|    if(XLENGTH(x) == 1 && !incomp) {
  ------------------
  |  Branch (1397:8): [True: 771k, False: 88]
  |  Branch (1397:27): [True: 771k, False: 0]
  ------------------
 1398|   771k|      int val = nmatch;
 1399|   771k|      int ntable = LENGTH(table);
 1400|   771k|      switch (type) {
  ------------------
  |  Branch (1400:15): [True: 771k, False: 0]
  ------------------
 1401|   771k|      case STRSXP: {
  ------------------
  |  |  126|   771k|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1401:7): [True: 771k, False: 72]
  ------------------
 1402|   771k|	  SEXP x_val = STRING_ELT(x,0);
 1403|  4.62M|	  for (int i=0; i < ntable; i++) if (Seql(STRING_ELT(table,i), x_val)) {
  ------------------
  |  | 1983|  3.85M|# define Seql			Rf_Seql
  ------------------
  |  Branch (1403:18): [True: 3.85M, False: 771k]
  |  Branch (1403:39): [True: 385, False: 3.85M]
  ------------------
 1404|    385|		  val = i + 1; break;
 1405|    385|	      }
 1406|   771k|	  break; }
 1407|      0|      case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (1407:7): [True: 0, False: 771k]
  ------------------
 1408|     72|      case INTSXP: {
  ------------------
  |  |  123|     72|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1408:7): [True: 72, False: 771k]
  ------------------
 1409|     72|	  int x_val = INTEGER_ELT(x, 0),
 1410|     72|	      *table_p = INTEGER(table);
 1411|    336|	  for (int i=0; i < ntable; i++) if (table_p[i] == x_val) {
  ------------------
  |  Branch (1411:18): [True: 272, False: 64]
  |  Branch (1411:39): [True: 8, False: 264]
  ------------------
 1412|      8|		  val = i + 1; break;
 1413|      8|	      }
 1414|     72|	  break; }
 1415|      0|      case REALSXP: {
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1415:7): [True: 0, False: 771k]
  ------------------
 1416|      0|	  double xv = REAL_ELT(x, 0);
 1417|       |	  // pblm with signed 0s under IEC60559
 1418|      0|	  double x_val = (xv == 0.) ? 0. : xv;
  ------------------
  |  Branch (1418:19): [True: 0, False: 0]
  ------------------
 1419|      0|	  double *table_p = REAL(table);
 1420|       |	  /* we want all NaNs except NA equal, and all NAs equal */
 1421|      0|	  if (R_IsNA(x_val)) {
  ------------------
  |  Branch (1421:8): [True: 0, False: 0]
  ------------------
 1422|      0|	      for (int i=0; i < ntable; i++) if (R_IsNA(table_p[i])) {
  ------------------
  |  Branch (1422:22): [True: 0, False: 0]
  |  Branch (1422:43): [True: 0, False: 0]
  ------------------
 1423|      0|		      val = i + 1; break;
 1424|      0|		  }
 1425|      0|	  }
 1426|      0|	  else if (R_IsNaN(x_val)) {
  ------------------
  |  Branch (1426:13): [True: 0, False: 0]
  ------------------
 1427|      0|	      for (int i=0; i < ntable; i++) if (R_IsNaN(table_p[i])) {
  ------------------
  |  Branch (1427:22): [True: 0, False: 0]
  |  Branch (1427:43): [True: 0, False: 0]
  ------------------
 1428|      0|		      val = i + 1; break;
 1429|      0|		  }
 1430|      0|	  }
 1431|      0|	  else {
 1432|      0|	      for (int i=0; i < ntable; i++) if (table_p[i] == x_val) {
  ------------------
  |  Branch (1432:22): [True: 0, False: 0]
  |  Branch (1432:43): [True: 0, False: 0]
  ------------------
 1433|      0|		      val = i + 1; break;
 1434|      0|	      }
 1435|      0|	  }
 1436|      0|	  break; }
 1437|      0|      case CPLXSXP: {
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (1437:7): [True: 0, False: 771k]
  ------------------
 1438|      0|	  Rcomplex x_val = COMPLEX_ELT(x, 0),
 1439|      0|	      *table_p = COMPLEX(table);
 1440|      0|	  for (int i=0; i < ntable; i++)
  ------------------
  |  Branch (1440:18): [True: 0, False: 0]
  ------------------
 1441|      0|	      if (cplx_eq(table_p[i], x_val)) {
  ------------------
  |  Branch (1441:12): [True: 0, False: 0]
  ------------------
 1442|      0|		  val = i + 1; break;
 1443|      0|	      }
 1444|      0|	  break; }
 1445|      0|      case RAWSXP: {
  ------------------
  |  |  136|      0|#define RAWSXP      24    /* raw bytes */
  ------------------
  |  Branch (1445:7): [True: 0, False: 771k]
  ------------------
 1446|      0|	  Rbyte x_val = RAW_ELT(x, 0),
 1447|      0|	      *table_p = RAW(table);
 1448|      0|	  for (int i=0; i < ntable; i++) if (table_p[i] == x_val) {
  ------------------
  |  Branch (1448:18): [True: 0, False: 0]
  |  Branch (1448:39): [True: 0, False: 0]
  ------------------
 1449|      0|		  val = i + 1; break;
 1450|      0|	      }
 1451|      0|	  break; }
 1452|   771k|      }
 1453|   771k|      PROTECT(ans = ScalarInteger(val)); nprot++;
  ------------------
  |  |  357|   771k|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1454|   771k|    }
 1455|     88|    else { // regular case
 1456|     88|	HashData data = { 0 };
 1457|     88|	if (incomp) { PROTECT(incomp = coerceVector(incomp, type)); nprot++; }
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  |  Branch (1457:6): [True: 0, False: 88]
  ------------------
 1458|     88|	data.nomatch = nmatch;
 1459|     88|	HashTableSetup(table, &data, NA_INTEGER);
  ------------------
  |  |   56|     88|#define NA_INTEGER	R_NaInt
  ------------------
 1460|     88|	PROTECT(data.HashTable); nprot++;
  ------------------
  |  |  357|     88|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1461|     88|	if(type == STRSXP) {
  ------------------
  |  |  126|     88|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1461:5): [True: 88, False: 0]
  ------------------
 1462|     88|	    Rboolean useBytes = FALSE;
 1463|     88|	    Rboolean useUTF8 = FALSE;
 1464|     88|	    Rboolean useCache = TRUE;
 1465|  8.53k|	    for(R_xlen_t i = 0; i < xlength(x); i++) {
  ------------------
  |  | 1049|  8.53k|#define xlength(x)		Rf_xlength(x)
  ------------------
  |  Branch (1465:26): [True: 8.44k, False: 88]
  ------------------
 1466|  8.44k|		SEXP s = STRING_ELT(x, i);
 1467|  8.44k|		if(IS_BYTES(s)) {
  ------------------
  |  Branch (1467:6): [True: 0, False: 8.44k]
  ------------------
 1468|      0|		    useBytes = TRUE;
 1469|      0|		    useUTF8 = FALSE;
 1470|      0|		    break;
 1471|      0|		}
 1472|  8.44k|		if(ENC_KNOWN(s)) {
  ------------------
  |  Branch (1472:6): [True: 0, False: 8.44k]
  ------------------
 1473|      0|		    useUTF8 = TRUE;
 1474|      0|		}
 1475|  8.44k|		if(!IS_CACHED(s)) {
  ------------------
  |  Branch (1475:6): [True: 0, False: 8.44k]
  ------------------
 1476|      0|		    useCache = FALSE;
 1477|      0|		    break;
 1478|      0|		}
 1479|  8.44k|	    }
 1480|     88|	    if(!useBytes || useCache) {
  ------------------
  |  Branch (1480:9): [True: 88, False: 0]
  |  Branch (1480:22): [True: 0, False: 0]
  ------------------
 1481|  15.3k|		for(int i = 0; i < LENGTH(table); i++) {
  ------------------
  |  Branch (1481:18): [True: 15.2k, False: 88]
  ------------------
 1482|  15.2k|		    SEXP s = STRING_ELT(table, i);
 1483|  15.2k|		    if(IS_BYTES(s)) {
  ------------------
  |  Branch (1483:10): [True: 0, False: 15.2k]
  ------------------
 1484|      0|			useBytes = TRUE;
 1485|      0|			useUTF8 = FALSE;
 1486|      0|			break;
 1487|      0|		    }
 1488|  15.2k|		    if(ENC_KNOWN(s)) {
  ------------------
  |  Branch (1488:10): [True: 0, False: 15.2k]
  ------------------
 1489|      0|			useUTF8 = TRUE;
 1490|      0|		    }
 1491|  15.2k|		    if(!IS_CACHED(s)) {
  ------------------
  |  Branch (1491:10): [True: 0, False: 15.2k]
  ------------------
 1492|      0|			useCache = FALSE;
 1493|      0|			break;
 1494|      0|		    }
 1495|  15.2k|		}
 1496|     88|	    }
 1497|     88|	    if(useUTF8) {
  ------------------
  |  Branch (1497:9): [True: 0, False: 88]
  ------------------
 1498|      0|		x = PROTECT(asUTF8(x)); nprot++;
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1499|      0|		table = PROTECT(asUTF8(table)); nprot++;
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1500|      0|	    }
 1501|     88|	    data.useUTF8 = useUTF8;
 1502|     88|	    data.useCache = useCache;
 1503|     88|	}
 1504|     88|	DoHashing(table, &data);
 1505|     88|	if (incomp) UndoHashing(incomp, table, &data);
  ------------------
  |  Branch (1505:6): [True: 0, False: 88]
  ------------------
 1506|     88|	ans = HashLookup(table, x, &data);
 1507|     88|    }
 1508|   771k|    UNPROTECT(nprot);
  ------------------
  |  |  358|   771k|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1509|   771k|    return ans;
 1510|   771k|} // end{ match5 }
unique.c:match_transform:
 1289|  1.54M|{
 1290|  1.54M|    if(OBJECT(s)) {
  ------------------
  |  Branch (1290:8): [True: 0, False: 1.54M]
  ------------------
 1291|      0|	if(inherits(s, "factor")) return asCharacterFactor(s);
  ------------------
  |  |  933|      0|#define inherits		Rf_inherits
  ------------------
              	if(inherits(s, "factor")) return asCharacterFactor(s);
  ------------------
  |  |  883|      0|#define asCharacterFactor	Rf_asCharacterFactor
  ------------------
  |  Branch (1291:5): [True: 0, False: 0]
  ------------------
 1292|       |	/*
 1293|       |	else if(inherits(s, "POSIXlt")) { // and maybe more classes in the future:
 1294|       |					  // Call R's (generic) as.character(s):
 1295|       |	    SEXP call, r;
 1296|       |	    PROTECT(call = lang2(R_AsCharacterSymbol, s));
 1297|       |	    r = eval(call, env);
 1298|       |	    UNPROTECT(1);
 1299|       |	    return r;
 1300|       |	}
 1301|       |	*/
 1302|      0|	else {
 1303|      0|	    SEXP call, r;
 1304|      0|	    PROTECT(call = lang2(install("mtfrm"), s));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1305|      0|	    r = eval(call, env);
  ------------------
  |  |  913|      0|#define eval			Rf_eval
  ------------------
 1306|      0|	    UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1307|      0|	    return r;
 1308|      0|	}
 1309|      0|    }
 1310|       |    /* else */
 1311|  1.54M|    return duplicate(s);
  ------------------
  |  |  909|  1.54M|#define duplicate		Rf_duplicate
  ------------------
 1312|  1.54M|}
unique.c:HashLookup:
 1258|     88|{
 1259|     88|    SEXP ans;
 1260|     88|    R_xlen_t i, n;
 1261|       |
 1262|     88|    n = XLENGTH(x);
 1263|     88|    PROTECT(ans = allocVector(INTSXP, n));
  ------------------
  |  |  357|     88|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1264|     88|    int *pa = INTEGER0(ans);
 1265|       |
 1266|     88|    switch (TYPEOF(x)) {
 1267|      0|    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (1267:5): [True: 0, False: 88]
  ------------------
 1268|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (1268:14): [True: 0, False: 0]
  ------------------
 1269|      0|	    pa[i] = iLookup(table, x, i, d);
 1270|      0|	break;
 1271|      0|    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (1271:5): [True: 0, False: 88]
  ------------------
 1272|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (1272:14): [True: 0, False: 0]
  ------------------
 1273|      0|	    pa[i] = rLookup(table, x, i, d);
 1274|      0|	break;
 1275|     88|    case STRSXP:
  ------------------
  |  |  126|     88|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1275:5): [True: 88, False: 0]
  ------------------
 1276|  8.53k|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (1276:14): [True: 8.44k, False: 88]
  ------------------
 1277|  8.44k|	    pa[i] = sLookup(table, x, i, d);
 1278|     88|	break;
 1279|      0|    default:
  ------------------
  |  Branch (1279:5): [True: 0, False: 88]
  ------------------
 1280|      0|	for (i = 0; i < n; i++)
  ------------------
  |  Branch (1280:14): [True: 0, False: 0]
  ------------------
 1281|      0|	    pa[i] = Lookup(table, x, i, d);
 1282|     88|    }
 1283|       |
 1284|     88|    UNPROTECT(1);
  ------------------
  |  |  358|     88|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1285|     88|    return ans;
 1286|     88|}
unique.c:sLookup:
 1237|  8.44k|    {								\
 1238|  8.44k|	int *h = HTDATA_INT(d);					\
  ------------------
  |  |   82|  8.44k|#define HTDATA_INT(d) (INTEGER0((d)->HashTable))
  ------------------
 1239|  8.44k|	hlen i = HASHFUN(x, indx, d);				\
 1240|  11.6k|	while (h[i] != NIL) {					\
  ------------------
  |  |   51|  11.6k|#define NIL -1
  ------------------
  |  Branch (1240:9): [True: 8.03k, False: 3.64k]
  ------------------
 1241|  8.03k|	    if (EQLFUN(table, h[i], x, indx))			\
  ------------------
  |  Branch (1241:10): [True: 4.80k, False: 3.23k]
  ------------------
 1242|  8.03k|		return h[i] >= 0 ? h[i] + 1 : d->nomatch;	\
  ------------------
  |  Branch (1242:10): [True: 4.80k, False: 0]
  ------------------
 1243|  8.03k|	    i = (i + 1) % d->M;					\
 1244|  3.23k|	}							\
 1245|  8.44k|	return d->nomatch;					\
 1246|  8.44k|    }
unique.c:DoHashing:
 1220|     88|{
 1221|     88|    R_xlen_t i, n = XLENGTH(table);
 1222|  15.3k|    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (1222:17): [True: 15.2k, False: 88]
  ------------------
 1223|       |//	if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
 1224|  15.2k|	(void) isDuplicated(table, i, d);
 1225|  15.2k|    }
 1226|     88|}
unique.c:ExpandDots:
 1815|     25|{
 1816|     25|    SEXP r;
 1817|     25|    if (s == R_NilValue)
  ------------------
  |  Branch (1817:9): [True: 7, False: 18]
  ------------------
 1818|      7|	return s;
 1819|     18|    if (TYPEOF(CAR(s)) == DOTSXP ) {
  ------------------
  |  |  127|     18|#define DOTSXP	    17	  /* dot-dot-dot object */
  ------------------
  |  Branch (1819:9): [True: 0, False: 18]
  ------------------
 1820|      0|	SET_TYPEOF(CAR(s), LISTSXP);	/* a safe mutation */
  ------------------
  |  |  113|      0|#define LISTSXP	     2	  /* lists of dotted pairs */
  ------------------
 1821|      0|	if (expdots) {
  ------------------
  |  Branch (1821:6): [True: 0, False: 0]
  ------------------
 1822|      0|	    r = CAR(s);
 1823|      0|	    while (CDR(r) != R_NilValue ) {
  ------------------
  |  Branch (1823:13): [True: 0, False: 0]
  ------------------
 1824|      0|		SET_ARGUSED(r, 1);
  ------------------
  |  |   53|      0|#define SET_ARGUSED(x,v) SETLEVELS(x,v)
  ------------------
 1825|      0|		r = CDR(r);
 1826|      0|	    }
 1827|      0|	    SET_ARGUSED(r, 1);
  ------------------
  |  |   53|      0|#define SET_ARGUSED(x,v) SETLEVELS(x,v)
  ------------------
 1828|      0|	    SETCDR(r, ExpandDots(CDR(s), expdots));
 1829|      0|	    return CAR(s);
 1830|      0|	}
 1831|      0|    }
 1832|     18|    else
 1833|     18|	SET_ARGUSED(s, 0);
  ------------------
  |  |   53|     18|#define SET_ARGUSED(x,v) SETLEVELS(x,v)
  ------------------
 1834|     18|    SETCDR(s, ExpandDots(CDR(s), expdots));
 1835|     18|    return s;
 1836|     18|}
unique.c:StripUnmatched:
 1799|     25|{
 1800|     25|    if (s == R_NilValue) return s;
  ------------------
  |  Branch (1800:9): [True: 7, False: 18]
  ------------------
 1801|       |
 1802|     18|    if (CAR(s) == R_MissingArg && !ARGUSED(s) ) {
  ------------------
  |  |   52|      6|#define ARGUSED(x) LEVELS(x)
  ------------------
  |  Branch (1802:9): [True: 6, False: 12]
  |  Branch (1802:35): [True: 6, False: 0]
  ------------------
 1803|      6|	return StripUnmatched(CDR(s));
 1804|      6|    }
 1805|     12|    else if (CAR(s) == R_DotsSymbol ) {
  ------------------
  |  Branch (1805:14): [True: 0, False: 12]
  ------------------
 1806|      0|	return StripUnmatched(CDR(s));
 1807|      0|    }
 1808|     12|    else {
 1809|     12|	SETCDR(s, StripUnmatched(CDR(s)));
 1810|     12|	return s;
 1811|     12|    }
 1812|     18|}
unique.c:duplicated2:
 2158|      2|{
 2159|      2|    SEXP ans;
 2160|      2|    int i, n;
 2161|       |
 2162|      2|    n = LENGTH(x);
 2163|      2|    HashTableSetup(x, d, NA_INTEGER);
  ------------------
  |  |   56|      2|#define NA_INTEGER	R_NaInt
  ------------------
 2164|      2|    PROTECT(d->HashTable);
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2165|      2|    PROTECT(ans = allocVector(INTSXP, n));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
 2166|       |
 2167|      2|    int *h = HTDATA_INT(d);
  ------------------
  |  |   82|      2|#define HTDATA_INT(d) (INTEGER0((d)->HashTable))
  ------------------
 2168|      2|    int *v = INTEGER0(ans);
 2169|     34|    for (i = 0; i < d->M; i++) h[i] = NIL;
  ------------------
  |  |   51|     32|#define NIL -1
  ------------------
  |  Branch (2169:17): [True: 32, False: 2]
  ------------------
 2170|     14|    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (2170:17): [True: 12, False: 2]
  ------------------
 2171|       |//	if ((i+1) % NINTERRUPT == 0) R_CheckUserInterrupt();
 2172|     12|	v[i] = isDuplicated2(x, i, d);
 2173|     12|    }
 2174|      2|    UNPROTECT(2);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 2175|      2|    return ans;
 2176|      2|}
unique.c:isDuplicated2:
 2145|     12|{
 2146|     12|    int *h = HTDATA_INT(d);
  ------------------
  |  |   82|     12|#define HTDATA_INT(d) (INTEGER0((d)->HashTable))
  ------------------
 2147|     12|    hlen i = d->hash(x, indx, d);
 2148|     16|    while (h[i] != NIL) {
  ------------------
  |  |   51|     16|#define NIL -1
  ------------------
  |  Branch (2148:12): [True: 4, False: 12]
  ------------------
 2149|      4|	if (d->equal(x, h[i], x, indx))
  ------------------
  |  Branch (2149:6): [True: 0, False: 4]
  ------------------
 2150|      0|	    return h[i] + 1;
 2151|      4|	i = (i + 1) % d->M;
 2152|      4|    }
 2153|     12|    h[i] = indx;
 2154|     12|    return 0;
 2155|     12|}

Rf_nrows:
   82|  3.46k|{
   83|  3.46k|    if (isVector(s) || isList(s)) {
  ------------------
  |  |  974|  3.46k|#define isVector		Rf_isVector
  ------------------
                  if (isVector(s) || isList(s)) {
  ------------------
  |  |  951|      0|#define isList			Rf_isList
  ------------------
  |  Branch (83:9): [True: 3.46k, False: 0]
  |  Branch (83:24): [True: 0, False: 0]
  ------------------
   84|  3.46k|	SEXP t = getAttrib(s, R_DimSymbol);
  ------------------
  |  |  924|  3.46k|#define getAttrib		Rf_getAttrib
  ------------------
   85|  3.46k|	if (t == R_NilValue) return LENGTH(s);
  ------------------
  |  Branch (85:6): [True: 0, False: 3.46k]
  ------------------
   86|  3.46k|	return INTEGER(t)[0];
   87|  3.46k|    } else
   88|      0|	error(_("object is not a matrix"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("object is not a matrix"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
   89|      0|    return -1;
   90|  3.46k|}
Rf_ncols:
   94|  3.47k|{
   95|  3.47k|    if (isVector(s) || isList(s)) {
  ------------------
  |  |  974|  3.47k|#define isVector		Rf_isVector
  ------------------
                  if (isVector(s) || isList(s)) {
  ------------------
  |  |  951|      0|#define isList			Rf_isList
  ------------------
  |  Branch (95:9): [True: 3.47k, False: 0]
  |  Branch (95:24): [True: 0, False: 0]
  ------------------
   96|  3.47k|	SEXP t = getAttrib(s, R_DimSymbol);
  ------------------
  |  |  924|  3.47k|#define getAttrib		Rf_getAttrib
  ------------------
   97|  3.47k|	if (t == R_NilValue) return 1;
  ------------------
  |  Branch (97:6): [True: 0, False: 3.47k]
  ------------------
   98|  3.47k|	if (LENGTH(t) >= 2) return INTEGER(t)[1];
  ------------------
  |  Branch (98:6): [True: 3.47k, False: 0]
  ------------------
   99|       |	/* This is a 1D (or possibly 0D array) */
  100|      0|	return 1;
  101|  3.47k|    } else
  102|      0|	error(_("object is not a matrix"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("object is not a matrix"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  103|      0|    return -1;/*NOTREACHED*/
  104|  3.47k|}
Rf_asChar:
  137|    103|{
  138|    103|	if (isVectorAtomic(x) && XLENGTH(x) >= 1) {
  ------------------
  |  |  975|    103|#define isVectorAtomic		Rf_isVectorAtomic
  ------------------
  |  Branch (138:6): [True: 103, False: 0]
  |  Branch (138:27): [True: 103, False: 0]
  ------------------
  139|    103|	    int w, d, e, wi, di, ei;
  140|    103|	    char buf[MAXELTSIZE];  /* Probably 100 would suffice */
  141|       |
  142|    103|	    switch (TYPEOF(x)) {
  143|      0|	    case LGLSXP:
  ------------------
  |  |  121|      0|#define LGLSXP	    10	  /* logical vectors */
  ------------------
  |  Branch (143:6): [True: 0, False: 103]
  ------------------
  144|      0|		if (LOGICAL(x)[0] == NA_LOGICAL)
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (144:7): [True: 0, False: 0]
  ------------------
  145|      0|		    return NA_STRING;
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  146|      0|		if (LOGICAL(x)[0])
  ------------------
  |  Branch (146:7): [True: 0, False: 0]
  ------------------
  147|      0|		    snprintf(buf, MAXELTSIZE, "TRUE");
  ------------------
  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
  148|      0|		else
  149|      0|		    snprintf(buf, MAXELTSIZE, "FALSE");
  ------------------
  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
  150|      0|		return mkChar(buf);
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  151|      0|	    case INTSXP:
  ------------------
  |  |  123|      0|#define INTSXP	    13	  /* integer vectors */
  ------------------
  |  Branch (151:6): [True: 0, False: 103]
  ------------------
  152|      0|		if (INTEGER(x)[0] == NA_INTEGER)
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (152:7): [True: 0, False: 0]
  ------------------
  153|      0|		    return NA_STRING;
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  154|      0|		snprintf(buf, MAXELTSIZE, "%d", INTEGER(x)[0]);
  ------------------
  |  |   85|      0|#define MAXELTSIZE 8192 /* Used as a default for string buffer sizes,
  ------------------
  155|      0|		return mkChar(buf);
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  156|      0|	    case REALSXP:
  ------------------
  |  |  124|      0|#define REALSXP	    14	  /* real variables */
  ------------------
  |  Branch (156:6): [True: 0, False: 103]
  ------------------
  157|      0|		PrintDefaults();
  ------------------
  |  | 1970|      0|# define PrintDefaults		Rf_PrintDefaults
  ------------------
  158|      0|		formatReal(REAL(x), 1, &w, &d, &e, 0);
  ------------------
  |  |   41|      0|#define formatReal         Rf_formatReal
  ------------------
  159|      0|		return mkChar(EncodeReal0(REAL(x)[0], w, d, e, OutDec));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
              		return mkChar(EncodeReal0(REAL(x)[0], w, d, e, OutDec));
  ------------------
  |  |   46|      0|#define EncodeReal0        Rf_EncodeReal0
  ------------------
  160|      0|	    case CPLXSXP:
  ------------------
  |  |  125|      0|#define CPLXSXP	    15	  /* complex variables */
  ------------------
  |  Branch (160:6): [True: 0, False: 103]
  ------------------
  161|      0|		PrintDefaults();
  ------------------
  |  | 1970|      0|# define PrintDefaults		Rf_PrintDefaults
  ------------------
  162|      0|		formatComplex(COMPLEX(x), 1, &w, &d, &e, &wi, &di, &ei, 0);
  ------------------
  |  |   42|      0|#define formatComplex      Rf_formatComplex
  ------------------
  163|      0|		return mkChar(EncodeComplex(COMPLEX(x)[0], w, d, e, wi, di, ei, OutDec));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
              		return mkChar(EncodeComplex(COMPLEX(x)[0], w, d, e, wi, di, ei, OutDec));
  ------------------
  |  |   47|      0|#define EncodeComplex      Rf_EncodeComplex
  ------------------
  164|    103|	    case STRSXP:
  ------------------
  |  |  126|    103|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (164:6): [True: 103, False: 0]
  ------------------
  165|    103|		return STRING_ELT(x, 0);
  166|      0|	    default:
  ------------------
  |  Branch (166:6): [True: 0, False: 103]
  ------------------
  167|      0|		return NA_STRING;
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  168|    103|	    }
  169|    103|	} else if(TYPEOF(x) == CHARSXP) {
  ------------------
  |  |  120|      0|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (169:12): [True: 0, False: 0]
  ------------------
  170|      0|	    return x;
  171|      0|	} else if(TYPEOF(x) == SYMSXP)
  ------------------
  |  |  112|      0|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (171:12): [True: 0, False: 0]
  ------------------
  172|      0|	    return PRINTNAME(x);
  173|      0|    return NA_STRING;
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  174|    103|}
Rf_str2type:
  242|   392k|{
  243|   392k|    int i;
  244|  7.44M|    for (i = 0; TypeTable[i].str; i++) {
  ------------------
  |  Branch (244:17): [True: 7.44M, False: 0]
  ------------------
  245|  7.44M|	if (!strcmp(s, TypeTable[i].str))
  ------------------
  |  Branch (245:6): [True: 392k, False: 7.05M]
  ------------------
  246|   392k|	    return (SEXPTYPE) TypeTable[i].type;
  247|  7.44M|    }
  248|       |
  249|       |    /* SEXPTYPE is an unsigned int, so the compiler warns us w/o the cast. */
  250|      0|    return (SEXPTYPE) -1;
  251|   392k|}
Rf_InitTypeTables:
  271|      2|void InitTypeTables(void) {
  272|       |
  273|       |    /* Type2Table */
  274|     66|    for (int type = 0; type < MAX_NUM_SEXPTYPE; type++) {
  ------------------
  |  |  184|     66|#define MAX_NUM_SEXPTYPE (1<<TYPE_BITS)
  |  |  ------------------
  |  |  |  |  183|     66|#define TYPE_BITS 5
  |  |  ------------------
  ------------------
  |  Branch (274:24): [True: 64, False: 2]
  ------------------
  275|     64|	int j = findTypeInTypeTable(type);
  276|       |
  277|     64|	if (j != -1) {
  ------------------
  |  Branch (277:6): [True: 48, False: 16]
  ------------------
  278|     48|	    const char *cstr = TypeTable[j].str;
  279|     48|	    SEXP rchar = PROTECT(mkChar(cstr));
  ------------------
  |  |  357|     48|#define PROTECT(s)	Rf_protect(s)
  ------------------
  280|     48|	    SEXP rstr = ScalarString(rchar);
  ------------------
  |  | 1025|     48|#define ScalarString		Rf_ScalarString
  ------------------
  281|     48|	    MARK_NOT_MUTABLE(rstr);
  282|     48|	    R_PreserveObject(rstr);
  283|     48|	    SEXP rsym = install(cstr);
  ------------------
  |  |  934|     48|#define install			Rf_install
  ------------------
  284|       |
  285|     48|	    Type2Table[type].cstrName = cstr;
  286|     48|	    Type2Table[type].rcharName = rchar;
  287|     48|	    Type2Table[type].rstrName = rstr;
  288|     48|	    Type2Table[type].rsymName = rsym;
  289|     48|	    UNPROTECT(1); /* rchar */
  ------------------
  |  |  358|     48|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  290|     48|	} else {
  291|     16|	    Type2Table[type].cstrName = NULL;
  292|     16|	    Type2Table[type].rcharName = NULL;
  293|     16|	    Type2Table[type].rstrName = NULL;
  294|       |	    Type2Table[type].rsymName = NULL;
  295|     16|	}
  296|     64|    }
  297|      2|}
Rf_type2str_nowarn:
  300|  1.54k|{
  301|       |    // if (t >= 0 && t < MAX_NUM_SEXPTYPE) { /* branch not really needed */
  302|  1.54k|	SEXP res = Type2Table[t].rcharName;
  303|  1.54k|	if (res != NULL) return res;
  ------------------
  |  Branch (303:6): [True: 1.52k, False: 16]
  ------------------
  304|       |    // }
  305|     16|    return R_NilValue;
  306|  1.54k|}
Rf_type2str:
  309|  1.48k|{
  310|  1.48k|    SEXP s = type2str_nowarn(t);
  ------------------
  |  | 1043|  1.48k|#define type2str_nowarn		Rf_type2str_nowarn
  ------------------
  311|  1.48k|    if (s != R_NilValue) {
  ------------------
  |  Branch (311:9): [True: 1.48k, False: 0]
  ------------------
  312|  1.48k|	return s;
  313|  1.48k|    }
  314|      0|    warning(_("type %d is unimplemented in '%s'"), t, "type2str");
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
                  warning(_("type %d is unimplemented in '%s'"), t, "type2str");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  315|      0|    char buf[50];
  316|      0|    snprintf(buf, 50, "unknown type #%d", t);
  317|      0|    return mkChar(buf);
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  318|  1.48k|}
Rf_type2rstr:
  321|  1.16k|{
  322|       |    // if (t < MAX_NUM_SEXPTYPE) {
  323|  1.16k|	SEXP res = Type2Table[t].rstrName;
  324|  1.16k|	if (res != NULL) return res;
  ------------------
  |  Branch (324:6): [True: 1.16k, False: 0]
  ------------------
  325|       |    // }
  326|      0|    error(_("type %d is unimplemented in '%s'"), t,
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  error(_("type %d is unimplemented in '%s'"), t,
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  327|      0|	  "type2ImmutableScalarString");
  328|      0|    return R_NilValue; /* for -Wall */
  329|  1.16k|}
Rf_isBlankString:
  448|  1.12M|{
  449|  1.12M|    if(mbcslocale) {
  ------------------
  |  Branch (449:8): [True: 0, False: 1.12M]
  ------------------
  450|      0|	wchar_t wc; size_t used; mbstate_t mb_st;
  451|      0|	mbs_init(&mb_st);
  ------------------
  |  | 2454|      0|#define mbs_init(x) memset(x, 0, sizeof(mbstate_t))
  ------------------
  452|       |	// This does not allow for surrogate pairs, but all blanks are in BMP
  453|      0|	while( (used = Mbrtowc(&wc, s, R_MB_CUR_MAX, &mb_st)) ) {
  ------------------
  |  | 1949|      0|# define Mbrtowc		Rf_mbrtowc
  ------------------
  |  Branch (453:9): [True: 0, False: 0]
  ------------------
  454|      0|	    if(!iswspace((wint_t) wc)) return FALSE;
  ------------------
  |  Branch (454:9): [True: 0, False: 0]
  ------------------
  455|      0|	    s += used;
  456|      0|	}
  457|      0|    } else
  458|  1.13M|	while (*s)
  ------------------
  |  Branch (458:9): [True: 538k, False: 592k]
  ------------------
  459|   538k|	    if (!isspace((int)*s++)) return FALSE;
  ------------------
  |  Branch (459:10): [True: 533k, False: 4.95k]
  ------------------
  460|   592k|    return TRUE;
  461|  1.12M|}
Rf_StringTrue:
  474|     58|{
  475|     58|    int i;
  476|    222|    for (i = 0; truenames[i]; i++)
  ------------------
  |  Branch (476:17): [True: 198, False: 24]
  ------------------
  477|    198|	if (!strcmp(name, truenames[i]))
  ------------------
  |  Branch (477:6): [True: 34, False: 164]
  ------------------
  478|     34|	    return TRUE;
  479|     24|    return FALSE;
  480|     58|}
Rf_StringFalse:
  484|     58|{
  485|     58|    int i;
  486|    246|    for (i = 0; falsenames[i]; i++)
  ------------------
  |  Branch (486:17): [True: 210, False: 36]
  ------------------
  487|    210|	if (!strcmp(name, falsenames[i]))
  ------------------
  |  Branch (487:6): [True: 22, False: 188]
  ------------------
  488|     22|	    return TRUE;
  489|     36|    return FALSE;
  490|     58|}
Rf_EnsureString:
  494|  3.09M|{
  495|  3.09M|    switch(TYPEOF(s)) {
  496|    114|    case SYMSXP:
  ------------------
  |  |  112|    114|#define SYMSXP	     1	  /* symbols */
  ------------------
  |  Branch (496:5): [True: 114, False: 3.09M]
  ------------------
  497|    114|	s = PRINTNAME(s);
  498|    114|	break;
  499|      0|    case STRSXP:
  ------------------
  |  |  126|      0|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (499:5): [True: 0, False: 3.09M]
  ------------------
  500|      0|	s = STRING_ELT(s, 0);
  501|      0|	break;
  502|  1.54M|    case CHARSXP:
  ------------------
  |  |  120|  1.54M|#define CHARSXP	     9	  /* "scalar" string type (internal only)*/
  ------------------
  |  Branch (502:5): [True: 1.54M, False: 1.54M]
  ------------------
  503|  1.54M|	break;
  504|  1.54M|    case NILSXP:
  ------------------
  |  |  111|  1.54M|#define NILSXP	     0	  /* nil = NULL */
  ------------------
  |  Branch (504:5): [True: 1.54M, False: 1.54M]
  ------------------
  505|  1.54M|	s = R_BlankString;
  506|  1.54M|	break;
  507|      0|    default:
  ------------------
  |  Branch (507:5): [True: 0, False: 3.09M]
  ------------------
  508|      0|	error(_("invalid tag in name extraction"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid tag in name extraction"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  509|  3.09M|    }
  510|  3.09M|    return s;
  511|  3.09M|}
Rf_checkArityCall:
  515|  11.2M|{
  516|  11.2M|    if (PRIMARITY(op) >= 0 && PRIMARITY(op) != length(args)) {
  ------------------
  |  | 1348|  11.2M|#define PRIMARITY(x)	(R_FunTab[PRIMOFFSET(x)].arity)
  ------------------
                  if (PRIMARITY(op) >= 0 && PRIMARITY(op) != length(args)) {
  ------------------
  |  | 1348|  10.1M|#define PRIMARITY(x)	(R_FunTab[PRIMOFFSET(x)].arity)
  ------------------
                  if (PRIMARITY(op) >= 0 && PRIMARITY(op) != length(args)) {
  ------------------
  |  |  987|  10.1M|#define length(x)		Rf_length(x)
  ------------------
  |  Branch (516:9): [True: 10.1M, False: 1.16M]
  |  Branch (516:31): [True: 0, False: 10.1M]
  ------------------
  517|       |	/* FIXME: ngettext reguires unsigned long, but %u would seem appropriate */
  518|      0|	if (PRIMINTERNAL(op))
  ------------------
  |  | 1351|      0|#define PRIMINTERNAL(x) (((R_FunTab[PRIMOFFSET(x)].eval)%100)/10)
  |  |  ------------------
  |  |  |  |  913|      0|#define eval			Rf_eval
  |  |  ------------------
  |  |  |  Branch (1351:25): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  519|      0|	    error(ngettext("%d argument passed to .Internal(%s) which requires %d",
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  520|      0|		     "%d arguments passed to .Internal(%s) which requires %d",
  521|      0|			   (unsigned long) length(args)),
  522|      0|		  length(args), PRIMNAME(op), PRIMARITY(op));
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
              		  length(args), PRIMNAME(op), PRIMARITY(op));
  ------------------
  |  | 1346|      0|#define PRIMNAME(x)	(R_FunTab[PRIMOFFSET(x)].name)
  ------------------
              		  length(args), PRIMNAME(op), PRIMARITY(op));
  ------------------
  |  | 1348|      0|#define PRIMARITY(x)	(R_FunTab[PRIMOFFSET(x)].arity)
  ------------------
  523|      0|	else
  524|      0|	    errorcall(call,
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
  525|      0|		      ngettext("%d argument passed to '%s' which requires %d",
  526|      0|			       "%d arguments passed to '%s' which requires %d",
  527|      0|			       (unsigned long) length(args)),
  528|      0|		      length(args), PRIMNAME(op), PRIMARITY(op));
  ------------------
  |  |  987|      0|#define length(x)		Rf_length(x)
  ------------------
              		      length(args), PRIMNAME(op), PRIMARITY(op));
  ------------------
  |  | 1346|      0|#define PRIMNAME(x)	(R_FunTab[PRIMOFFSET(x)].name)
  ------------------
              		      length(args), PRIMNAME(op), PRIMARITY(op));
  ------------------
  |  | 1348|      0|#define PRIMARITY(x)	(R_FunTab[PRIMOFFSET(x)].arity)
  ------------------
  529|      0|    }
  530|  11.2M|}
Rf_check1arg:
  533|  5.82M|{
  534|  5.82M|    SEXP tag = TAG(arg);
  535|  5.82M|    if (tag == R_NilValue) return;
  ------------------
  |  Branch (535:9): [True: 5.82M, False: 0]
  ------------------
  536|      0|    const char *supplied = CHAR(PRINTNAME(tag));
  ------------------
  |  |  203|      0|#define CHAR(x) R_CHAR(x)
  ------------------
  537|      0|    size_t ns = strlen(supplied);
  538|      0|    if (ns > strlen(formal) || strncmp(supplied, formal, ns))
  ------------------
  |  Branch (538:9): [True: 0, False: 0]
  |  Branch (538:32): [True: 0, False: 0]
  ------------------
  539|      0|	errorcall(call, _("supplied argument name '%s' does not match '%s'"),
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	errorcall(call, _("supplied argument name '%s' does not match '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  540|      0|		  supplied, formal);
  541|      0|    if (R_warn_partial_match_args && ns > 0 && ns < strlen(formal)) {
  ------------------
  |  Branch (541:9): [True: 0, False: 0]
  |  Branch (541:38): [True: 0, False: 0]
  |  Branch (541:48): [True: 0, False: 0]
  ------------------
  542|      0|	SEXP fsym = install(formal);
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
  543|      0|	SEXP cond = R_makePartialArgumentMatchWarningCondition(call, tag, fsym);
  544|      0|	PROTECT(cond);
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
  545|      0|	R_signalWarningCondition(cond);
  546|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  547|      0|    }
  548|      0|}
Rf_nthcdr:
  551|  1.37k|{
  552|  1.37k|    if (isPairList(s)) {
  ------------------
  |  |  961|  1.37k|#define isPairList		Rf_isPairList
  ------------------
  |  Branch (552:9): [True: 1.37k, False: 0]
  ------------------
  553|  1.54k|	while( n-- > 0 ) {
  ------------------
  |  Branch (553:9): [True: 167, False: 1.37k]
  ------------------
  554|    167|	    if (s == R_NilValue)
  ------------------
  |  Branch (554:10): [True: 0, False: 167]
  ------------------
  555|      0|		error(_("'nthcdr' list shorter than %d"), n);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("'nthcdr' list shorter than %d"), n);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  556|    167|	    s = CDR(s);
  557|    167|	}
  558|  1.37k|	return s;
  559|  1.37k|    }
  560|      0|    else error(_("'nthcdr' needs a list to CDR down"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
                  else error(_("'nthcdr' needs a list to CDR down"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  561|      0|    return R_NilValue;/* for -Wall */
  562|  1.37k|}
R_listCompact:
  566|   773k|SEXP R_listCompact(SEXP s, bool keep_initial) {
  567|   773k|    if(!keep_initial)
  ------------------
  |  Branch (567:8): [True: 0, False: 773k]
  ------------------
  568|       |    // skip initial NULL values
  569|      0|	while (s != R_NilValue && CAR(s) == R_NilValue)
  ------------------
  |  Branch (569:9): [True: 0, False: 0]
  |  Branch (569:28): [True: 0, False: 0]
  ------------------
  570|      0|	    s = CDR(s);
  571|       |
  572|   773k|    SEXP val = s;
  573|   773k|    SEXP prev = s;
  574|  2.32M|    while (s != R_NilValue) {
  ------------------
  |  Branch (574:12): [True: 1.54M, False: 773k]
  ------------------
  575|  1.54M|	s = CDR(s);
  576|  1.54M|	if (CAR(s) == R_NilValue) // skip it
  ------------------
  |  Branch (576:6): [True: 773k, False: 774k]
  ------------------
  577|   773k|	    SETCDR(prev, CDR(s));
  578|   774k|	else
  579|   774k|	    prev = s;
  580|  1.54M|    }
  581|   773k|    return val;
  582|   773k|}
do_nargs:
  587|     68|{
  588|     68|    RCNTXT *cptr;
  589|     68|    int nargs = NA_INTEGER;
  ------------------
  |  |   56|     68|#define NA_INTEGER	R_NaInt
  ------------------
  590|       |
  591|     68|    checkArity(op, args);
  ------------------
  |  | 1788|     68|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  592|     68|    for (cptr = R_GlobalContext; cptr != NULL; cptr = cptr->nextcontext) {
  ------------------
  |  Branch (592:34): [True: 68, False: 0]
  ------------------
  593|     68|	if ((cptr->callflag & CTXT_FUNCTION) && cptr->cloenv == rho) {
  ------------------
  |  Branch (593:6): [True: 68, False: 0]
  |  Branch (593:42): [True: 68, False: 0]
  ------------------
  594|     68|	    nargs = length(cptr->promargs);
  ------------------
  |  |  987|     68|#define length(x)		Rf_length(x)
  ------------------
  595|     68|	    break;
  596|     68|	}
  597|     68|    }
  598|     68|    return ScalarInteger(nargs);
  ------------------
  |  | 1022|     68|#define ScalarInteger		Rf_ScalarInteger
  ------------------
  599|     68|}
do_basename:
  905|     14|{
  906|     14|    SEXP ans, s = R_NilValue;	/* -Wall */
  907|     14|    const char fsp = FILESEP[0];
  ------------------
  |  |  993|     14|# define FILESEP     "/"
  ------------------
  908|     14|    const char *pp;
  909|     14|    int i, n;
  910|       |
  911|     14|    checkArity(op, args);
  ------------------
  |  | 1788|     14|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  912|     14|    if (TYPEOF(s = CAR(args)) != STRSXP)
  ------------------
  |  |  126|     14|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (912:9): [True: 0, False: 14]
  ------------------
  913|      0|	error(_("a character vector argument expected"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("a character vector argument expected"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  914|     14|    PROTECT(ans = allocVector(STRSXP, n = LENGTH(s)));
  ------------------
  |  |  357|     14|#define PROTECT(s)	Rf_protect(s)
  ------------------
  915|     28|    for(i = 0; i < n; i++) {
  ------------------
  |  Branch (915:16): [True: 14, False: 14]
  ------------------
  916|     14|	if (STRING_ELT(s, i) == NA_STRING)
  ------------------
  |  |  433|     14|#define NA_STRING	R_NaString
  ------------------
  |  Branch (916:6): [True: 0, False: 14]
  ------------------
  917|      0|	    SET_STRING_ELT(ans, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
  918|     14|	else {
  919|     14|	    pp = R_ExpandFileName(translateCharFP(STRING_ELT(s, i)));
  ------------------
  |  | 1998|     14|# define translateCharFP	Rf_translateCharFP
  ------------------
  920|     14|	    size_t ll = strlen(pp);
  921|     14|	    if (ll > R_PATH_MAX - 1)
  ------------------
  |  | 1150|     14|# define R_PATH_MAX PATH_MAX
  ------------------
  |  Branch (921:10): [True: 0, False: 14]
  ------------------
  922|      0|		error(_("path too long"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("path too long"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  923|       |	    /* remove trailing file separator(s) */
  924|     14|	    while(ll && pp[ll-1] == fsp) ll--;
  ------------------
  |  Branch (924:12): [True: 14, False: 0]
  |  Branch (924:18): [True: 0, False: 14]
  ------------------
  925|     14|	    size_t ff = ll;
  926|       |	    /* find start of file part */
  927|    114|	    while(ff && pp[ff-1] != fsp) ff--;
  ------------------
  |  Branch (927:12): [True: 114, False: 0]
  |  Branch (927:18): [True: 100, False: 14]
  ------------------
  928|     14|	    SET_STRING_ELT(ans, i, mkCharLenCE(pp+ff, (int)(ll-ff), CE_NATIVE));
  ------------------
  |  | 1001|     14|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
  929|     14|	}
  930|     14|    }
  931|     14|    UNPROTECT(1);
  ------------------
  |  |  358|     14|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  932|     14|    return(ans);
  933|     14|}
do_dirname:
 1013|     28|{
 1014|     28|    SEXP ans, s = R_NilValue;	/* -Wall */
 1015|     28|    const char fsp = FILESEP[0];
  ------------------
  |  |  993|     28|# define FILESEP     "/"
  ------------------
 1016|     28|    const char *pp;
 1017|     28|    int i, n;
 1018|       |
 1019|     28|    checkArity(op, args);
  ------------------
  |  | 1788|     28|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1020|     28|    if (TYPEOF(s = CAR(args)) != STRSXP)
  ------------------
  |  |  126|     28|#define STRSXP	    16	  /* string vectors */
  ------------------
  |  Branch (1020:9): [True: 0, False: 28]
  ------------------
 1021|      0|	error(_("a character vector argument expected"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("a character vector argument expected"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1022|     28|    PROTECT(ans = allocVector(STRSXP, n = LENGTH(s)));
  ------------------
  |  |  357|     28|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1023|     56|    for(i = 0; i < n; i++) {
  ------------------
  |  Branch (1023:16): [True: 28, False: 28]
  ------------------
 1024|     28|	if (STRING_ELT(s, i) == NA_STRING)
  ------------------
  |  |  433|     28|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1024:6): [True: 0, False: 28]
  ------------------
 1025|      0|	    SET_STRING_ELT(ans, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
 1026|     28|	else {
 1027|     28|	    pp = R_ExpandFileName(translateCharFP(STRING_ELT(s, i)));
  ------------------
  |  | 1998|     28|# define translateCharFP	Rf_translateCharFP
  ------------------
 1028|     28|	    size_t ll = strlen(pp);
 1029|     28|	    if (ll > R_PATH_MAX - 1)
  ------------------
  |  | 1150|     28|# define R_PATH_MAX PATH_MAX
  ------------------
  |  Branch (1029:10): [True: 0, False: 28]
  ------------------
 1030|      0|		error(_("path too long"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              		error(_("path too long"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1031|     28|	    if (ll) { // svMisc calls this with ""
  ------------------
  |  Branch (1031:10): [True: 28, False: 0]
  ------------------
 1032|       |		/* remove trailing file separator(s) */
 1033|     28|		while(ll && pp[ll-1] == fsp) ll--;
  ------------------
  |  Branch (1033:9): [True: 28, False: 0]
  |  Branch (1033:15): [True: 0, False: 28]
  ------------------
 1034|     28|		if (!ll) { /* only separators */
  ------------------
  |  Branch (1034:7): [True: 0, False: 28]
  ------------------
 1035|      0|		    SET_STRING_ELT(ans, i, mkCharLenCE(&fsp, 1, CE_NATIVE));
  ------------------
  |  | 1001|      0|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
 1036|      0|		    continue;
 1037|      0|		}
 1038|       |		/* remove file part */
 1039|    234|		while(ll && pp[ll-1] != fsp) ll--;
  ------------------
  |  Branch (1039:9): [True: 234, False: 0]
  |  Branch (1039:15): [True: 206, False: 28]
  ------------------
 1040|     28|		if (!ll) { /* only file part */
  ------------------
  |  Branch (1040:7): [True: 0, False: 28]
  ------------------
 1041|      0|		    SET_STRING_ELT(ans, i, mkChar("."));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 1042|      0|		    continue;
 1043|      0|		}
 1044|       |		/* remove separator(s) after directory part */
 1045|     56|		while(ll && pp[ll-1] == fsp) ll--;
  ------------------
  |  Branch (1045:9): [True: 56, False: 0]
  |  Branch (1045:15): [True: 28, False: 28]
  ------------------
 1046|     28|		if (!ll) { /* only single part */
  ------------------
  |  Branch (1046:7): [True: 0, False: 28]
  ------------------
 1047|      0|		    SET_STRING_ELT(ans, i, mkCharLenCE(&fsp, 1, CE_NATIVE));
  ------------------
  |  | 1001|      0|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
 1048|      0|		    continue;
 1049|      0|		}
 1050|     28|		SET_STRING_ELT(ans, i, mkCharLenCE(pp, (int)ll, CE_NATIVE));
  ------------------
  |  | 1001|     28|#define mkCharLenCE		Rf_mkCharLenCE
  ------------------
 1051|     28|	    } else
 1052|       |		/* empty pathname is invalid, but returned */
 1053|      0|		SET_STRING_ELT(ans, i, mkChar(""));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
 1054|     28|	}
 1055|     28|    }
 1056|     28|    UNPROTECT(1);
  ------------------
  |  |  358|     28|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1057|     28|    return(ans);
 1058|     28|}
do_normalizepath:
 1068|     42|{
 1069|     42|    SEXP ans, paths = CAR(args), elp;
 1070|     42|    int i, n = LENGTH(paths);
 1071|     42|    const char *path;
 1072|     42|    char abspath[R_PATH_MAX+1];
 1073|       |
 1074|     42|    checkArity(op, args);
  ------------------
  |  | 1788|     42|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1075|     42|    if (!isString(paths))
  ------------------
  |  |  966|     42|#define isString		Rf_isString
  ------------------
  |  Branch (1075:9): [True: 0, False: 42]
  ------------------
 1076|      0|	error(_("'path' must be a character vector"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'path' must be a character vector"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1077|       |
 1078|     42|    int mustWork = asLogical(CADDR(args)); /* 1, NA_LOGICAL or 0 */
  ------------------
  |  |  886|     42|#define asLogical		Rf_asLogical
  ------------------
 1079|       |
 1080|       |/* Does any platform not have this? */
 1081|     42|#ifdef HAVE_REALPATH
 1082|     42|    PROTECT(ans = allocVector(STRSXP, n));
  ------------------
  |  |  357|     42|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1083|     84|    for (i = 0; i < n; i++) {
  ------------------
  |  Branch (1083:17): [True: 42, False: 42]
  ------------------
 1084|     42|	elp = STRING_ELT(paths, i);
 1085|     42|	if (elp == NA_STRING) {
  ------------------
  |  |  433|     42|#define NA_STRING	R_NaString
  ------------------
  |  Branch (1085:6): [True: 0, False: 42]
  ------------------
 1086|      0|	    SET_STRING_ELT(ans, i, NA_STRING);
  ------------------
  |  |  433|      0|#define NA_STRING	R_NaString
  ------------------
 1087|      0|	    if (mustWork == 1)
  ------------------
  |  Branch (1087:10): [True: 0, False: 0]
  ------------------
 1088|      0|		error("path[%d]=NA", i+1);
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 1089|      0|	    else if (mustWork == NA_LOGICAL)
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1089:15): [True: 0, False: 0]
  ------------------
 1090|      0|		warning("path[%d]=NA", i+1);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
 1091|      0|	    continue;
 1092|      0|	}
 1093|     42|	path = translateCharFP2(elp);
  ------------------
  |  | 1999|     42|# define translateCharFP2	Rf_translateCharFP2
  ------------------
 1094|     42|	if (path) {
  ------------------
  |  Branch (1094:6): [True: 42, False: 0]
  ------------------
 1095|     42|	    char *res = realpath(path, abspath);
 1096|     42|	    if (res)
  ------------------
  |  Branch (1096:10): [True: 42, False: 0]
  ------------------
 1097|     42|		SET_STRING_ELT(ans, i, mkChar(abspath));
  ------------------
  |  |  998|     42|#define mkChar			Rf_mkChar
  ------------------
 1098|      0|	    else {
 1099|      0|		SET_STRING_ELT(ans, i, elp);
 1100|       |		/* and report the problem */
 1101|      0|		if (mustWork == 1)
  ------------------
  |  Branch (1101:7): [True: 0, False: 0]
  ------------------
 1102|      0|		    error("path[%d]=\"%s\": %s", i+1, path, strerror(errno));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
 1103|      0|		else if (mustWork == NA_LOGICAL)
  ------------------
  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  ------------------
  |  Branch (1103:12): [True: 0, False: 0]
  ------------------
 1104|      0|		    warning("path[%d]=\"%s\": %s", i+1, path, strerror(errno));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
 1105|      0|	    }
 1106|     42|	}
 1107|      0|	else if (mustWork == 1) error("fatal translation error");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (1107:11): [True: 0, False: 0]
  ------------------
 1108|      0|	else SET_STRING_ELT(ans, i, elp);
 1109|     42|    }
 1110|       |#else
 1111|       |    bool OK;
 1112|       |    warning("this platform does not have realpath so the results may not be canonical");
 1113|       |    PROTECT(ans = allocVector(STRSXP, n));
 1114|       |    for (i = 0; i < n; i++) {
 1115|       |	elp = STRING_ELT(paths, i);
 1116|       |	if (elp == NA_STRING) {
 1117|       |	    SET_STRING_ELT(ans, i, NA_STRING);
 1118|       |	    if (mustWork == 1)
 1119|       |		error("path[%d]=NA", i+1);
 1120|       |	    else if (mustWork == NA_LOGICAL)
 1121|       |		warning("path[%d]=NA", i+1);
 1122|       |	    continue;
 1123|       |	}
 1124|       |	path = translateCharFP(elp);
 1125|       |	OK = strlen(path) <= R_PATH_MAX;
 1126|       |	if (OK) {
 1127|       |	    if (path[0] == '/') strncpy(abspath, path, R_PATH_MAX);
 1128|       |	    else {
 1129|       |		OK = getcwd(abspath, R_PATH_MAX) != NULL;
 1130|       |		OK = OK && (strlen(path) + strlen(abspath) + 1 <= R_PATH_MAX);
 1131|       |		if (OK) {strcat(abspath, "/"); strcat(abspath, path);}
 1132|       |	    }
 1133|       |	}
 1134|       |	/* we need to check that this exists */
 1135|       |	if (OK) OK = (access(abspath, 0 /* F_OK */) == 0);
 1136|       |	if (OK) SET_STRING_ELT(ans, i, mkChar(abspath));
 1137|       |	else {
 1138|       |	    SET_STRING_ELT(ans, i, elp);
 1139|       |	    /* and report the problem */
 1140|       |	    if (mustWork == 1)
 1141|       |		error("path[%d]=\"%s\": %s", i+1, path, strerror(errno));
 1142|       |	    else if (mustWork == NA_LOGICAL)
 1143|       |		warning("path[%d]=\"%s\": %s", i+1, path, strerror(errno));
 1144|       |	}
 1145|       |    }
 1146|       |#endif
 1147|     42|    UNPROTECT(1);
  ------------------
  |  |  358|     42|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1148|     42|    return ans;
 1149|     42|}
Rf_markKnown:
 1335|   306k|{
 1336|   306k|    int ienc = 0;
 1337|   306k|    if(ENC_KNOWN(ref)) {
  ------------------
  |  Branch (1337:8): [True: 0, False: 306k]
  ------------------
 1338|      0|	if(known_to_be_latin1) ienc = CE_LATIN1;
  ------------------
  |  Branch (1338:5): [True: 0, False: 0]
  ------------------
 1339|      0|	if(known_to_be_utf8) ienc = CE_UTF8;
  ------------------
  |  Branch (1339:5): [True: 0, False: 0]
  ------------------
 1340|      0|    }
 1341|   306k|    return mkCharCE(s, ienc);
  ------------------
  |  |  999|   306k|#define mkCharCE		Rf_mkCharCE
  ------------------
 1342|   306k|}
Rf_utf8clen:
 1360|     84|{
 1361|       |    /* This allows through 8-bit chars 10xxxxxx, which are invalid */
 1362|     84|    if ((c & 0xc0) != 0xc0) return 1;
  ------------------
  |  Branch (1362:9): [True: 84, False: 0]
  ------------------
 1363|      0|    return 1 + utf8_table4[c & 0x3f];
 1364|     84|}
Rf_strchr:
 1769|    450|{
 1770|    450|    mbstate_t mb_st;
 1771|    450|    size_t used;
 1772|       |
 1773|    450|    if(!mbcslocale || utf8locale) return strchr(s, c);
  ------------------
  |  Branch (1773:8): [True: 450, False: 0]
  |  Branch (1773:23): [True: 0, False: 0]
  ------------------
 1774|      0|    mbs_init(&mb_st);
  ------------------
  |  | 2454|      0|#define mbs_init(x) memset(x, 0, sizeof(mbstate_t))
  ------------------
 1775|      0|    while( (used = Mbrtowc(NULL, s, R_MB_CUR_MAX, &mb_st)) ) {
  ------------------
  |  | 1949|      0|# define Mbrtowc		Rf_mbrtowc
  ------------------
  |  Branch (1775:12): [True: 0, False: 0]
  ------------------
 1776|      0|	if(*s == c) return s;
  ------------------
  |  Branch (1776:5): [True: 0, False: 0]
  ------------------
 1777|      0|	s += used;
 1778|      0|    }
 1779|      0|    return (char *)NULL;
 1780|      0|}
Rf_strrchr:
 1784|     10|{
 1785|     10|    char *plast = NULL;
 1786|     10|    mbstate_t mb_st;
 1787|     10|    size_t used;
 1788|       |
 1789|     10|    if(!mbcslocale || utf8locale) return strrchr(s, c);
  ------------------
  |  Branch (1789:8): [True: 10, False: 0]
  |  Branch (1789:23): [True: 0, False: 0]
  ------------------
 1790|      0|    mbs_init(&mb_st);
  ------------------
  |  | 2454|      0|#define mbs_init(x) memset(x, 0, sizeof(mbstate_t))
  ------------------
 1791|      0|    while( (used = Mbrtowc(NULL, s, R_MB_CUR_MAX, &mb_st)) ) {
  ------------------
  |  | 1949|      0|# define Mbrtowc		Rf_mbrtowc
  ------------------
  |  Branch (1791:12): [True: 0, False: 0]
  ------------------
 1792|      0|	if(*s == c) plast = s;
  ------------------
  |  Branch (1792:5): [True: 0, False: 0]
  ------------------
 1793|      0|	s += used;
 1794|      0|    }
 1795|      0|    return plast;
 1796|     10|}
Rf_strchr_const:
 1799|    108|{
 1800|    108|    mbstate_t mb_st;
 1801|    108|    size_t used;
 1802|       |
 1803|    108|    if(!mbcslocale || utf8locale) return strchr(s, c);
  ------------------
  |  Branch (1803:8): [True: 108, False: 0]
  |  Branch (1803:23): [True: 0, False: 0]
  ------------------
 1804|      0|    mbs_init(&mb_st);
  ------------------
  |  | 2454|      0|#define mbs_init(x) memset(x, 0, sizeof(mbstate_t))
  ------------------
 1805|      0|    while( (used = Mbrtowc(NULL, s, R_MB_CUR_MAX, &mb_st)) ) {
  ------------------
  |  | 1949|      0|# define Mbrtowc		Rf_mbrtowc
  ------------------
  |  Branch (1805:12): [True: 0, False: 0]
  ------------------
 1806|      0|	if(*s == c) return s;
  ------------------
  |  Branch (1806:5): [True: 0, False: 0]
  ------------------
 1807|      0|	s += used;
 1808|      0|    }
 1809|      0|    return (const char *)NULL;
 1810|      0|}
Rf_strrchr_const:
 1814|  1.05k|{
 1815|  1.05k|    const char *plast = NULL;
 1816|  1.05k|    mbstate_t mb_st;
 1817|  1.05k|    size_t used;
 1818|       |
 1819|  1.05k|    if(!mbcslocale || utf8locale) return strrchr(s, c);
  ------------------
  |  Branch (1819:8): [True: 1.05k, False: 0]
  |  Branch (1819:23): [True: 0, False: 0]
  ------------------
 1820|      0|    mbs_init(&mb_st);
  ------------------
  |  | 2454|      0|#define mbs_init(x) memset(x, 0, sizeof(mbstate_t))
  ------------------
 1821|      0|    while( (used = Mbrtowc(NULL, s, R_MB_CUR_MAX, &mb_st)) ) {
  ------------------
  |  | 1949|      0|# define Mbrtowc		Rf_mbrtowc
  ------------------
  |  Branch (1821:12): [True: 0, False: 0]
  ------------------
 1822|      0|	if(*s == c) plast = s;
  ------------------
  |  Branch (1822:5): [True: 0, False: 0]
  ------------------
 1823|      0|	s += used;
 1824|      0|    }
 1825|      0|    return plast;
 1826|  1.05k|}
R_strtod5:
 2173|   509k|{
 2174|   509k|    LDOUBLE ans = 0.0;
  ------------------
  |  | 2577|   509k|# define LDOUBLE long double
  ------------------
 2175|   509k|    int sign = 1;
 2176|   509k|    const char *p = str;
 2177|       |
 2178|       |    /* optional whitespace */
 2179|   509k|    while (isspace(*p)) p++;
  ------------------
  |  Branch (2179:12): [True: 979, False: 509k]
  ------------------
 2180|       |
 2181|   509k|    if (NA && strncmp(p, "NA", 2) == 0) {
  ------------------
  |  Branch (2181:9): [True: 0, False: 509k]
  |  Branch (2181:15): [True: 0, False: 0]
  ------------------
 2182|      0|	ans = NA_REAL;
  ------------------
  |  |   58|      0|#define NA_REAL		R_NaReal
  ------------------
 2183|      0|	p += 2;
 2184|      0|	goto done;
 2185|      0|    }
 2186|       |
 2187|       |   /* optional sign */
 2188|   509k|    switch (*p) {
 2189|  1.78k|    case '-': sign = -1;
  ------------------
  |  Branch (2189:5): [True: 1.78k, False: 507k]
  ------------------
 2190|  2.26k|    case '+': p++;
  ------------------
  |  Branch (2190:5): [True: 475, False: 508k]
  ------------------
 2191|   509k|    default: ;
  ------------------
  |  Branch (2191:5): [True: 507k, False: 2.26k]
  ------------------
 2192|   509k|    }
 2193|       |
 2194|   509k|    if (strncasecmp(p, "NaN", 3) == 0) {
  ------------------
  |  Branch (2194:9): [True: 320, False: 508k]
  ------------------
 2195|    320|	ans = R_NaN;
 2196|    320|	p += 3;
 2197|    320|	goto done;
 2198|       |    /* C99 specifies this: must come first to avoid 'inf' match */
 2199|   508k|    } else if (strncasecmp(p, "infinity", 8) == 0) {
  ------------------
  |  Branch (2199:16): [True: 233, False: 508k]
  ------------------
 2200|    233|	ans = R_PosInf;
 2201|    233|	p += 8;
 2202|    233|	goto done;
 2203|   508k|    } else if (strncasecmp(p, "Inf", 3) == 0) {
  ------------------
  |  Branch (2203:16): [True: 271, False: 508k]
  ------------------
 2204|    271|	ans = R_PosInf;
 2205|    271|	p += 3;
 2206|    271|	goto done;
 2207|    271|    }
 2208|       |
 2209|   508k|    int n, expn = 0;
 2210|   508k|    if(strlen(p) > 2 && p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) { // Hexadecimal "0x....."
  ------------------
  |  Branch (2210:8): [True: 417k, False: 91.3k]
  |  Branch (2210:25): [True: 6.35k, False: 410k]
  |  Branch (2210:41): [True: 1.72k, False: 4.62k]
  |  Branch (2210:56): [True: 1.96k, False: 2.66k]
  ------------------
 2211|       |	/* Prior to 4.5.0 this did not allow forms such as 0x1.234
 2212|       |	   without an exponent.: C99 allow this and implicitly
 2213|       |	   appends "p0"".
 2214|       |
 2215|       |	   Changed following PR#18805
 2216|       |	 */
 2217|  3.69k|	int exph = -1;
 2218|       |
 2219|       |	/* This will overflow to Inf if appropriate */
 2220|  38.8k|	for(p += 2; p; p++) {
  ------------------
  |  Branch (2220:14): [True: 38.8k, False: 0]
  ------------------
 2221|  38.8k|	    if('0' <= *p && *p <= '9') ans = 16*ans + (*p -'0');
  ------------------
  |  Branch (2221:9): [True: 36.7k, False: 2.17k]
  |  Branch (2221:22): [True: 4.56k, False: 32.1k]
  ------------------
 2222|  34.3k|	    else if('a' <= *p && *p <= 'f') ans = 16*ans + (*p -'a' + 10);
  ------------------
  |  Branch (2222:14): [True: 29.8k, False: 4.46k]
  |  Branch (2222:27): [True: 28.6k, False: 1.23k]
  ------------------
 2223|  5.69k|	    else if('A' <= *p && *p <= 'F') ans = 16*ans + (*p -'A' + 10);
  ------------------
  |  Branch (2223:14): [True: 3.50k, False: 2.19k]
  |  Branch (2223:27): [True: 550, False: 2.95k]
  ------------------
 2224|  5.14k|	    else if(*p == dec) {exph = 0; continue;}
  ------------------
  |  Branch (2224:14): [True: 1.45k, False: 3.69k]
  ------------------
 2225|  3.69k|	    else break;
 2226|  33.7k|	    if (exph >= 0) exph += 4;
  ------------------
  |  Branch (2226:10): [True: 31.5k, False: 2.22k]
  ------------------
 2227|  33.7k|	}
 2228|  3.69k|#define strtod_EXACT_CLAUSE						\
 2229|  3.69k|	if(exact && ans > 0x1.fffffffffffffp52) {			\
 2230|  3.69k|	    if(exact == NA_LOGICAL)					\
 2231|  3.69k|		warning(_(						\
 2232|  3.69k|		"accuracy loss in conversion from \"%s\" to numeric"),	\
 2233|  3.69k|			str);						\
 2234|  3.69k|	    else {							\
 2235|  3.69k|		ans = NA_REAL;						\
 2236|  3.69k|		p = str; /* back out */					\
 2237|  3.69k|		goto done;						\
 2238|  3.69k|	    }								\
 2239|  3.69k|	}
 2240|  3.69k|	strtod_EXACT_CLAUSE;
  ------------------
  |  | 2229|  3.69k|	if(exact && ans > 0x1.fffffffffffffp52) {			\
  |  |  ------------------
  |  |  |  Branch (2229:5): [True: 0, False: 3.69k]
  |  |  |  Branch (2229:14): [True: 0, False: 0]
  |  |  ------------------
  |  | 2230|      0|	    if(exact == NA_LOGICAL)					\
  |  |  ------------------
  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  ------------------
  |  |  |  Branch (2230:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2231|      0|		warning(_(						\
  |  |  ------------------
  |  |  |  |   89|      0|#define warning Rf_warning
  |  |  ------------------
  |  |               		warning(_(						\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2232|      0|		"accuracy loss in conversion from \"%s\" to numeric"),	\
  |  | 2233|      0|			str);						\
  |  | 2234|      0|	    else {							\
  |  | 2235|      0|		ans = NA_REAL;						\
  |  |  ------------------
  |  |  |  |   58|      0|#define NA_REAL		R_NaReal
  |  |  ------------------
  |  | 2236|      0|		p = str; /* back out */					\
  |  | 2237|      0|		goto done;						\
  |  | 2238|      0|	    }								\
  |  | 2239|      0|	}
  ------------------
 2241|       |	/* Binary exponent, if any */
 2242|  3.69k|	if (*p == 'p' || *p == 'P') {
  ------------------
  |  Branch (2242:6): [True: 1.18k, False: 2.50k]
  |  Branch (2242:19): [True: 1.69k, False: 810]
  ------------------
 2243|  2.88k|	    int expsign = 1;
 2244|  2.88k|	    switch(*++p) {
 2245|  1.00k|	    case '-': expsign = -1;
  ------------------
  |  Branch (2245:6): [True: 1.00k, False: 1.87k]
  ------------------
 2246|  1.37k|	    case '+': p++;
  ------------------
  |  Branch (2246:6): [True: 364, False: 2.51k]
  ------------------
 2247|  2.88k|	    default: ;
  ------------------
  |  Branch (2247:6): [True: 1.50k, False: 1.37k]
  ------------------
 2248|  2.88k|	    }
 2249|  2.88k|#define MAX_EXPONENT_PREFIX 9999
 2250|       |	    /* exponents beyond ca +1024/-1076 over/underflow
 2251|       |	       Limit exponent from PR#16358.
 2252|       |	     */
 2253|  2.88k|	    int ndig = 0;
 2254|  7.60k|	    for (n = 0; *p >= '0' && *p <= '9'; p++, ndig++)
  ------------------
  |  Branch (2254:18): [True: 5.29k, False: 2.31k]
  |  Branch (2254:31): [True: 4.72k, False: 566]
  ------------------
 2255|  4.72k|		n = (n < MAX_EXPONENT_PREFIX) ? n * 10 + (*p - '0') : n;
  ------------------
  |  | 2249|  4.72k|#define MAX_EXPONENT_PREFIX 9999
  ------------------
  |  Branch (2255:7): [True: 4.25k, False: 470]
  ------------------
 2256|  2.88k|	    if (ndig == 0) {
  ------------------
  |  Branch (2256:10): [True: 1.52k, False: 1.35k]
  ------------------
 2257|  1.52k|		ans = NA_REAL;
  ------------------
  |  |   58|  1.52k|#define NA_REAL		R_NaReal
  ------------------
 2258|  1.52k|		p = str; /* back out */
 2259|  1.52k|		goto done;
 2260|  1.52k|	    }
 2261|  1.35k|	    expn += expsign * n;
 2262|  1.35k|	}
 2263|  2.16k|	if (ans != 0.0) { /* PR#15976:  allow big exponents on 0 */
  ------------------
  |  Branch (2263:6): [True: 1.74k, False: 421]
  ------------------
 2264|  1.74k|	    LDOUBLE fac = 1.0;
  ------------------
  |  | 2577|  1.74k|# define LDOUBLE long double
  ------------------
 2265|  1.74k|	    double p2 = 2.0;
 2266|  1.74k|	    if(exph > 0) {
  ------------------
  |  Branch (2266:9): [True: 1.00k, False: 741]
  ------------------
 2267|  1.00k|		if (expn - exph < -122) {	/* PR#17199:  fac may overflow below if expn - exph is too small.
  ------------------
  |  Branch (2267:7): [True: 689, False: 311]
  ------------------
 2268|       |					       2^-122 is a bit bigger than 1E-37, so should be fine on all systems */
 2269|  3.57k|		    for (n = exph, fac = 1.0; n; n >>= 1, p2 *= p2)
  ------------------
  |  Branch (2269:33): [True: 2.88k, False: 689]
  ------------------
 2270|  2.88k|			if (n & 1) fac *= p2;
  ------------------
  |  Branch (2270:8): [True: 1.18k, False: 1.70k]
  ------------------
 2271|    689|		    ans /= fac;
 2272|    689|		    p2 = 2.0;
 2273|    689|		} else
 2274|    311|		    expn -= exph;
 2275|  1.00k|	    }
 2276|  1.74k|	    if (expn < 0) {
  ------------------
  |  Branch (2276:10): [True: 1.04k, False: 701]
  ------------------
 2277|  9.53k|		for (n = -expn, fac = 1.0; n; n >>= 1, p2 *= p2)
  ------------------
  |  Branch (2277:30): [True: 8.49k, False: 1.04k]
  ------------------
 2278|  8.49k|		    if (n & 1) fac *= p2;
  ------------------
  |  Branch (2278:11): [True: 3.62k, False: 4.86k]
  ------------------
 2279|  1.04k|		ans /= fac;
 2280|  1.04k|	    } else {
 2281|  3.05k|		for (n = expn, fac = 1.0; n; n >>= 1, p2 *= p2)
  ------------------
  |  Branch (2281:29): [True: 2.35k, False: 701]
  ------------------
 2282|  2.35k|		    if (n & 1) fac *= p2;
  ------------------
  |  Branch (2282:11): [True: 1.50k, False: 845]
  ------------------
 2283|    701|		ans *= fac;
 2284|    701|	    }
 2285|  1.74k|	}
 2286|  2.16k|	goto done;
 2287|  3.69k|    } // end {hexadecimal case}
 2288|       |
 2289|   504k|    int ndigits = 0;
 2290|  1.07M|    for ( ; *p >= '0' && *p <= '9'; p++, ndigits++) ans = 10*ans + (*p - '0');
  ------------------
  |  Branch (2290:13): [True: 980k, False: 98.5k]
  |  Branch (2290:26): [True: 573k, False: 406k]
  ------------------
 2291|   504k|    if (*p == dec)
  ------------------
  |  Branch (2291:9): [True: 2.56k, False: 502k]
  ------------------
 2292|  9.94k|	for (p++; *p >= '0' && *p <= '9'; p++, ndigits++, expn--)
  ------------------
  |  Branch (2292:12): [True: 7.66k, False: 2.28k]
  |  Branch (2292:25): [True: 7.38k, False: 277]
  ------------------
 2293|  7.38k|	    ans = 10*ans + (*p - '0');
 2294|   504k|    if (ndigits == 0) {
  ------------------
  |  Branch (2294:9): [True: 7.07k, False: 497k]
  ------------------
 2295|  7.07k|	ans = NA_REAL;
  ------------------
  |  |   58|  7.07k|#define NA_REAL		R_NaReal
  ------------------
 2296|  7.07k|	p = str; /* back out */
 2297|  7.07k|	goto done;
 2298|  7.07k|    }
 2299|   995k|    strtod_EXACT_CLAUSE;
  ------------------
  |  | 2229|   497k|	if(exact && ans > 0x1.fffffffffffffp52) {			\
  |  |  ------------------
  |  |  |  Branch (2229:5): [True: 0, False: 497k]
  |  |  |  Branch (2229:14): [True: 0, False: 0]
  |  |  ------------------
  |  | 2230|      0|	    if(exact == NA_LOGICAL)					\
  |  |  ------------------
  |  |  |  |   55|      0|#define NA_LOGICAL	R_NaInt
  |  |  ------------------
  |  |  |  Branch (2230:9): [True: 0, False: 0]
  |  |  ------------------
  |  | 2231|      0|		warning(_(						\
  |  |  ------------------
  |  |  |  |   89|      0|#define warning Rf_warning
  |  |  ------------------
  |  |               		warning(_(						\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  | 2232|      0|		"accuracy loss in conversion from \"%s\" to numeric"),	\
  |  | 2233|      0|			str);						\
  |  | 2234|      0|	    else {							\
  |  | 2235|      0|		ans = NA_REAL;						\
  |  |  ------------------
  |  |  |  |   58|      0|#define NA_REAL		R_NaReal
  |  |  ------------------
  |  | 2236|      0|		p = str; /* back out */					\
  |  | 2237|      0|		goto done;						\
  |  | 2238|      0|	    }								\
  |  | 2239|      0|	}
  ------------------
 2300|       |
 2301|   995k|    if (*p == 'e' || *p == 'E') {
  ------------------
  |  Branch (2301:9): [True: 400k, False: 97.4k]
  |  Branch (2301:22): [True: 516, False: 96.9k]
  ------------------
 2302|   400k|	int ndigits = 0;
 2303|   400k|	int expsign = 1;
 2304|   400k|	switch(*++p) {
 2305|  2.68k|	case '-': expsign = -1;
  ------------------
  |  Branch (2305:2): [True: 2.68k, False: 398k]
  ------------------
 2306|  2.93k|	case '+': p++;
  ------------------
  |  Branch (2306:2): [True: 254, False: 400k]
  ------------------
 2307|   400k|	default: ;
  ------------------
  |  Branch (2307:2): [True: 397k, False: 2.93k]
  ------------------
 2308|   400k|	}
 2309|       |	/* The test for n is in response to PR#16358; which was
 2310|       |	   parsing 1e999999999999.
 2311|       |	   It's not right if the exponent is very large, but the
 2312|       |	   overflow or underflow below will handle it.
 2313|       |	   1e308 is already Inf, but negative exponents can go down to -323
 2314|       |	   before undeflowing to zero.  And people could do perverse things
 2315|       |	   like 0.00000001e312.
 2316|       |	*/
 2317|       |	// C17 §6.4.4.2 requires a non-empty 'digit sequence'
 2318|  1.21M|	for (n = 0; *p >= '0' && *p <= '9'; p++, ndigits++)
  ------------------
  |  Branch (2318:14): [True: 816k, False: 396k]
  |  Branch (2318:27): [True: 812k, False: 4.34k]
  ------------------
 2319|   812k|	    n = (n < MAX_EXPONENT_PREFIX) ? n * 10 + (*p - '0') : n;
  ------------------
  |  | 2249|   812k|#define MAX_EXPONENT_PREFIX 9999
  ------------------
  |  Branch (2319:10): [True: 806k, False: 5.15k]
  ------------------
 2320|   400k|	if (ndigits == 0) {
  ------------------
  |  Branch (2320:6): [True: 4.94k, False: 395k]
  ------------------
 2321|  4.94k|	    ans = NA_REAL;
  ------------------
  |  |   58|  4.94k|#define NA_REAL		R_NaReal
  ------------------
 2322|  4.94k|	    p = str; /* back out */
 2323|  4.94k|	    goto done;
 2324|  4.94k|	}
 2325|   395k|	expn += expsign * n;
 2326|   395k|    }
 2327|       |
 2328|       |    /* avoid unnecessary underflow for large negative exponents */
 2329|   492k|    if (expn + ndigits < -300) {
  ------------------
  |  Branch (2329:9): [True: 703, False: 492k]
  ------------------
 2330|  1.98k|	for (n = 0; n < ndigits; n++) ans /= 10.0;
  ------------------
  |  Branch (2330:14): [True: 1.28k, False: 703]
  ------------------
 2331|    703|	expn += ndigits;
 2332|    703|    }
 2333|   492k|    LDOUBLE p10 = 10., fac = 1.0;
  ------------------
  |  | 2577|   492k|# define LDOUBLE long double
  ------------------
 2334|   492k|    if (expn < -307) { /* use underflow, not overflow */
  ------------------
  |  Branch (2334:9): [True: 552, False: 492k]
  ------------------
 2335|  6.42k|	for (n = -expn, fac = 1.0; n; n >>= 1, p10 *= p10)
  ------------------
  |  Branch (2335:29): [True: 5.86k, False: 552]
  ------------------
 2336|  5.86k|	    if (n & 1) fac /= p10;
  ------------------
  |  Branch (2336:10): [True: 2.91k, False: 2.95k]
  ------------------
 2337|    552|	ans *= fac;
 2338|   492k|    } else if (expn < 0) { /* positive powers are exact */
  ------------------
  |  Branch (2338:16): [True: 3.45k, False: 488k]
  ------------------
 2339|  15.5k|	for (n = -expn, fac = 1.0; n; n >>= 1, p10 *= p10)
  ------------------
  |  Branch (2339:29): [True: 12.0k, False: 3.45k]
  ------------------
 2340|  12.0k|	    if (n & 1) fac *= p10;
  ------------------
  |  Branch (2340:10): [True: 6.59k, False: 5.47k]
  ------------------
 2341|  3.45k|	ans /= fac;
 2342|   488k|    } else if (ans != 0.0) { /* PR#15976:  allow big exponents on 0, e.g. 0E4933 */
  ------------------
  |  Branch (2342:16): [True: 409k, False: 79.1k]
  ------------------
 2343|  2.42M|	for (n = expn, fac = 1.0; n; n >>= 1, p10 *= p10)
  ------------------
  |  Branch (2343:28): [True: 2.01M, False: 409k]
  ------------------
 2344|  2.01M|	    if (n & 1) fac *= p10;
  ------------------
  |  Branch (2344:10): [True: 1.56M, False: 449k]
  ------------------
 2345|   409k|	ans *= fac;
 2346|   409k|    }
 2347|       |
 2348|       |    /* explicit overflow to infinity */
 2349|   492k|    if (ans > DBL_MAX) {
  ------------------
  |  Branch (2349:9): [True: 2.63k, False: 490k]
  ------------------
 2350|  2.63k|	if (endptr) *endptr = (char *) p;
  ------------------
  |  Branch (2350:6): [True: 2.63k, False: 0]
  ------------------
 2351|  2.63k|	return (sign > 0) ? R_PosInf : R_NegInf;
  ------------------
  |  Branch (2351:9): [True: 2.26k, False: 362]
  ------------------
 2352|  2.63k|    }
 2353|       |
 2354|   506k|done:
 2355|   506k|    if (endptr) *endptr = (char *) p;
  ------------------
  |  Branch (2355:9): [True: 506k, False: 254]
  ------------------
 2356|   506k|    return sign * (double) ans;
 2357|   492k|}
R_strtod:
 2367|   509k|{
 2368|   509k|    return R_strtod5(str, endptr, '.', FALSE, FALSE);
 2369|   509k|}
R_atof:
 2372|    254|{
 2373|       |    return R_strtod5(str, NULL, '.', FALSE, FALSE);
 2374|    254|}
Rf_Scollate:
 2771|  63.4k|{
 2772|  63.4k|    return strcoll(translateChar(a), translateChar(b));
  ------------------
  |  | 1037|  63.4k|#define translateChar		Rf_translateChar
  ------------------
                  return strcoll(translateChar(a), translateChar(b));
  ------------------
  |  | 1037|  63.4k|#define translateChar		Rf_translateChar
  ------------------
 2773|  63.4k|}
Rstrdup:
 3254|    792|{
 3255|    792|    size_t nb = strlen(s) + 1;
 3256|    792|    void *cpy = malloc(nb);
 3257|    792|    if (cpy == NULL) error("allocation error in Rstrdup");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  |  Branch (3257:9): [True: 0, False: 792]
  ------------------
 3258|    792|    memcpy (cpy, s, nb);
 3259|    792|    return (char *) cpy;
 3260|    792|}
do_compareNumericVersion:
 3298|     38|{
 3299|     38|    SEXP ans, x, y;
 3300|     38|    int i, nx, ny, na;
 3301|       |
 3302|     38|    checkArity(op, args);
  ------------------
  |  | 1788|     38|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 3303|       |
 3304|     38|    x = CAR(args); args = CDR(args);
 3305|     38|    y = CAR(args);
 3306|       |
 3307|     38|    if(!isVector(x))
  ------------------
  |  |  974|     38|#define isVector		Rf_isVector
  ------------------
  |  Branch (3307:8): [True: 0, False: 38]
  ------------------
 3308|      0|	error(_("invalid '%s' argument"), "x");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "x");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3309|     38|    if(!isVector(y))
  ------------------
  |  |  974|     38|#define isVector		Rf_isVector
  ------------------
  |  Branch (3309:8): [True: 0, False: 38]
  ------------------
 3310|      0|	error(_("invalid '%s' argument"), "y");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "y");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3311|     38|    nx = LENGTH(x);
 3312|     38|    ny = LENGTH(y);
 3313|     38|    if(nx > 0 && ny > 0)
  ------------------
  |  Branch (3313:8): [True: 38, False: 0]
  |  Branch (3313:18): [True: 38, False: 0]
  ------------------
 3314|     38|	na = nx > ny ? nx : ny;
  ------------------
  |  Branch (3314:7): [True: 0, False: 38]
  ------------------
 3315|      0|    else
 3316|      0|	na = 0;
 3317|     38|    PROTECT(ans = allocVector(INTSXP, na));
  ------------------
  |  |  357|     38|#define PROTECT(s)	Rf_protect(s)
  ------------------
 3318|     76|    for(i = 0; i < na; i++) {
  ------------------
  |  Branch (3318:16): [True: 38, False: 38]
  ------------------
 3319|     38|	INTEGER(ans)[i] =
 3320|     38|	    compareNumericVersion(VECTOR_ELT(x, i % nx),
 3321|     38|				  VECTOR_ELT(y, i % ny));
 3322|     38|    }
 3323|     38|    UNPROTECT(1);
  ------------------
  |  |  358|     38|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 3324|     38|    return ans;
 3325|     38|}
Rasprintf_malloc:
 3328|      6|{
 3329|      6|    va_list ap;
 3330|       |
 3331|      6|    *str = NULL;
 3332|       |
 3333|      6|    va_start(ap, fmt);
 3334|       |    /* could optimize by using non-zero initial size, large
 3335|       |       enough so that most prints with fill */
 3336|       |    /* trio does not accept NULL as str */
 3337|      6|    char dummy[1];
 3338|      6|    int ret = vsnprintf(dummy, 0, fmt, ap);
 3339|      6|    va_end(ap);
 3340|       |
 3341|      6|    if (ret <= 0)
  ------------------
  |  Branch (3341:9): [True: 0, False: 6]
  ------------------
 3342|       |	/* error or empty print */
 3343|      0|	return ret;
 3344|       |
 3345|      6|    size_t needed = ret + 1;
 3346|      6|    char *buf = (char *) malloc(needed);
 3347|      6|    if (!buf) {
  ------------------
  |  Branch (3347:9): [True: 0, False: 6]
  ------------------
 3348|      0|	errno = ENOMEM;
 3349|      0|	return -1;
 3350|      0|    }
 3351|       |
 3352|      6|    va_start(ap, fmt);
 3353|      6|    ret = vsnprintf(buf, needed, fmt, ap);
 3354|      6|    va_end(ap);
 3355|       |
 3356|      6|    if (ret < 0 || (size_t)ret >= needed)
  ------------------
  |  Branch (3356:9): [True: 0, False: 6]
  |  Branch (3356:20): [True: 0, False: 6]
  ------------------
 3357|       |	/* error */
 3358|      0|	free(buf);
 3359|      6|    else
 3360|      6|	*str = buf;
 3361|      6|    return ret;
 3362|      6|}
util.c:findTypeInTypeTable:
  262|     64| {
  263|  1.04k|    for (int i = 0; TypeTable[i].str; i++)
  ------------------
  |  Branch (263:21): [True: 1.03k, False: 16]
  ------------------
  264|  1.03k|	if (TypeTable[i].type == t) return i;
  ------------------
  |  Branch (264:6): [True: 48, False: 984]
  ------------------
  265|       |
  266|     16|    return -1;
  267|     64|}
util.c:compareNumericVersion:
 3263|     38|{
 3264|     38|    int i, nx, ny, nc, *ix, *iy;
 3265|     38|    if(!isInteger(x))
  ------------------
  |  |  949|     38|#define isInteger		Rf_isInteger
  ------------------
  |  Branch (3265:8): [True: 0, False: 38]
  ------------------
 3266|      0|	error(_("invalid '%s' argument"), "x");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "x");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3267|     38|    if(!isInteger(y))
  ------------------
  |  |  949|     38|#define isInteger		Rf_isInteger
  ------------------
  |  Branch (3267:8): [True: 0, False: 38]
  ------------------
 3268|      0|	error(_("invalid '%s' argument"), "y");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "y");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 3269|     38|    nx = LENGTH(x);
 3270|     38|    ny = LENGTH(y);
 3271|     38|    nc =  nx > ny ? ny : nx;
  ------------------
  |  Branch (3271:11): [True: 0, False: 38]
  ------------------
 3272|     38|    if(nc == 0)
  ------------------
  |  Branch (3272:8): [True: 0, False: 38]
  ------------------
 3273|      0|	return NA_INTEGER;
  ------------------
  |  |   56|      0|#define NA_INTEGER	R_NaInt
  ------------------
 3274|     38|    ix = INTEGER(x);
 3275|     38|    iy = INTEGER(y);
 3276|     88|    for(i = 0; i < nc; i++) {
  ------------------
  |  Branch (3276:16): [True: 76, False: 12]
  ------------------
 3277|     76|	if(ix[i] > iy[i])
  ------------------
  |  Branch (3277:5): [True: 26, False: 50]
  ------------------
 3278|     26|	    return 1;
 3279|     50|	if(ix[i] < iy[i])
  ------------------
  |  Branch (3279:5): [True: 0, False: 50]
  ------------------
 3280|      0|	    return -1;
 3281|     50|    }
 3282|     12|    if(nc < nx) {
  ------------------
  |  Branch (3282:8): [True: 0, False: 12]
  ------------------
 3283|      0|	for(i = nc; i < nx; i++) {
  ------------------
  |  Branch (3283:14): [True: 0, False: 0]
  ------------------
 3284|      0|	    if(ix[i] > 0)
  ------------------
  |  Branch (3284:9): [True: 0, False: 0]
  ------------------
 3285|      0|		return 1;
 3286|      0|	}
 3287|     12|    } else if(nc < ny) {
  ------------------
  |  Branch (3287:15): [True: 0, False: 12]
  ------------------
 3288|      0|	for(i = nc; i < ny; i++) {
  ------------------
  |  Branch (3288:14): [True: 0, False: 0]
  ------------------
 3289|      0|	    if(iy[i] > 0)
  ------------------
  |  Branch (3289:9): [True: 0, False: 0]
  ------------------
 3290|      0|		return -1;
 3291|      0|	}
 3292|      0|    }
 3293|     12|    return 0;
 3294|     12|}

do_version:
   49|      2|{
   50|      2|    SEXP value, names;
   51|      2|    char buf[128];
   52|      2|    int i = 0;
   53|       |
   54|      2|    checkArity(op, args);
  ------------------
  |  | 1788|      2|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
   55|      2|#ifndef Win32
   56|      2|    PROTECT(value = allocVector(VECSXP,14));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
   57|      2|    PROTECT(names = allocVector(STRSXP,14));
  ------------------
  |  |  357|      2|#define PROTECT(s)	Rf_protect(s)
  ------------------
   58|       |#else
   59|       |    PROTECT(value = allocVector(VECSXP,15));
   60|       |    PROTECT(names = allocVector(STRSXP,15));
   61|       |#endif
   62|       |
   63|      2|    SET_STRING_ELT(names, i, mkChar("platform"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   64|      2|    SET_VECTOR_ELT(value, i++, mkString(R_PLATFORM));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
                  SET_VECTOR_ELT(value, i++, mkString(R_PLATFORM));
  ------------------
  |  | 1101|      2|#define R_PLATFORM "x86_64-pc-linux-gnu"
  ------------------
   65|      2|    SET_STRING_ELT(names, i, mkChar("arch"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   66|      2|    SET_VECTOR_ELT(value, i++, mkString(R_CPU));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
                  SET_VECTOR_ELT(value, i++, mkString(R_CPU));
  ------------------
  |  | 1088|      2|#define R_CPU "x86_64"
  ------------------
   67|      2|    SET_STRING_ELT(names, i, mkChar("os"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   68|      2|    SET_VECTOR_ELT(value, i++, mkString(R_OS));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
                  SET_VECTOR_ELT(value, i++, mkString(R_OS));
  ------------------
  |  | 1098|      2|#define R_OS "linux-gnu"
  ------------------
   69|       |#ifdef Win32
   70|       |    SET_STRING_ELT(names, i, mkChar("crt"));
   71|       |    SET_VECTOR_ELT(value, i++, mkString(R_CRT));
   72|       |#endif
   73|       |
   74|      2|    snprintf(buf, 128, "%s, %s", R_CPU, R_OS);
  ------------------
  |  | 1088|      2|#define R_CPU "x86_64"
  ------------------
                  snprintf(buf, 128, "%s, %s", R_CPU, R_OS);
  ------------------
  |  | 1098|      2|#define R_OS "linux-gnu"
  ------------------
   75|      2|    SET_STRING_ELT(names, i, mkChar("system"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   76|      2|    SET_VECTOR_ELT(value, i++, mkString(buf));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
   77|       |
   78|      2|    SET_STRING_ELT(names, i, mkChar("status"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   79|      2|    SET_VECTOR_ELT(value, i++, mkString(R_STATUS));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
                  SET_VECTOR_ELT(value, i++, mkString(R_STATUS));
  ------------------
  |  |   14|      2|#define R_STATUS "Under development (unstable)"
  ------------------
   80|      2|    SET_STRING_ELT(names, i, mkChar("major"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   81|      2|    SET_VECTOR_ELT(value, i++, mkString(R_MAJOR));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
                  SET_VECTOR_ELT(value, i++, mkString(R_MAJOR));
  ------------------
  |  |   12|      2|#define R_MAJOR  "4"
  ------------------
   82|      2|    SET_STRING_ELT(names, i, mkChar("minor"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   83|      2|    SET_VECTOR_ELT(value, i++, mkString(R_MINOR));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
                  SET_VECTOR_ELT(value, i++, mkString(R_MINOR));
  ------------------
  |  |   13|      2|#define R_MINOR  "7.0"
  ------------------
   84|      2|    SET_STRING_ELT(names, i, mkChar("year"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   85|      2|    SET_VECTOR_ELT(value, i++, mkString(R_YEAR));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
                  SET_VECTOR_ELT(value, i++, mkString(R_YEAR));
  ------------------
  |  |   15|      2|#define R_YEAR   "2026"
  ------------------
   86|      2|    SET_STRING_ELT(names, i, mkChar("month"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   87|      2|    SET_VECTOR_ELT(value, i++, mkString(R_MONTH));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
                  SET_VECTOR_ELT(value, i++, mkString(R_MONTH));
  ------------------
  |  |   16|      2|#define R_MONTH  "11"
  ------------------
   88|      2|    SET_STRING_ELT(names, i, mkChar("day"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   89|      2|    SET_VECTOR_ELT(value, i++, mkString(R_DAY));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
                  SET_VECTOR_ELT(value, i++, mkString(R_DAY));
  ------------------
  |  |   17|      2|#define R_DAY    "13"
  ------------------
   90|       |
   91|      2|    SET_STRING_ELT(names, i, mkChar("svn rev"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   92|      2|    snprintf(buf, 128, "%d", R_SVN_REVISION);
  ------------------
  |  |   18|      2|#define R_SVN_REVISION 90883
  ------------------
   93|      2|    SET_VECTOR_ELT(value, i++, mkString(buf));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
   94|      2|    SET_STRING_ELT(names, i, mkChar("language"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   95|      2|    SET_VECTOR_ELT(value, i++, mkString("R"));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
   96|       |
   97|      2|    PrintVersionString(buf, 128);
  ------------------
  |  | 1976|      2|# define PrintVersionString    	Rf_PrintVersionString
  ------------------
   98|      2|    SET_STRING_ELT(names, i, mkChar("version.string"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
   99|      2|    SET_VECTOR_ELT(value, i++, mkString(buf));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
  100|      2|    SET_STRING_ELT(names, i, mkChar("nickname"));
  ------------------
  |  |  998|      2|#define mkChar			Rf_mkChar
  ------------------
  101|      2|    SET_VECTOR_ELT(value, i++, mkString(R_NICK));
  ------------------
  |  | 1003|      2|#define mkString		Rf_mkString
  ------------------
                  SET_VECTOR_ELT(value, i++, mkString(R_NICK));
  ------------------
  |  |   10|      2|#define R_NICK "Unsuffered Consequences"
  ------------------
  102|       |
  103|      2|    setAttrib(value, R_NamesSymbol, names);
  ------------------
  |  | 1027|      2|#define setAttrib		Rf_setAttrib
  ------------------
  104|      2|    UNPROTECT(2);
  ------------------
  |  |  358|      2|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  105|      2|    return value;
  106|      2|}
Rf_PrintVersionString:
  121|      2|{
  122|       |    
  123|      2|#ifndef Win32
  124|      2|# define _R_PV_EXTRA_ ""
  125|       |#else
  126|       |# define _R_PV_EXTRA_ " " R_CRT
  127|       |#endif
  128|      2|    if(R_SVN_REVISION <= 0) {// 'svn info' failed in ../../Makefile.in
  ------------------
  |  |   18|      2|#define R_SVN_REVISION 90883
  ------------------
  |  Branch (128:8): [Folded, False: 2]
  ------------------
  129|      0|	snprintf(s, len, "R version %s.%s %s (%s-%s-%s%s)",
  130|      0|		R_MAJOR, R_MINOR, R_STATUS, R_YEAR, R_MONTH, R_DAY,
  ------------------
  |  |   12|      0|#define R_MAJOR  "4"
  ------------------
              		R_MAJOR, R_MINOR, R_STATUS, R_YEAR, R_MONTH, R_DAY,
  ------------------
  |  |   13|      0|#define R_MINOR  "7.0"
  ------------------
              		R_MAJOR, R_MINOR, R_STATUS, R_YEAR, R_MONTH, R_DAY,
  ------------------
  |  |   14|      0|#define R_STATUS "Under development (unstable)"
  ------------------
              		R_MAJOR, R_MINOR, R_STATUS, R_YEAR, R_MONTH, R_DAY,
  ------------------
  |  |   15|      0|#define R_YEAR   "2026"
  ------------------
              		R_MAJOR, R_MINOR, R_STATUS, R_YEAR, R_MONTH, R_DAY,
  ------------------
  |  |   16|      0|#define R_MONTH  "11"
  ------------------
              		R_MAJOR, R_MINOR, R_STATUS, R_YEAR, R_MONTH, R_DAY,
  ------------------
  |  |   17|      0|#define R_DAY    "13"
  ------------------
  131|      0|	        _R_PV_EXTRA_);
  ------------------
  |  |  124|      0|# define _R_PV_EXTRA_ ""
  ------------------
  132|      2|    } else if(strlen(R_STATUS) == 0) {
  ------------------
  |  |   14|      2|#define R_STATUS "Under development (unstable)"
  ------------------
  |  Branch (132:15): [Folded, False: 2]
  ------------------
  133|      0|	snprintf(s, len, "R version %s.%s (%s-%s-%s%s)",
  134|      0|		R_MAJOR, R_MINOR, R_YEAR, R_MONTH, R_DAY, _R_PV_EXTRA_);
  ------------------
  |  |   12|      0|#define R_MAJOR  "4"
  ------------------
              		R_MAJOR, R_MINOR, R_YEAR, R_MONTH, R_DAY, _R_PV_EXTRA_);
  ------------------
  |  |   13|      0|#define R_MINOR  "7.0"
  ------------------
              		R_MAJOR, R_MINOR, R_YEAR, R_MONTH, R_DAY, _R_PV_EXTRA_);
  ------------------
  |  |   15|      0|#define R_YEAR   "2026"
  ------------------
              		R_MAJOR, R_MINOR, R_YEAR, R_MONTH, R_DAY, _R_PV_EXTRA_);
  ------------------
  |  |   16|      0|#define R_MONTH  "11"
  ------------------
              		R_MAJOR, R_MINOR, R_YEAR, R_MONTH, R_DAY, _R_PV_EXTRA_);
  ------------------
  |  |   17|      0|#define R_DAY    "13"
  ------------------
              		R_MAJOR, R_MINOR, R_YEAR, R_MONTH, R_DAY, _R_PV_EXTRA_);
  ------------------
  |  |  124|      0|# define _R_PV_EXTRA_ ""
  ------------------
  135|      2|    } else if(strcmp(R_STATUS, "Under development (unstable)") == 0) {
  ------------------
  |  |   14|      2|#define R_STATUS "Under development (unstable)"
  ------------------
  |  Branch (135:15): [True: 2, Folded]
  ------------------
  136|      2|	snprintf(s, len, "R %s (%s-%s-%s r%d%s)",
  137|      2|		R_STATUS, R_YEAR, R_MONTH, R_DAY, R_SVN_REVISION,
  ------------------
  |  |   14|      2|#define R_STATUS "Under development (unstable)"
  ------------------
              		R_STATUS, R_YEAR, R_MONTH, R_DAY, R_SVN_REVISION,
  ------------------
  |  |   15|      2|#define R_YEAR   "2026"
  ------------------
              		R_STATUS, R_YEAR, R_MONTH, R_DAY, R_SVN_REVISION,
  ------------------
  |  |   16|      2|#define R_MONTH  "11"
  ------------------
              		R_STATUS, R_YEAR, R_MONTH, R_DAY, R_SVN_REVISION,
  ------------------
  |  |   17|      2|#define R_DAY    "13"
  ------------------
              		R_STATUS, R_YEAR, R_MONTH, R_DAY, R_SVN_REVISION,
  ------------------
  |  |   18|      2|#define R_SVN_REVISION 90883
  ------------------
  138|      2|	        _R_PV_EXTRA_);
  ------------------
  |  |  124|      2|# define _R_PV_EXTRA_ ""
  ------------------
  139|      2|    } else {
  140|      0|	snprintf(s, len, "R version %s.%s %s (%s-%s-%s r%d%s)",
  141|      0|		R_MAJOR, R_MINOR, R_STATUS, R_YEAR, R_MONTH, R_DAY,
  ------------------
  |  |   12|      0|#define R_MAJOR  "4"
  ------------------
              		R_MAJOR, R_MINOR, R_STATUS, R_YEAR, R_MONTH, R_DAY,
  ------------------
  |  |   13|      0|#define R_MINOR  "7.0"
  ------------------
              		R_MAJOR, R_MINOR, R_STATUS, R_YEAR, R_MONTH, R_DAY,
  ------------------
  |  |   14|      0|#define R_STATUS "Under development (unstable)"
  ------------------
              		R_MAJOR, R_MINOR, R_STATUS, R_YEAR, R_MONTH, R_DAY,
  ------------------
  |  |   15|      0|#define R_YEAR   "2026"
  ------------------
              		R_MAJOR, R_MINOR, R_STATUS, R_YEAR, R_MONTH, R_DAY,
  ------------------
  |  |   16|      0|#define R_MONTH  "11"
  ------------------
              		R_MAJOR, R_MINOR, R_STATUS, R_YEAR, R_MONTH, R_DAY,
  ------------------
  |  |   17|      0|#define R_DAY    "13"
  ------------------
  142|      0|		R_SVN_REVISION, _R_PV_EXTRA_);
  ------------------
  |  |   18|      0|#define R_SVN_REVISION 90883
  ------------------
              		R_SVN_REVISION, _R_PV_EXTRA_);
  ------------------
  |  |  124|      0|# define _R_PV_EXTRA_ ""
  ------------------
  143|      0|    }
  144|      2|#undef _R_PV_EXTRA_
  145|      2|}
do_internalsID:
  171|     10|{
  172|     10|    return mkString(R_INTERNALS_UUID);
  ------------------
  |  | 1003|     10|#define mkString		Rf_mkString
  ------------------
                  return mkString(R_INTERNALS_UUID);
  ------------------
  |  |  116|     10|#define R_INTERNALS_UUID "2fdf6c18-697a-4ba7-b8ef-11c0d92f1327"
  ------------------
  173|     10|}

Rf_InitFunctionHashing:
   58|      2|{
   59|      2|    R_osDynSymbol->loadLibrary = loadLibrary;
   60|      2|    R_osDynSymbol->dlsym = R_local_dlsym;
   61|      2|    R_osDynSymbol->closeLibrary = closeLibrary;
   62|      2|    R_osDynSymbol->getError = getSystemError;
   63|       |
   64|      2|    R_osDynSymbol->deleteCachedSymbols = Rf_deleteCachedSymbols;
   65|      2|    R_osDynSymbol->lookupCachedSymbol = Rf_lookupCachedSymbol;
   66|       |
   67|      2|    R_osDynSymbol->getFullDLLPath = getFullDLLPath;
   68|      2|}
dynload.c:loadLibrary:
   78|     10|{
   79|     10|    void *handle;
   80|     10|    int openFlag = 0;
   81|       |
   82|     10|    openFlag = computeDLOpenFlag(asLocal, now);
   83|     10|    handle = (void *) dlopen(path,openFlag);
   84|       |
   85|     10|    return(handle);
   86|     10|}
dynload.c:computeDLOpenFlag:
  107|     10|{
  108|       |#if !defined(RTLD_LOCAL) || !defined(RTLD_GLOBAL) || !defined(RTLD_NOW) || !defined(RTLD_LAZY)
  109|       |    static char *warningMessages[] = {
  110|       |	N_("Explicit local dynamic loading not supported on this platform. Using default."),
  111|       |	N_("Explicit global dynamic loading not supported on this platform. Using default."),
  112|       |	N_("Explicit non-lazy dynamic loading not supported on this platform. Using default."),
  113|       |	N_("Explicit lazy dynamic loading not supported on this platform. Using default.")
  114|       |    };
  115|       |    /* Define a local macro for issuing the warnings.
  116|       |       This allows us to redefine it easily so that it only emits the
  117|       |       warning once as in
  118|       |       DL_WARN(i) if(warningMessages[i]) {\
  119|       |       warning(warningMessages[i]); \
  120|       |       warningMessages[i] = NULL; \
  121|       |       }
  122|       |       or to control the emission via the options currently in effect at
  123|       |       call time.
  124|       |    */
  125|       |# define DL_WARN(i) \
  126|       |    if(asInteger(GetOption1(install("warn"))) == 1 || \
  127|       |       asInteger(GetOption1(install("verbose"))) > 0) \
  128|       |	warning(_(warningMessages[i]))
  129|       |#endif
  130|       |
  131|     10|    int openFlag = 0;		/* Default value so no-ops for undefined
  132|       |				   flags should do nothing in the
  133|       |				   resulting dlopen(). */
  134|       |
  135|     10|    if(asLocal != 0) {
  ------------------
  |  Branch (135:8): [True: 10, False: 0]
  ------------------
  136|       |#ifndef RTLD_LOCAL
  137|       |	DL_WARN(0);
  138|       |#else
  139|     10|	openFlag = RTLD_LOCAL;
  140|     10|#endif
  141|     10|    } else {
  142|       |#ifndef RTLD_GLOBAL
  143|       |	DL_WARN(1);
  144|       |#else
  145|      0|	openFlag = RTLD_GLOBAL;
  146|      0|#endif
  147|      0|    }
  148|       |
  149|     10|    if(now != 0) {
  ------------------
  |  Branch (149:8): [True: 10, False: 0]
  ------------------
  150|       |#ifndef RTLD_NOW
  151|       |	DL_WARN(2);
  152|       |#else
  153|     10|	openFlag |= RTLD_NOW;
  154|     10|#endif
  155|     10|    } else {
  156|       |#ifndef RTLD_LAZY
  157|       |	DL_WARN(3);
  158|       |#else
  159|      0|	openFlag |= RTLD_LAZY;
  160|      0|#endif
  161|      0|    }
  162|       |
  163|     10|    return(openFlag);
  164|     10|}
dynload.c:R_local_dlsym:
  178|     10|{
  179|     10|    fn_ptr tmp;
  180|     10|    tmp.p = dlsym(info->handle, name);
  181|     10|    return tmp.fn;
  182|     10|}
dynload.c:getFullDLLPath:
  200|     10|{
  201|     10|    size_t needed = 0;
  202|       |
  203|     10|    if(path[0] == '~') {
  ------------------
  |  Branch (203:8): [True: 0, False: 10]
  ------------------
  204|      0|	const char *expanded = R_ExpandFileName(path);
  205|      0|	needed = strlen(expanded);
  206|      0|	if (bufsize >= needed + 1)
  ------------------
  |  Branch (206:6): [True: 0, False: 0]
  ------------------
  207|      0|	    strcpy(buf, expanded);
  208|     10|    } else if(path[0] != '/') {
  ------------------
  |  Branch (208:15): [True: 0, False: 10]
  ------------------
  209|      0|#ifdef HAVE_GETCWD
  210|      0|	if(!getcwd(buf, bufsize))
  ------------------
  |  Branch (210:5): [True: 0, False: 0]
  ------------------
  211|      0|#endif
  212|       |	    /* NOTE: also when bufsize is small */
  213|      0|	    errorcall(call, _("cannot get working directory!"));
  ------------------
  |  |  912|      0|#define errorcall		Rf_errorcall
  ------------------
              	    errorcall(call, _("cannot get working directory!"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  214|      0|	needed = strlen(buf) + 1 + strlen(path);
  215|      0|	if (bufsize >= needed + 1) {
  ------------------
  |  Branch (215:6): [True: 0, False: 0]
  ------------------
  216|      0|	    strcat(buf, "/");
  217|      0|	    strcat(buf, path);
  218|      0|	}
  219|      0|    }
  220|     10|    else {
  221|     10|	needed = strlen(path);
  222|     10|	if (bufsize >= needed + 1)
  ------------------
  |  Branch (222:6): [True: 10, False: 0]
  ------------------
  223|     10|	    strcpy(buf, path);
  224|     10|    }
  225|     10|    return needed;
  226|     10|}

R_ExpandFileName_readline:
  506|    454|{
  507|    454|    char *s2 = tilde_expand_word(s);
  508|    454|    size_t len = strlen(s2);
  509|       |
  510|    454|    strncpy(buff, s2, R_PATH_MAX);
  ------------------
  |  | 1150|    454|# define R_PATH_MAX PATH_MAX
  ------------------
  511|    454|    if(len >= R_PATH_MAX) {
  ------------------
  |  | 1150|    454|# define R_PATH_MAX PATH_MAX
  ------------------
  |  Branch (511:8): [True: 0, False: 454]
  ------------------
  512|      0|	buff[R_PATH_MAX-1] = '\0';
  ------------------
  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  ------------------
  513|      0|	warning(_("expanded path length %lld would be too long for\n%s\n"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("expanded path length %lld would be too long for\n%s\n"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  514|      0|	        (long long)len, s);
  515|      0|    }
  516|    454|    free(s2);
  517|    454|    return buff;
  518|    454|}
set_rl_word_breaks:
  771|      2|{
  772|      2|    static char p1[201], p2[203];
  773|      2|    strncpy(p1, str, 200); p1[200]= '\0';
  774|      2|    strncpy(p2, p1, 200); p2[200] = '\0';
  775|      2|    strcat(p2, "[]");
  776|      2|    rl_basic_word_break_characters = p2;
  777|      2|    rl_completer_word_break_characters = p1;
  778|      2|}
Rstd_ResetConsole:
 1191|  1.90k|{
 1192|  1.90k|}
Rstd_FlushConsole:
 1198|  1.90k|{
 1199|       |    /* fflush(stdin);  really work on Solaris on pipes */
 1200|  1.90k|}
Rstd_ClearerrConsole:
 1205|  1.90k|{
 1206|       |    clearerr(stdin);
 1207|  1.90k|}
sys-std.c:nop:
  325|  1.24M|static void nop(void){}

R_OpenInitFile:
   69|      2|{
   70|      2|    char buf[R_PATH_MAX], *home, *p = getenv("R_PROFILE_USER");
   71|      2|    FILE *fp;
   72|       |
   73|      2|    fp = NULL;
   74|      2|    if (LoadInitFile) {
  ------------------
  |  Branch (74:9): [True: 0, False: 2]
  ------------------
   75|      0|	if(p) {
  ------------------
  |  Branch (75:5): [True: 0, False: 0]
  ------------------
   76|      0|	    if(!*p) return NULL;  /* set to "" */
  ------------------
  |  Branch (76:9): [True: 0, False: 0]
  ------------------
   77|      0|	    return R_fopen(R_ExpandFileName(p), "r");
   78|      0|	}
   79|      0|	if((fp = R_fopen(".Rprofile", "r")))
  ------------------
  |  Branch (79:5): [True: 0, False: 0]
  ------------------
   80|      0|	    return fp;
   81|      0|	if((home = getenv("HOME")) == NULL)
  ------------------
  |  Branch (81:5): [True: 0, False: 0]
  ------------------
   82|      0|	    return NULL;
   83|      0|	snprintf(buf, R_PATH_MAX, "%s/.Rprofile", home);
  ------------------
  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  ------------------
   84|      0|	if((fp = R_fopen(buf, "r")))
  ------------------
  |  Branch (84:5): [True: 0, False: 0]
  ------------------
   85|      0|	    return fp;
   86|      0|    }
   87|      2|    return fp;
   88|      2|}
R_ExpandFileName:
  187|    454|{
  188|    454|#if defined(HAVE_LIBREADLINE) && defined(HAVE_TILDE_EXPAND_WORD)
  189|    454|    if(UsingReadline) {
  ------------------
  |  Branch (189:8): [True: 454, False: 0]
  ------------------
  190|    454|	const char * c = R_ExpandFileName_readline(s, newFileName);
  191|       |	/* we can return the result only if tilde_expand is not broken */
  192|    454|	if (!c || c[0]!='~' || (c[1]!='\0' && c[1]!='/'))
  ------------------
  |  Branch (192:6): [True: 0, False: 454]
  |  Branch (192:12): [True: 454, False: 0]
  |  Branch (192:26): [True: 0, False: 0]
  |  Branch (192:40): [True: 0, False: 0]
  ------------------
  193|    454|	    return c;
  194|    454|    }
  195|      0|#endif
  196|      0|    return R_ExpandFileName_unix(s, newFileName);
  197|    454|}
R_setStartTime:
  217|      2|{
  218|      2|#ifdef HAVE_SYSCONF
  219|      2|    clk_tck = (double) sysconf(_SC_CLK_TCK);
  220|       |#else
  221|       |# ifndef CLK_TCK
  222|       |/* this is in ticks/second, generally 60 on BSD style Unix, 100? on SysV
  223|       | */
  224|       |#  ifdef HZ
  225|       |#   define CLK_TCK HZ
  226|       |#  else
  227|       |#   define CLK_TCK 60
  228|       |#  endif
  229|       |# endif /* not CLK_TCK */
  230|       |    clk_tck = (double) CLK_TCK;
  231|       |#endif
  232|       |    /* printf("CLK_TCK = %d\n", CLK_TCK); */
  233|      2|    StartTime = currentTime();
  ------------------
  |  | 1877|      2|# define currentTime		Rf_currentTime
  ------------------
  234|      2|}
R_getProcTime:
  243|    104|{
  244|       |    /* docs say this is rounded to the nearest ms */
  245|    104|    double et = currentTime() - StartTime;
  ------------------
  |  | 1877|    104|# define currentTime		Rf_currentTime
  ------------------
  246|    104|    data[2] = 1e-3 * rint(1000*et);
  247|    104|#ifdef HAVE_GETRUSAGE
  248|       |    /* all known current OSes */
  249|    104|    struct rusage self, children;
  250|    104|    getrusage(RUSAGE_SELF, &self);
  251|    104|    getrusage(RUSAGE_CHILDREN, &children);
  252|    104|    data[0] = (double)     self.ru_utime.tv_sec + 1e-3 * (double)(    self.ru_utime.tv_usec/1000);
  253|    104|    data[1] = (double)     self.ru_stime.tv_sec + 1e-3 * (double)(    self.ru_stime.tv_usec/1000);
  254|    104|    data[3] = (double) children.ru_utime.tv_sec + 1e-3 * (double)(children.ru_utime.tv_usec/1000);
  255|    104|    data[4] = (double) children.ru_stime.tv_sec + 1e-3 * (double)(children.ru_stime.tv_usec/1000);
  256|       |#else
  257|       |    /* Not known to be currently used */
  258|       |    struct tms timeinfo;
  259|       |    times(&timeinfo);
  260|       |    data[0] = fround(timeinfo.tms_utime / clk_tck, 3);
  261|       |    data[1] = fround(timeinfo.tms_stime / clk_tck, 3);
  262|       |    data[3] = fround(timeinfo.tms_cutime / clk_tck, 3);
  263|       |    data[4] = fround(timeinfo.tms_cstime / clk_tck, 3);
  264|       |#endif
  265|    104|}
do_system:
  895|      4|{
  896|      4|    SEXP tlist = R_NilValue;
  897|      4|    int intern = 0;
  898|      4|    int timeout = 0;
  899|      4|    int consignals = 0;
  900|       |
  901|      4|    checkArity(op, args);
  ------------------
  |  | 1788|      4|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
  902|      4|    if (!isValidStringF(CAR(args)))
  ------------------
  |  |  973|      4|#define isValidStringF		Rf_isValidStringF
  ------------------
  |  Branch (902:9): [True: 0, False: 4]
  ------------------
  903|      0|	error(_("non-empty character argument expected"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("non-empty character argument expected"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  904|      4|    intern = asLogical(CADR(args));
  ------------------
  |  |  886|      4|#define asLogical		Rf_asLogical
  ------------------
  905|      4|    if (intern == NA_INTEGER)
  ------------------
  |  |   56|      4|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (905:9): [True: 0, False: 4]
  ------------------
  906|      0|	error(_("'intern' must be logical and not NA"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'intern' must be logical and not NA"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  907|      4|    timeout = asInteger(CADDR(args));
  ------------------
  |  |  885|      4|#define asInteger		Rf_asInteger
  ------------------
  908|      4|    if (timeout == NA_INTEGER || timeout < 0)
  ------------------
  |  |   56|      8|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (908:9): [True: 0, False: 4]
  |  Branch (908:34): [True: 0, False: 4]
  ------------------
  909|      0|	error(_("invalid '%s' argument"), "timeout");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("invalid '%s' argument"), "timeout");
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  910|      4|    consignals = asLogical(CADDDR(args));
  ------------------
  |  |  886|      4|#define asLogical		Rf_asLogical
  ------------------
  911|      4|    if (consignals == NA_INTEGER)
  ------------------
  |  |   56|      4|#define NA_INTEGER	R_NaInt
  ------------------
  |  Branch (911:9): [True: 0, False: 4]
  ------------------
  912|      0|	error(_("'receive.console.signals' must be logical and not NA"));
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
              	error(_("'receive.console.signals' must be logical and not NA"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  913|      4|    const char *cmd = translateCharFP(STRING_ELT(CAR(args), 0));
  ------------------
  |  | 1998|      4|# define translateCharFP	Rf_translateCharFP
  ------------------
  914|       |
  915|      4|    int last_is_amp = 0;
  916|       |    /* command ending with & is not supported by timeout */
  917|      4|    const void *vmax = vmaxget();
  918|      4|    const char *c = trCharUTF8(STRING_ELT(CAR(args), 0));
  ------------------
  |  | 2000|      4|# define trCharUTF8      	Rf_trCharUTF8
  ------------------
  919|      4|    int len = 0;
  920|     88|    for(;*c; c += len) {
  ------------------
  |  Branch (920:10): [True: 84, False: 4]
  ------------------
  921|     84|	len = utf8clen(*c);
  ------------------
  |  | 2008|     84|# define utf8clen		Rf_utf8clen
  ------------------
  922|     84|	if (len == 1) {
  ------------------
  |  Branch (922:6): [True: 84, False: 0]
  ------------------
  923|     84|	    if (*c == '&')
  ------------------
  |  Branch (923:10): [True: 0, False: 84]
  ------------------
  924|      0|		last_is_amp = 1;
  925|     84|	    else if (*c != ' ' && *c != '\t' && *c != '\r' && *c != '\n')
  ------------------
  |  Branch (925:15): [True: 78, False: 6]
  |  Branch (925:28): [True: 78, False: 0]
  |  Branch (925:42): [True: 78, False: 0]
  |  Branch (925:56): [True: 78, False: 0]
  ------------------
  926|     78|		last_is_amp = 0;
  927|     84|	} else
  928|      0|	    last_is_amp = 0;
  929|     84|    }
  930|      4|    vmaxset(vmax);
  931|      4|    if (last_is_amp && timeout > 0)
  ------------------
  |  Branch (931:9): [True: 0, False: 4]
  |  Branch (931:24): [True: 0, False: 0]
  ------------------
  932|      0|	error("Timeout with background running processes is not supported.");
  ------------------
  |  |   88|      0|#define error Rf_error
  ------------------
  933|       |
  934|      4|    if (intern) { /* intern = TRUE */
  ------------------
  |  Branch (934:9): [True: 4, False: 0]
  ------------------
  935|      4|	FILE *fp;
  936|      4|	char *x = "r",
  937|      4|#ifdef HAVE_GETLINE
  938|      4|	    *buf = NULL;
  939|      4|	size_t buf_len = 0;
  940|       |#else
  941|       |	    buf[INTERN_BUFSIZE + MB_LEN_MAX],
  942|       |	    buf2[MB_LEN_MAX + 1]; /* overflow bytes from MBCS truncation */
  943|       |#endif
  944|      4|	int i, j, res;
  945|      4|	SEXP tchar, rval;
  946|       |
  947|      4|	PROTECT(tlist);
  ------------------
  |  |  357|      4|#define PROTECT(s)	Rf_protect(s)
  ------------------
  948|      4|	errno = 0; /* precaution */
  949|      4|	if (timeout == 0)
  ------------------
  |  Branch (949:6): [True: 4, False: 0]
  ------------------
  950|      4|	    fp = R_popen(cmd, x);
  951|      0|	else
  952|      0|	    fp = R_popen_timeout(cmd, x, timeout);
  953|      4|	if(!fp)
  ------------------
  |  Branch (953:5): [True: 0, False: 4]
  ------------------
  954|      0|	    cmdError(cmd, _("cannot popen '%s', probable reason '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  955|      0|		     cmd, strerror(errno));
  956|      4|#ifdef HAVE_GETLINE
  957|      4|        size_t read;
  958|      8|        for(i = 0; (read = getline(&buf, &buf_len, fp)) != (size_t)-1; i++) {
  ------------------
  |  Branch (958:20): [True: 4, False: 4]
  ------------------
  959|      4|	    if (buf[read - 1] == '\n')
  ------------------
  |  Branch (959:10): [True: 4, False: 0]
  ------------------
  960|       |#else
  961|       |	size_t read = 0;
  962|       |	size_t truncb = 0; /* number of overflow bytes from MBCS truncation */
  963|       |	buf[0] = '\0';
  964|       |	for (i = 0; fgets(buf + truncb, INTERN_BUFSIZE, fp) || truncb; i++) {
  965|       |	    buf2[0] = '\0';
  966|       |	    read = strlen(buf);
  967|       |	    if (read >= INTERN_BUFSIZE - 1 + truncb) {
  968|       |		warning(_("line %d may be truncated in call to system(, intern = TRUE)"), i + 1);
  969|       |		/* save trailing bytes in buf2 in case they are from incomplete
  970|       |		   multi-byte character, and hence will be removed from buf by
  971|       |		   mbcsTruncateToValid */
  972|       |		memcpy(buf2, buf + read - MB_LEN_MAX, MB_LEN_MAX);
  973|       |		buf2[MB_LEN_MAX] = '\0';
  974|       |		mbcsTruncateToValid(buf);
  975|       |		truncb = read - strlen(buf);
  976|       |	    }
  977|       |	    else truncb = 0;
  978|       |
  979|       |	    if (read > 0 && buf[read-1] == '\n')
  980|       |#endif
  981|      4|		buf[read - 1] = '\0'; /* chop final CR */
  982|      4|	    tchar = mkChar(buf);
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
  983|      4|	    UNPROTECT(1);
  ------------------
  |  |  358|      4|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
  984|      4|	    PROTECT(tlist = CONS(tchar, tlist));
  ------------------
  |  |  357|      4|#define PROTECT(s)	Rf_protect(s)
  ------------------
  985|       |#ifndef HAVE_GETLINE
  986|       |	    if (truncb > 0 && truncb <= MB_LEN_MAX) 
  987|       |		/* recover overflow bytes and prepend them for next line */
  988|       |		strcpy(buf, buf2 + (MB_LEN_MAX - truncb));
  989|       |#endif
  990|      4|	}
  991|      4|#ifdef HAVE_GETLINE
  992|      4|        if (buf != NULL)
  ------------------
  |  Branch (992:13): [True: 4, False: 0]
  ------------------
  993|      4|          free(buf);
  994|      4|#endif
  995|      4|	if (timeout == 0)
  ------------------
  |  Branch (995:6): [True: 4, False: 0]
  ------------------
  996|      4|	    res = pclose(fp);
  997|      0|	else 
  998|      0|	    res = R_pclose_timeout(fp);
  999|       |
 1000|       |	/* On Solaris, pclose sometimes returns -1 and sets errno to ESPIPE
 1001|       |	   (Illegal seek). In that case, do_system reports 0 exit status and
 1002|       |	   displays a warning via warn_status. ESPIPE is not mentioned by
 1003|       |	   POSIX as possible outcome of pclose. */
 1004|       |
 1005|      4|#ifdef HAVE_SYS_WAIT_H
 1006|      4|	if (WIFEXITED(res)) res = WEXITSTATUS(res);
  ------------------
  |  Branch (1006:6): [True: 4, False: 0]
  ------------------
 1007|      0|	else res = 0;
 1008|       |#else
 1009|       |	/* assume that this is shifted if a multiple of 256 */
 1010|       |	if ((res % 256) == 0) res = res/256;
 1011|       |#endif
 1012|      4|	if ((res & 0xff)  == 127) {/* 127, aka -1 */
  ------------------
  |  Branch (1012:6): [True: 0, False: 4]
  ------------------
 1013|      0|	    if (errno)
  ------------------
  |  Branch (1013:10): [True: 0, False: 0]
  ------------------
 1014|      0|		cmdError(cmd, _("error in running command: '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1015|      0|			 strerror(errno));
 1016|      0|	    else
 1017|      0|		cmdError(cmd, _("error in running command"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1018|      0|	}
 1019|       |
 1020|      4|	if (timeout && tost.timedout) {
  ------------------
  |  Branch (1020:6): [True: 0, False: 4]
  |  Branch (1020:17): [True: 0, False: 0]
  ------------------
 1021|      0|	    res = 124;
 1022|      0|	    warning(_("command '%s' timed out after %ds"), cmd, timeout);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("command '%s' timed out after %ds"), cmd, timeout);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1023|      0|	} else
 1024|      4|	    warn_status(cmd, res);
 1025|       |
 1026|      4|	rval = PROTECT(allocVector(STRSXP, i));
  ------------------
  |  |  357|      4|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1027|      8|	for (j = (i - 1); j >= 0; j--) {
  ------------------
  |  Branch (1027:20): [True: 4, False: 4]
  ------------------
 1028|      4|	    SET_STRING_ELT(rval, j, CAR(tlist));
 1029|      4|	    tlist = CDR(tlist);
 1030|      4|	}
 1031|      4|	if(res) {
  ------------------
  |  Branch (1031:5): [True: 0, False: 4]
  ------------------
 1032|      0|	    SEXP lsym = install("status");
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 1033|      0|	    setAttrib(rval, lsym, ScalarInteger(res));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              	    setAttrib(rval, lsym, ScalarInteger(res));
  ------------------
  |  | 1022|      0|#define ScalarInteger		Rf_ScalarInteger
  ------------------
 1034|      0|	    if(errno) {
  ------------------
  |  Branch (1034:9): [True: 0, False: 0]
  ------------------
 1035|      0|		lsym = install("errmsg");
  ------------------
  |  |  934|      0|#define install			Rf_install
  ------------------
 1036|      0|		setAttrib(rval, lsym, mkString(strerror(errno)));
  ------------------
  |  | 1027|      0|#define setAttrib		Rf_setAttrib
  ------------------
              		setAttrib(rval, lsym, mkString(strerror(errno)));
  ------------------
  |  | 1003|      0|#define mkString		Rf_mkString
  ------------------
 1037|      0|	    }
 1038|      0|	}
 1039|      4|	UNPROTECT(2);
  ------------------
  |  |  358|      4|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1040|      4|	return rval;
 1041|      4|    }
 1042|      0|    else { /* intern =  FALSE */
 1043|       |#ifdef HAVE_AQUA
 1044|       |	R_Busy(1);
 1045|       |#endif
 1046|      0|	tlist = PROTECT(allocVector(INTSXP, 1));
  ------------------
  |  |  357|      0|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1047|      0|	fflush(stdout);
 1048|      0|	int res;
 1049|       |	/* When running background processes (last_is_amp) in interactive mode,
 1050|       |	   Ctrl+C (SIGINT) should just interrupt the currently executing R
 1051|       |	   loop or cancel currently edited command, but it should not kill
 1052|       |	   the background processes (PR#17764). The C library system() runs
 1053|       |	   background processes as (orphaned) processes in the same process
 1054|       |	   group as R, so they receive SIGINT, and may terminate themselves
 1055|       |	   consequently, such as R itself used to. Applications that leave
 1056|       |	   the SIG_IGN disposition of SIGINT (set by system()) alone will not
 1057|       |	   be terminated.
 1058|       |
 1059|       |	   We hence use R_system_timeout (even without a real timeout), which
 1060|       |	   runs the task in a new process group, and hence does not receive
 1061|       |	   SIGINT as a result of Ctrl+C from R console. However, we only
 1062|       |	   use R_system_timeout in this case, because it has undesirable
 1063|       |	   consequences for job control (SIGTSTP, SIGCONT missed, so Ctrl+Z does
 1064|       |	   not suspend) and termination (SIGHUP missed, so terminal close does
 1065|       |	   not terminate).
 1066|       |
 1067|       |	   When running a background process (last_is_amp, normally via
 1068|       |	   wait=FALSE), which serves as an implementation of a foreground
 1069|       |	   operation (such as clusterApply()), one can use
 1070|       |	   receive.console.signals=TRUE to force the non-timeout
 1071|       |	   implementation. */
 1072|      0|	if (timeout == 0 && (!R_Interactive || !last_is_amp || consignals))
  ------------------
  |  Branch (1072:6): [True: 0, False: 0]
  |  Branch (1072:23): [True: 0, False: 0]
  |  Branch (1072:41): [True: 0, False: 0]
  |  Branch (1072:57): [True: 0, False: 0]
  ------------------
 1073|      0|	    res = R_system(cmd);
 1074|      0|	else 
 1075|      0|	    res = R_system_timeout(cmd, timeout);
 1076|      0|	if (res == 127) 
  ------------------
  |  Branch (1076:6): [True: 0, False: 0]
  ------------------
 1077|      0|	    warning(_("error in running command"));
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("error in running command"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1078|      0|	if (timeout && tost.timedout) {
  ------------------
  |  Branch (1078:6): [True: 0, False: 0]
  |  Branch (1078:17): [True: 0, False: 0]
  ------------------
 1079|      0|	    res = 124;
 1080|      0|	    warning(_("command '%s' timed out after %ds"), cmd, timeout);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	    warning(_("command '%s' timed out after %ds"), cmd, timeout);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
 1081|      0|	} 
 1082|      0|	INTEGER(tlist)[0] = res;
 1083|       |#ifdef HAVE_AQUA
 1084|       |	R_Busy(0);
 1085|       |#endif
 1086|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1087|      0|	R_Visible = 0;
 1088|      0|	return tlist;
 1089|      0|    }
 1090|      4|}
do_sysinfo:
 1104|      4|{
 1105|      4|    SEXP ans, ansnames;
 1106|      4|    struct utsname name;
 1107|      4|    char *login;
 1108|       |
 1109|      4|    checkArity(op, args);
  ------------------
  |  | 1788|      4|#define checkArity(a,b) Rf_checkArityCall(a,b,call)
  ------------------
 1110|      4|    PROTECT(ans = allocVector(STRSXP, 8));
  ------------------
  |  |  357|      4|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1111|      4|    if(uname(&name) == -1) {
  ------------------
  |  Branch (1111:8): [True: 0, False: 4]
  ------------------
 1112|      0|	UNPROTECT(1);
  ------------------
  |  |  358|      0|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1113|      0|	return R_NilValue;
 1114|      0|    }
 1115|      4|    SET_STRING_ELT(ans, 0, mkChar(name.sysname));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
 1116|      4|    SET_STRING_ELT(ans, 1, mkChar(name.release));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
 1117|      4|    SET_STRING_ELT(ans, 2, mkChar(name.version));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
 1118|      4|    SET_STRING_ELT(ans, 3, mkChar(name.nodename));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
 1119|      4|    SET_STRING_ELT(ans, 4, mkChar(name.machine));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
 1120|      4|    login = getlogin();
 1121|      4|    SET_STRING_ELT(ans, 5, login ? mkChar(login) : mkChar("unknown"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
                  SET_STRING_ELT(ans, 5, login ? mkChar(login) : mkChar("unknown"));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
  |  Branch (1121:28): [True: 0, False: 4]
  ------------------
 1122|      4|#if defined(HAVE_PWD_H) && defined(HAVE_GETPWUID) && defined(HAVE_GETUID)
 1123|      4|    {
 1124|      4|	struct passwd *stpwd;
 1125|      4|	stpwd = getpwuid(getuid());
 1126|      4|	SET_STRING_ELT(ans, 6, stpwd ? mkChar(stpwd->pw_name) : mkChar("unknown"));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
              	SET_STRING_ELT(ans, 6, stpwd ? mkChar(stpwd->pw_name) : mkChar("unknown"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  |  Branch (1126:25): [True: 4, False: 0]
  ------------------
 1127|      4|    }
 1128|       |#else
 1129|       |    SET_STRING_ELT(ans, 6, mkChar("unknown"));
 1130|       |#endif
 1131|      4|#if defined(HAVE_PWD_H) && defined(HAVE_GETPWUID) && defined(HAVE_GETEUID)
 1132|      4|    {
 1133|      4|	struct passwd *stpwd;
 1134|      4|	stpwd = getpwuid(geteuid());
 1135|      4|	SET_STRING_ELT(ans, 7, stpwd ? mkChar(stpwd->pw_name) : mkChar("unknown"));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
              	SET_STRING_ELT(ans, 7, stpwd ? mkChar(stpwd->pw_name) : mkChar("unknown"));
  ------------------
  |  |  998|      0|#define mkChar			Rf_mkChar
  ------------------
  |  Branch (1135:25): [True: 4, False: 0]
  ------------------
 1136|      4|    }
 1137|       |#else
 1138|       |    SET_STRING_ELT(ans, 7, mkChar("unknown"));
 1139|       |#endif
 1140|      4|    PROTECT(ansnames = allocVector(STRSXP, 8));
  ------------------
  |  |  357|      4|#define PROTECT(s)	Rf_protect(s)
  ------------------
 1141|      4|    SET_STRING_ELT(ansnames, 0, mkChar("sysname"));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
 1142|      4|    SET_STRING_ELT(ansnames, 1, mkChar("release"));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
 1143|      4|    SET_STRING_ELT(ansnames, 2, mkChar("version"));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
 1144|      4|    SET_STRING_ELT(ansnames, 3, mkChar("nodename"));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
 1145|      4|    SET_STRING_ELT(ansnames, 4, mkChar("machine"));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
 1146|      4|    SET_STRING_ELT(ansnames, 5, mkChar("login"));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
 1147|      4|    SET_STRING_ELT(ansnames, 6, mkChar("user"));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
 1148|      4|    SET_STRING_ELT(ansnames, 7, mkChar("effective_user"));
  ------------------
  |  |  998|      4|#define mkChar			Rf_mkChar
  ------------------
 1149|      4|    setAttrib(ans, R_NamesSymbol, ansnames);
  ------------------
  |  | 1027|      4|#define setAttrib		Rf_setAttrib
  ------------------
 1150|      4|    UNPROTECT(2);
  ------------------
  |  |  358|      4|#define UNPROTECT(n)	Rf_unprotect(n)
  ------------------
 1151|      4|    return ans;
 1152|      4|}
R_ProcessEvents:
 1169|  1.24M|{
 1170|       |#ifdef HAVE_AQUA
 1171|       |    /* disable ProcessEvents in child,
 1172|       |       since we can't call CoreFoundation there. */
 1173|       |    if (ptr_R_ProcessEvents && !R_isForkedChild) ptr_R_ProcessEvents();
 1174|       |#else
 1175|       |    /* We might in due course want to always inhibit in a child */
 1176|  1.24M|    if (ptr_R_ProcessEvents) ptr_R_ProcessEvents();
  ------------------
  |  Branch (1176:9): [True: 0, False: 1.24M]
  ------------------
 1177|  1.24M|#endif
 1178|  1.24M|    R_PolledEvents();
 1179|  1.24M|    if (cpuLimit > 0.0 || elapsedLimit > 0.0)
  ------------------
  |  Branch (1179:9): [True: 0, False: 1.24M]
  |  Branch (1179:27): [True: 0, False: 1.24M]
  ------------------
 1180|      0|	R_CheckTimeLimits();
 1181|  1.24M|}
fpu_setup:
 1205|      2|{
 1206|      2|    if (start) {
  ------------------
  |  Branch (1206:9): [True: 2, False: 0]
  ------------------
 1207|       |#ifdef __FreeBSD__
 1208|       |    fpsetmask(0);
 1209|       |#endif
 1210|       |
 1211|       |#if (defined(__i386) || defined(__x86_64)) && defined(__INTEL_COMPILER) && __INTEL_COMPILER > 800
 1212|       |    _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_OFF);
 1213|       |    _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_OFF);
 1214|       |#endif
 1215|       |
 1216|       |#if defined(__ARM_ARCH) && defined(__ARM_32BIT_STATE) && defined(__ARM_FP)
 1217|       |    uint32_t fpscr;
 1218|       |
 1219|       |    __asm__ volatile("vmrs %0, fpscr" : "=r"(fpscr));
 1220|       |    /* clear/disable DN (default NaN) and FZ (flush to zero) bits */
 1221|       |    fpscr = fpscr & 0xfcffffff;
 1222|       |    __asm__ volatile("vmsr fpscr, %0" : : "r"(fpscr));
 1223|       |#elif defined(__ARM_ARCH) && defined(__ARM_64BIT_STATE) && defined(__ARM_FP)
 1224|       |    uint64_t fpcr;
 1225|       |
 1226|       |    __asm__ volatile("mrs %0, fpcr" : "=r"(fpcr));
 1227|       |    /* clear/disable DN (default NaN) and FZ (flush to zero) bits */
 1228|       |    fpcr = fpcr & 0xfffffffffcffffff;
 1229|       |    __asm__ volatile("msr fpcr, %0" : : "r"(fpcr));
 1230|       |#endif
 1231|      2|    } else {
 1232|       |#ifdef __FreeBSD__
 1233|       |    fpsetmask(~0);
 1234|       |#endif
 1235|      0|    }
 1236|      2|}
sys-unix.c:warn_status:
  853|      4|{
  854|      4|    if (!res)
  ------------------
  |  Branch (854:9): [True: 4, False: 0]
  ------------------
  855|      4|	return;
  856|       |
  857|      0|    if (errno)
  ------------------
  |  Branch (857:9): [True: 0, False: 0]
  ------------------
  858|       |	/* FIXME: TK: non-zero errno is a sign of an error only when
  859|       |	   a function that modified it also signals an error by its
  860|       |	   return value, usually -1 or EOF. We should not be reporting
  861|       |	   an error here (CERT ERR30-C).*/
  862|       |	/* on Solaris, if the command ends with non-zero status and timeout
  863|       |	   is 0, "Illegal seek" error is reported; the timeout version
  864|       |	   works this around by restoring errno on success */
  865|      0|	warning(_("running command '%s' had status %d and error message '%s'"),
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("running command '%s' had status %d and error message '%s'"),
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  866|      0|		cmd, res, strerror(errno));
  867|      0|    else
  868|      0|	warning(_("running command '%s' had status %d"), cmd, res);
  ------------------
  |  |   89|      0|#define warning Rf_warning
  ------------------
              	warning(_("running command '%s' had status %d"), cmd, res);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  869|      0|}

R_ResetConsole:
   79|  1.90k|void R_ResetConsole(void) { ptr_R_ResetConsole(); }
R_FlushConsole:
   81|  1.90k|void R_FlushConsole(void) { ptr_R_FlushConsole(); }
R_ClearerrConsole:
   83|  1.90k|void R_ClearerrConsole(void) { ptr_R_ClearerrConsole(); }
R_setupHistory:
  120|      2|{
  121|      2|    int value, ierr;
  122|      2|    char *p;
  123|       |
  124|      2|    if ((R_HistoryFile = getenv("R_HISTFILE")) == NULL)
  ------------------
  |  Branch (124:9): [True: 2, False: 0]
  ------------------
  125|      2|	R_HistoryFile = ".Rhistory";
  126|      2|    R_HistorySize = 512;
  127|      2|    if ((p = getenv("R_HISTSIZE"))) {
  ------------------
  |  Branch (127:9): [True: 0, False: 2]
  ------------------
  128|      0|	value = (int) R_Decode2Long(p, &ierr);
  129|      0|	if (ierr != 0 || value < 0)
  ------------------
  |  Branch (129:6): [True: 0, False: 0]
  |  Branch (129:19): [True: 0, False: 0]
  ------------------
  130|      0|	    R_ShowMessage("WARNING: invalid R_HISTSIZE ignored;");
  131|      0|	else
  132|      0|	    R_HistorySize = value;
  133|      0|    }
  134|      2|}
Rf_initialize_R:
  191|      2|{
  192|      2|    int i, ioff = 1, j;
  193|      2|    Rboolean useX11 = TRUE, useTk = FALSE;
  194|      2|    char *p, msg[MSGSIZE], cmdlines[10000], **avv;
  195|      2|    structRstart rstart;
  196|      2|    Rstart Rp = &rstart;
  197|      2|    Rboolean force_interactive = FALSE;
  198|       |
  199|      2|    if (num_initialized++) {
  ------------------
  |  Branch (199:9): [True: 0, False: 2]
  ------------------
  200|      0|	fprintf(stderr, "%s", "R is already initialized\n");
  201|      0|	exit(1);
  202|      0|    }
  203|       |
  204|       |
  205|      2|#if defined(HAVE_SYS_RESOURCE_H) && defined(HAVE_GETRLIMIT)
  206|      2|{
  207|       |    /* getrlimit is POSIX:
  208|       |       https://pubs.opengroup.org/onlinepubs/9699919799/functions/getrlimit.html
  209|       |    */
  210|      2|    struct rlimit rlim;
  211|       |
  212|      2|    R_CStackDir = C_STACK_DIRECTION;
  ------------------
  |  |   14|      2|#define C_STACK_DIRECTION 1
  ------------------
  213|       |    
  214|       |
  215|      2|    if(getrlimit(RLIMIT_STACK, &rlim) == 0) {
  ------------------
  |  Branch (215:8): [True: 2, False: 0]
  ------------------
  216|       |	/* 'unlimited' is represented by RLIM_INFINITY, which is a
  217|       |	   very large (but maybe not the largest) representable value.
  218|       |
  219|       |	   The standard allows the values RLIM_SAVED_CUR and
  220|       |	   RLIB_SAVED_MAX, apparently used on 32-bit AIX.  
  221|       |	   (http://www.ibm.com/support/knowledgecenter/ssw_aix_61/com.ibm.aix.basetrf1/getrlimit_64.htm)
  222|       |
  223|       |	   These may or may not be different from RLIM_INFINITY (they
  224|       |	   are the same on Linux and macOS but not Solaris where they
  225|       |	   are larger).  We will assume that unrepresentable limits
  226|       |	   are very large.
  227|       |
  228|       |	   This is cautious: it is extremely unlikely that the soft
  229|       |	   limit is either unlimited or unrepresentable.
  230|       |	*/
  231|      2|	rlim_t lim = rlim.rlim_cur;
  232|      2|#if defined(RLIM_SAVED_CUR) && defined(RLIM_SAVED_MAX)
  233|      2|	if (lim == RLIM_SAVED_CUR || lim == RLIM_SAVED_MAX) 
  ------------------
  |  Branch (233:6): [True: 0, False: 2]
  |  Branch (233:31): [True: 0, False: 2]
  ------------------
  234|      0|	    lim = RLIM_INFINITY;
  235|      2|#endif
  236|      2|	if (lim != RLIM_INFINITY) R_CStackLimit = (uintptr_t) lim;
  ------------------
  |  Branch (236:6): [True: 2, False: 0]
  ------------------
  237|      2|    }
  238|      2|#if defined(HAVE_LIBC_STACK_END)
  239|      2|    {
  240|      2|	R_CStackStart = (uintptr_t) __libc_stack_end;
  241|       |	/* The libc stack end is not exactly at the stack start, so one
  242|       |	   cannot access __libc_stack_end - R_CStackLimit/getrlimit + 1. We
  243|       |	   have to find the real stack start that matches getrlimit.
  244|       |
  245|       |	   A modern alternative to __libc_stack_end and to parsing /proc/maps
  246|       |	   directly is pthread_getattr_np; it doesn't provide the exact stack
  247|       |	   start, either, but provides a matching stack size smaller than 
  248|       |	   the one obtained from getrlimit. However, pthread_getattr_np
  249|       |	   may have not worked properly on old Linux distributions. */
  250|       |	
  251|       |	/* based on GDB relocatable.c */
  252|      2|	FILE *f;
  253|      2|	f = fopen("/proc/self/maps", "r");
  254|      2|	if (f) {
  ------------------
  |  Branch (254:6): [True: 2, False: 0]
  ------------------
  255|    238|	    for(;;) {
  256|    238|		int c;
  257|    238|		unsigned long start, end;
  258|       |
  259|    238|		if (fscanf(f, "%lx-%lx", &start, &end) == 2 &&
  ------------------
  |  Branch (259:7): [True: 238, False: 0]
  ------------------
  260|    238|		    R_CStackStart >= (uintptr_t)start &&
  ------------------
  |  Branch (260:7): [True: 238, False: 0]
  ------------------
  261|    238|		    R_CStackStart < (uintptr_t)end) {
  ------------------
  |  Branch (261:7): [True: 2, False: 236]
  ------------------
  262|       |		    
  263|       |		    /* would this be ok for R_CStackDir == -1? */
  264|      2|		    R_CStackStart = (uintptr_t) ((R_CStackDir == 1) ? end : start);
  ------------------
  |  Branch (264:36): [True: 2, False: 0]
  ------------------
  265|      2|		    break;
  266|      2|		}
  267|  19.7k|		for(c = getc(f); c != '\n' && c != EOF; c = getc(f));
  ------------------
  |  Branch (267:20): [True: 19.4k, False: 236]
  |  Branch (267:33): [True: 19.4k, False: 0]
  ------------------
  268|    236|		if (c == EOF) {
  ------------------
  |  Branch (268:7): [True: 0, False: 236]
  ------------------
  269|       |		    /* could also abort here, but R will usually work with
  270|       |		       R_CStackStart set just for __libc_stack_end */
  271|      0|		    fprintf(stderr, "WARNING: Error parsing /proc/self/maps!\n");
  272|      0|		    break;
  273|      0|		}
  274|    236|	    }
  275|      2|	    fclose(f);
  276|      2|	}
  277|      2|    }
  278|       |#elif defined(HAVE_KERN_USRSTACK)
  279|       |    {
  280|       |	/* Borrowed from mzscheme/gc/os_dep.c */
  281|       |	int nm[2] = {CTL_KERN, KERN_USRSTACK};
  282|       |	void * base;
  283|       |	size_t len = sizeof(void *);
  284|       |	(void) sysctl(nm, 2, &base, &len, NULL, 0);
  285|       |	R_CStackStart = (uintptr_t) base;
  286|       |    }
  287|       |#elif defined(HAVE_THR_STKSEGMENT)
  288|       |    {
  289|       |	/* Solaris */
  290|       |	stack_t stack;
  291|       |	if (thr_stksegment(&stack))
  292|       |	    R_Suicide("Cannot obtain stack information (thr_stksegment).");
  293|       |	R_CStackStart = (uintptr_t) stack.ss_sp;
  294|       |	/* This _may_ have to be adjusted for a (perhaps theoretical) platform
  295|       |	   where the stack would grow upwards.
  296|       |
  297|       |	   The stack size could be updated based on stack.ss_size, but experiments
  298|       |	   suggest getrlimit is safe here. */
  299|       |    }
  300|       |#else
  301|       |    if(R_running_as_main_program) {
  302|       |	/* This is not the main program, but unless embedded it is
  303|       |	   near the top, 5540 bytes away when checked. */
  304|       |	R_CStackStart = (uintptr_t) &i + (6000 * R_CStackDir);
  305|       |    }
  306|       |#endif
  307|      2|    if(R_CStackStart == (uintptr_t)(-1)) R_CStackLimit = (uintptr_t)(-1); /* never set */
  ------------------
  |  Branch (307:8): [True: 0, False: 2]
  ------------------
  308|       |
  309|       |    /* setup_Rmainloop includes (disabled) code to test stack detection */
  310|      2|}
  311|      2|#endif
  312|       |
  313|      2|    ptr_R_Suicide = Rstd_Suicide;
  314|      2|    ptr_R_ShowMessage = Rstd_ShowMessage;
  315|      2|    ptr_R_ReadConsole = Rstd_ReadConsole;
  316|      2|    ptr_R_WriteConsole = Rstd_WriteConsole;
  317|      2|    ptr_R_ResetConsole = Rstd_ResetConsole;
  318|      2|    ptr_R_FlushConsole = Rstd_FlushConsole;
  319|      2|    ptr_R_ClearerrConsole = Rstd_ClearerrConsole;
  320|      2|    ptr_R_Busy = Rstd_Busy;
  321|      2|    ptr_R_CleanUp = Rstd_CleanUp;
  322|      2|    ptr_R_ShowFiles = Rstd_ShowFiles;
  323|      2|    ptr_R_ChooseFile = Rstd_ChooseFile;
  324|      2|    ptr_R_loadhistory = Rstd_loadhistory;
  325|      2|    ptr_R_savehistory = Rstd_savehistory;
  326|      2|    ptr_R_addhistory = Rstd_addhistory;
  327|      2|    ptr_R_EditFile = NULL; /* for future expansion */
  328|      2|    R_timeout_handler = NULL;
  329|      2|    R_timeout_val = 0;
  330|       |
  331|      2|    R_GlobalContext = NULL; /* Make R_Suicide less messy... */
  332|       |
  333|      2|    if((R_Home = R_HomeDir()) == NULL)
  ------------------
  |  Branch (333:8): [True: 0, False: 2]
  ------------------
  334|      0|	R_Suicide("R home directory is not defined");
  335|      2|    BindDomain(R_Home);
  ------------------
  |  | 1865|      2|# define BindDomain		Rf_BindDomain
  ------------------
  336|       |
  337|      2|    process_system_Renviron();
  338|       |
  339|      2|    R_setStartTime();
  340|      2|    R_DefParamsEx(Rp, RSTART_VERSION);
  ------------------
  |  |   47|      2|#define RSTART_VERSION 1 /* version 1 introduced in R 4.2.0 */
  ------------------
  341|       |    /* Store the command line arguments before they are processed
  342|       |       by the R option handler.
  343|       |     */
  344|      2|    R_set_command_line_arguments(ac, av);
  345|      2|    cmdlines[0] = '\0';
  346|       |
  347|       |    /* first task is to select the GUI.
  348|       |       If run from the shell script, only Tk|tk|X11|x11 are allowed.
  349|       |     */
  350|     10|    for(i = 0, avv = av; i < ac; i++, avv++) {
  ------------------
  |  Branch (350:26): [True: 8, False: 2]
  ------------------
  351|      8|	if (!strcmp(*avv, "--args"))
  ------------------
  |  Branch (351:6): [True: 0, False: 8]
  ------------------
  352|      0|	    break;
  353|      8|	if(!strncmp(*avv, "--gui", 5) || !strncmp(*avv, "-g", 2)) {
  ------------------
  |  Branch (353:5): [True: 0, False: 8]
  |  Branch (353:35): [True: 0, False: 8]
  ------------------
  354|      0|	    if(!strncmp(*avv, "--gui", 5) && strlen(*avv) >= 7)
  ------------------
  |  Branch (354:9): [True: 0, False: 0]
  |  Branch (354:39): [True: 0, False: 0]
  ------------------
  355|      0|		p = &(*avv)[6];
  356|      0|	    else {
  357|      0|		if(i+1 < ac) {
  ------------------
  |  Branch (357:6): [True: 0, False: 0]
  ------------------
  358|      0|		    avv++; p = *avv; ioff++;
  359|      0|		} else {
  360|      0|		    snprintf(msg, MSGSIZE,
  ------------------
  |  |  189|      0|#define MSGSIZE R_PATH_MAX + 128
  |  |  ------------------
  |  |  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  |  |  ------------------
  ------------------
  361|      0|			    _("WARNING: --gui or -g without value ignored"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  362|      0|		    R_ShowMessage(msg);
  363|      0|		    p = "X11";
  364|      0|		}
  365|      0|	    }
  366|      0|	    if(!strcmp(p, "none"))
  ------------------
  |  Branch (366:9): [True: 0, False: 0]
  ------------------
  367|      0|		useX11 = FALSE; // not allowed from R.sh
  368|       |#ifdef HAVE_AQUA
  369|       |	    else if(!strcmp(p, "aqua"))
  370|       |		useaqua = TRUE; // not allowed from R.sh but used by R.app
  371|       |#endif
  372|      0|	    else if(!strcmp(p, "X11") || !strcmp(p, "x11"))
  ------------------
  |  Branch (372:14): [True: 0, False: 0]
  |  Branch (372:35): [True: 0, False: 0]
  ------------------
  373|      0|		useX11 = TRUE;
  374|      0|	    else if(!strcmp(p, "Tk") || !strcmp(p, "tk"))
  ------------------
  |  Branch (374:14): [True: 0, False: 0]
  |  Branch (374:34): [True: 0, False: 0]
  ------------------
  375|      0|		useTk = TRUE;
  376|      0|	    else {
  377|       |#ifdef HAVE_X11
  378|       |		snprintf(msg, MSGSIZE,
  379|       |			 _("WARNING: unknown gui '%s', using X11\n"), p);
  380|       |#else
  381|      0|		snprintf(msg, MSGSIZE,
  ------------------
  |  |  189|      0|#define MSGSIZE R_PATH_MAX + 128
  |  |  ------------------
  |  |  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  |  |  ------------------
  ------------------
  382|      0|			 _("WARNING: unknown gui '%s', using none\n"), p);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  383|      0|#endif
  384|      0|		R_ShowMessage(msg);
  385|      0|	    }
  386|       |	    /* now remove it/them */
  387|      0|	    for(j = i; j < ac - ioff; j++)
  ------------------
  |  Branch (387:17): [True: 0, False: 0]
  ------------------
  388|      0|		av[j] = av[j + ioff];
  389|      0|	    ac -= ioff;
  390|      0|	    break;
  391|      0|	}
  392|      8|    }
  393|       |
  394|       |#ifdef HAVE_X11
  395|       |    if(useX11) R_GUIType = "X11";
  396|       |#endif /* HAVE_X11 */
  397|       |
  398|       |#ifdef HAVE_AQUA
  399|       |    if(useaqua) R_GUIType = "AQUA";
  400|       |#endif
  401|       |
  402|       |#ifdef HAVE_TCLTK
  403|       |    if(useTk) R_GUIType = "Tk";
  404|       |#endif
  405|       |
  406|      2|    R_common_command_line(&ac, av, Rp);
  407|      2|    while (--ac) {
  ------------------
  |  Branch (407:12): [True: 0, False: 2]
  ------------------
  408|      0|	if (**++av == '-') {
  ------------------
  |  Branch (408:6): [True: 0, False: 0]
  ------------------
  409|      0|	    if(!strcmp(*av, "--no-readline")) {
  ------------------
  |  Branch (409:9): [True: 0, False: 0]
  ------------------
  410|      0|		UsingReadline = FALSE;
  411|      0|	    } else if(!strcmp(*av, "-f")) {
  ------------------
  |  Branch (411:16): [True: 0, False: 0]
  ------------------
  412|      0|		ac--; av++;
  413|      0|#define R_INIT_TREAT_F(_AV_)						\
  414|      0|		Rp->R_Interactive = FALSE;				\
  415|      0|		if(strcmp(_AV_, "-")) {					\
  416|      0|		    if(strlen(_AV_) >= R_PATH_MAX) {			\
  417|      0|			snprintf(msg, MSGSIZE,				\
  418|      0|				 _("path given in -f/--file is too long"));	\
  419|      0|			R_Suicide(msg);					\
  420|      0|		    }							\
  421|      0|		    char path[R_PATH_MAX], *p = path;			\
  422|      0|		    p = unescape_arg(p, _AV_);				\
  423|      0|		    *p = '\0';						\
  424|      0|		    ifp = R_fopen(path, "r");				\
  425|      0|		    if(!ifp) {						\
  426|      0|			snprintf(msg, MSGSIZE,				\
  427|      0|				 _("cannot open file '%s': %s"),	\
  428|      0|				 path, strerror(errno));		\
  429|      0|			R_Suicide(msg);					\
  430|      0|		    }							\
  431|      0|		}
  432|      0|		R_INIT_TREAT_F(*av);
  ------------------
  |  |  414|      0|		Rp->R_Interactive = FALSE;				\
  |  |  415|      0|		if(strcmp(_AV_, "-")) {					\
  |  |  ------------------
  |  |  |  Branch (415:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  416|      0|		    if(strlen(_AV_) >= R_PATH_MAX) {			\
  |  |  ------------------
  |  |  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  |  |  ------------------
  |  |  |  Branch (416:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  417|      0|			snprintf(msg, MSGSIZE,				\
  |  |  ------------------
  |  |  |  |  189|      0|#define MSGSIZE R_PATH_MAX + 128
  |  |  |  |  ------------------
  |  |  |  |  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  418|      0|				 _("path given in -f/--file is too long"));	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  419|      0|			R_Suicide(msg);					\
  |  |  420|      0|		    }							\
  |  |  421|      0|		    char path[R_PATH_MAX], *p = path;			\
  |  |  422|      0|		    p = unescape_arg(p, _AV_);				\
  |  |  423|      0|		    *p = '\0';						\
  |  |  424|      0|		    ifp = R_fopen(path, "r");				\
  |  |  425|      0|		    if(!ifp) {						\
  |  |  ------------------
  |  |  |  Branch (425:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  426|      0|			snprintf(msg, MSGSIZE,				\
  |  |  ------------------
  |  |  |  |  189|      0|#define MSGSIZE R_PATH_MAX + 128
  |  |  |  |  ------------------
  |  |  |  |  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  427|      0|				 _("cannot open file '%s': %s"),	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  428|      0|				 path, strerror(errno));		\
  |  |  429|      0|			R_Suicide(msg);					\
  |  |  430|      0|		    }							\
  |  |  431|      0|		}
  ------------------
  433|       |
  434|      0|	    } else if(!strncmp(*av, "--file=", 7)) {
  ------------------
  |  Branch (434:16): [True: 0, False: 0]
  ------------------
  435|       |
  436|      0|		R_INIT_TREAT_F((*av)+7);
  ------------------
  |  |  414|      0|		Rp->R_Interactive = FALSE;				\
  |  |  415|      0|		if(strcmp(_AV_, "-")) {					\
  |  |  ------------------
  |  |  |  Branch (415:6): [True: 0, False: 0]
  |  |  ------------------
  |  |  416|      0|		    if(strlen(_AV_) >= R_PATH_MAX) {			\
  |  |  ------------------
  |  |  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  |  |  ------------------
  |  |  |  Branch (416:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  417|      0|			snprintf(msg, MSGSIZE,				\
  |  |  ------------------
  |  |  |  |  189|      0|#define MSGSIZE R_PATH_MAX + 128
  |  |  |  |  ------------------
  |  |  |  |  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  418|      0|				 _("path given in -f/--file is too long"));	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  419|      0|			R_Suicide(msg);					\
  |  |  420|      0|		    }							\
  |  |  421|      0|		    char path[R_PATH_MAX], *p = path;			\
  |  |  422|      0|		    p = unescape_arg(p, _AV_);				\
  |  |  423|      0|		    *p = '\0';						\
  |  |  424|      0|		    ifp = R_fopen(path, "r");				\
  |  |  425|      0|		    if(!ifp) {						\
  |  |  ------------------
  |  |  |  Branch (425:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  426|      0|			snprintf(msg, MSGSIZE,				\
  |  |  ------------------
  |  |  |  |  189|      0|#define MSGSIZE R_PATH_MAX + 128
  |  |  |  |  ------------------
  |  |  |  |  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  427|      0|				 _("cannot open file '%s': %s"),	\
  |  |  ------------------
  |  |  |  | 2531|      0|#   define _(String) gettext (String)
  |  |  ------------------
  |  |  428|      0|				 path, strerror(errno));		\
  |  |  429|      0|			R_Suicide(msg);					\
  |  |  430|      0|		    }							\
  |  |  431|      0|		}
  ------------------
  437|       |
  438|      0|	    } else if(!strcmp(*av, "-e")) {
  ------------------
  |  Branch (438:16): [True: 0, False: 0]
  ------------------
  439|      0|		ac--; av++;
  440|      0|		Rp->R_Interactive = FALSE;
  441|      0|		if(strlen(cmdlines) + strlen(*av) + 2 <= 10000) {
  ------------------
  |  Branch (441:6): [True: 0, False: 0]
  ------------------
  442|      0|		    char *p = cmdlines+strlen(cmdlines);
  443|      0|		    p = unescape_arg(p, *av);
  444|      0|		    *p++ = '\n'; *p = '\0';
  445|      0|		} else {
  446|      0|		    snprintf(msg, MSGSIZE, _("WARNING: '-e %s' omitted as input is too long\n"), *av);
  ------------------
  |  |  189|      0|#define MSGSIZE R_PATH_MAX + 128
  |  |  ------------------
  |  |  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  |  |  ------------------
  ------------------
              		    snprintf(msg, MSGSIZE, _("WARNING: '-e %s' omitted as input is too long\n"), *av);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  447|      0|		    R_ShowMessage(msg);
  448|      0|		}
  449|      0|	    } else if(!strcmp(*av, "--args")) {
  ------------------
  |  Branch (449:16): [True: 0, False: 0]
  ------------------
  450|      0|		break;
  451|      0|	    } else if(!strcmp(*av, "--interactive")) {
  ------------------
  |  Branch (451:16): [True: 0, False: 0]
  ------------------
  452|      0|		force_interactive = TRUE;
  453|      0|		break;
  454|      0|	    } else {
  455|       |#ifdef HAVE_AQUA
  456|       |		// r27492: in 2003 launching from 'Finder OSX' passed this
  457|       |		if(!strncmp(*av, "-psn", 4)) break; else
  458|       |#endif
  459|      0|		snprintf(msg, MSGSIZE, _("WARNING: unknown option '%s'\n"), *av);
  ------------------
  |  |  189|      0|#define MSGSIZE R_PATH_MAX + 128
  |  |  ------------------
  |  |  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  |  |  ------------------
  ------------------
              		snprintf(msg, MSGSIZE, _("WARNING: unknown option '%s'\n"), *av);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  460|      0|		R_ShowMessage(msg);
  461|      0|	    }
  462|      0|	} else {
  463|      0|	    snprintf(msg, MSGSIZE, _("ARGUMENT '%s' __ignored__\n"), *av);
  ------------------
  |  |  189|      0|#define MSGSIZE R_PATH_MAX + 128
  |  |  ------------------
  |  |  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  |  |  ------------------
  ------------------
              	    snprintf(msg, MSGSIZE, _("ARGUMENT '%s' __ignored__\n"), *av);
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  464|      0|	    R_ShowMessage(msg);
  465|      0|	}
  466|      0|    }
  467|       |
  468|      2|    if(strlen(cmdlines)) { /* had at least one -e option */
  ------------------
  |  Branch (468:8): [True: 0, False: 2]
  ------------------
  469|      0|	size_t res;
  470|      0|	char *tm;
  471|      0|	static char ifile[R_PATH_MAX] = "\0";
  472|      0|	int ifd;
  473|       |
  474|      0|	if(ifp) R_Suicide(_("cannot use -e with -f or --file"));    
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (474:5): [True: 0, False: 0]
  ------------------
  475|       |	/* tmpfile() does not respect TMPDIR on some systems (PR#17925).
  476|       |	   R_TempDir is not initialized, yet. */
  477|      0|	tm = getenv("TMPDIR");
  478|      0|	if (!R_isWriteableDir(tm)) {
  ------------------
  |  Branch (478:6): [True: 0, False: 0]
  ------------------
  479|      0|	    tm = getenv("TMP");
  480|      0|	    if (!R_isWriteableDir(tm)) {
  ------------------
  |  Branch (480:10): [True: 0, False: 0]
  ------------------
  481|      0|		tm = getenv("TEMP");
  482|      0|		if (!R_isWriteableDir(tm))
  ------------------
  |  Branch (482:7): [True: 0, False: 0]
  ------------------
  483|      0|		    tm = "/tmp";
  484|      0|	    }
  485|      0|	}
  486|      0|	snprintf(ifile, R_PATH_MAX, "%s/Rscript%x.XXXXXX", tm, getpid());
  ------------------
  |  | 1150|      0|# define R_PATH_MAX PATH_MAX
  ------------------
  487|      0|	ifd = mkstemp(ifile);
  488|      0|	if (ifd >= 0) /* -1 on error, can be 0 if stdin is closed */
  ------------------
  |  Branch (488:6): [True: 0, False: 0]
  ------------------
  489|      0|	    ifp = fdopen(ifd, "w+");
  490|      0|	if(!ifp) R_Suicide(_("creating temporary file for '-e' failed"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  |  Branch (490:5): [True: 0, False: 0]
  ------------------
  491|      0|	unlink(ifile);
  492|      0|	res = fwrite(cmdlines, 1, strlen(cmdlines), ifp);
  493|      0|	if(res != strlen(cmdlines)) R_Suicide("fwrite error in initialize_R");
  ------------------
  |  Branch (493:5): [True: 0, False: 0]
  ------------------
  494|      0|	fflush(ifp);
  495|      0|	rewind(ifp);
  496|      0|    }
  497|      2|    if (ifp && Rp->SaveAction != SA_SAVE) Rp->SaveAction = SA_NOSAVE;
  ------------------
  |  Branch (497:9): [True: 0, False: 2]
  |  Branch (497:16): [True: 0, False: 0]
  ------------------
  498|       |
  499|      2|    R_SetParams(Rp);
  500|       |
  501|      2|    if(!Rp->NoRenviron) {
  ------------------
  |  Branch (501:8): [True: 0, False: 2]
  ------------------
  502|      0|	process_site_Renviron();
  503|      0|	process_user_Renviron();
  504|       |
  505|       |	/* allow for R_MAX_[VN]SIZE and R_[VN]SIZE in user/site Renviron */
  506|      0|	R_SizeFromEnv(Rp);
  507|      0|	R_SetParams(Rp);
  508|      0|    }
  509|       |
  510|       |
  511|       |    /* On Unix the console is a file; we just use stdio to write on it */
  512|       |
  513|       |#ifdef HAVE_AQUA
  514|       |    if(useaqua)
  515|       |	R_Interactive = useaqua;
  516|       |    else
  517|       |#endif
  518|      2|	R_Interactive = R_Interactive && (force_interactive || R_isatty(0));
  ------------------
  |  Branch (518:18): [True: 2, False: 0]
  |  Branch (518:36): [True: 0, False: 2]
  |  Branch (518:57): [True: 0, False: 2]
  ------------------
  519|       |
  520|       |#ifdef HAVE_AQUA
  521|       |    /* for Aqua and non-dumb terminal use callbacks instead of connections
  522|       |       and pretty-print warnings/errors (ESS = dumb terminal) */
  523|       |    if(useaqua || 
  524|       |       (R_Interactive && getenv("TERM") && strcmp(getenv("TERM"), "dumb"))) {
  525|       |	R_Outputfile = NULL;
  526|       |	R_Consolefile = NULL;
  527|       |	ptr_R_WriteConsoleEx = Rstd_WriteConsoleEx;
  528|       |	ptr_R_WriteConsole = NULL;
  529|       |    } else {
  530|       |#endif
  531|      2|	R_Outputfile = stdout;
  532|      2|	R_Consolefile = stderr;
  533|       |#ifdef HAVE_AQUA
  534|       |    }
  535|       |#endif
  536|       |
  537|       |
  538|       |/*
  539|       | *  Since users' expectations for save/no-save will differ, we decided
  540|       | *  that they should be forced to specify in the non-interactive case.
  541|       | */
  542|      2|    if (!R_Interactive && Rp->SaveAction != SA_SAVE &&
  ------------------
  |  Branch (542:9): [True: 2, False: 0]
  |  Branch (542:27): [True: 2, False: 0]
  ------------------
  543|      2|	Rp->SaveAction != SA_NOSAVE)
  ------------------
  |  Branch (543:2): [True: 0, False: 2]
  ------------------
  544|      0|	R_Suicide(_("you must specify '--save', '--no-save' or '--vanilla'"));
  ------------------
  |  | 2531|      0|#   define _(String) gettext (String)
  ------------------
  545|       |
  546|      2|    R_setupHistory();
  547|      2|    if (R_RestoreHistory)
  ------------------
  |  Branch (547:9): [True: 0, False: 2]
  ------------------
  548|      0|	Rstd_read_history(R_HistoryFile);
  549|      2|    fpu_setup(1);
  550|       |
  551|      2|    return(0);
  552|      2|}
R_EnsureFDLimit:
  626|      2|attribute_hidden int R_EnsureFDLimit(int desired) {
  627|       |
  628|      2|#if defined(HAVE_SYS_RESOURCE_H) && defined(HAVE_SETRLIMIT) && defined(HAVE_GETRLIMIT)
  629|      2|    struct rlimit rlim;
  630|      2|    if (getrlimit(RLIMIT_NOFILE, &rlim))
  ------------------
  |  Branch (630:9): [True: 0, False: 2]
  ------------------
  631|      0|	return -1;
  632|      2|    rlim_t lim = rlim.rlim_cur;
  633|      2|#if defined(RLIM_SAVED_CUR) && defined(RLIM_SAVED_MAX)
  634|      2|    if (lim == RLIM_SAVED_CUR || lim == RLIM_SAVED_MAX) 
  ------------------
  |  Branch (634:9): [True: 0, False: 2]
  |  Branch (634:34): [True: 0, False: 2]
  ------------------
  635|      0|	lim = RLIM_INFINITY;
  636|      2|#endif
  637|      2|    if (lim == RLIM_INFINITY || lim >= desired)
  ------------------
  |  Branch (637:9): [True: 0, False: 2]
  |  Branch (637:33): [True: 2, False: 0]
  ------------------
  638|      2|	return desired;
  639|       |
  640|       |    /* increase the limit */
  641|      0|    rlim_t hlim = rlim.rlim_max;
  642|      0|#if defined(RLIM_SAVED_CUR) && defined(RLIM_SAVED_MAX)
  643|      0|    if (hlim == RLIM_SAVED_CUR || hlim == RLIM_SAVED_MAX) 
  ------------------
  |  Branch (643:9): [True: 0, False: 0]
  |  Branch (643:35): [True: 0, False: 0]
  ------------------
  644|      0|	hlim = RLIM_INFINITY;
  645|      0|#endif
  646|      0|    if (hlim == RLIM_INFINITY || hlim >= desired)
  ------------------
  |  Branch (646:9): [True: 0, False: 0]
  |  Branch (646:34): [True: 0, False: 0]
  ------------------
  647|      0|	rlim.rlim_cur = (rlim_t) desired;
  648|      0|    else
  649|      0|	rlim.rlim_cur = hlim;
  650|      0|    if (setrlimit(RLIMIT_NOFILE, &rlim))
  ------------------
  |  Branch (650:9): [True: 0, False: 0]
  ------------------
  651|      0|	return (int) lim; /* also could return error */
  652|       |    
  653|      0|    return (int) rlim.rlim_cur;
  654|       |#else
  655|       |    return -1;
  656|       |#endif
  657|      0|}

deflate_decompress.c:get_unaligned_leword:
  514|   592k|{
  515|   592k|	STATIC_ASSERT(WORDBITS == 32 || WORDBITS == 64);
  ------------------
  |  |  297|   592k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  516|   592k|	if (WORDBITS == 32)
  ------------------
  |  |  128|   592k|#define WORDBITS	(8 * WORDBYTES)
  |  |  ------------------
  |  |  |  |  125|   592k|#define WORDBYTES	((int)sizeof(machine_word_t))
  |  |  ------------------
  ------------------
  |  Branch (516:6): [Folded, False: 592k]
  ------------------
  517|      0|		return get_unaligned_le32(p);
  518|   592k|	else
  519|   592k|		return get_unaligned_le64(p);
  520|   592k|}
deflate_decompress.c:get_unaligned_le64:
  502|   592k|{
  503|   592k|	if (UNALIGNED_ACCESS_IS_FAST)
  ------------------
  |  |  402|   592k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  ------------------
  |  |  |  Branch (402:36): [True: 592k, Folded]
  |  |  ------------------
  ------------------
  504|   592k|		return le64_bswap(load_u64_unaligned(p));
  ------------------
  |  |  376|   592k|#define le64_bswap(v) (CPU_IS_LITTLE_ENDIAN() ? (v) : bswap64(v))
  |  |  ------------------
  |  |  |  |  312|   592k|#  define CPU_IS_LITTLE_ENDIAN()  (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (312:35): [True: 592k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  505|      0|	else
  506|      0|		return ((u64)p[7] << 56) | ((u64)p[6] << 48) |
  507|      0|			((u64)p[5] << 40) | ((u64)p[4] << 32) |
  508|      0|			((u64)p[3] << 24) | ((u64)p[2] << 16) |
  509|      0|			((u64)p[1] << 8) | p[0];
  510|   592k|}
deflate_decompress.c:load_u64_unaligned:
  436|   592k|load_##type##_unaligned(const void *p)				\
  437|   592k|{								\
  438|   592k|	type v;							\
  439|   592k|								\
  440|   592k|	MEMCOPY(&v, p, sizeof(v));				\
  ------------------
  |  |  429|   592k|#  define MEMCOPY	memcpy
  ------------------
  441|   592k|	return v;						\
  442|   592k|}								\
deflate_decompress.c:bsr32:
  611|   251k|{
  612|   251k|#if defined(__GNUC__) || __has_builtin(__builtin_clz)
  613|   251k|	return 31 - __builtin_clz(v);
  614|       |#elif defined(_MSC_VER)
  615|       |	unsigned long i;
  616|       |
  617|       |	_BitScanReverse(&i, v);
  618|       |	return i;
  619|       |#else
  620|       |	unsigned i = 0;
  621|       |
  622|       |	while ((v >>= 1) != 0)
  623|       |		i++;
  624|       |	return i;
  625|       |#endif
  626|   251k|}
deflate_decompress.c:store_machine_word_t_unaligned:
  445|  2.77M|store_##type##_unaligned(type v, void *p)			\
  446|  2.77M|{								\
  447|  2.77M|	MEMCOPY(p, &v, sizeof(v));				\
  ------------------
  |  |  429|  2.77M|#  define MEMCOPY	memcpy
  ------------------
  448|  2.77M|}
deflate_decompress.c:load_machine_word_t_unaligned:
  436|  2.75M|load_##type##_unaligned(const void *p)				\
  437|  2.75M|{								\
  438|  2.75M|	type v;							\
  439|  2.75M|								\
  440|  2.75M|	MEMCOPY(&v, p, sizeof(v));				\
  ------------------
  |  |  429|  2.75M|#  define MEMCOPY	memcpy
  ------------------
  441|  2.75M|	return v;						\
  442|  2.75M|}								\
zlib_decompress.c:get_unaligned_be16:
  473|  1.51k|{
  474|  1.51k|	if (UNALIGNED_ACCESS_IS_FAST)
  ------------------
  |  |  402|  1.51k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  ------------------
  |  |  |  Branch (402:36): [True: 1.51k, Folded]
  |  |  ------------------
  ------------------
  475|  1.51k|		return be16_bswap(load_u16_unaligned(p));
  ------------------
  |  |  377|  1.51k|#define be16_bswap(v) (CPU_IS_LITTLE_ENDIAN() ? bswap16(v) : (v))
  |  |  ------------------
  |  |  |  |  312|  1.51k|#  define CPU_IS_LITTLE_ENDIAN()  (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (312:35): [True: 1.51k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  476|      0|	else
  477|      0|		return ((u16)p[0] << 8) | p[1];
  478|  1.51k|}
zlib_decompress.c:bswap16:
  330|  1.51k|{
  331|  1.51k|#if defined(__GNUC__) || __has_builtin(__builtin_bswap16)
  332|  1.51k|	return __builtin_bswap16(v);
  333|       |#elif defined(_MSC_VER)
  334|       |	return _byteswap_ushort(v);
  335|       |#else
  336|       |	return (v << 8) | (v >> 8);
  337|       |#endif
  338|  1.51k|}
zlib_decompress.c:load_u16_unaligned:
  436|  1.51k|load_##type##_unaligned(const void *p)				\
  437|  1.51k|{								\
  438|  1.51k|	type v;							\
  439|  1.51k|								\
  440|  1.51k|	MEMCOPY(&v, p, sizeof(v));				\
  ------------------
  |  |  429|  1.51k|#  define MEMCOPY	memcpy
  ------------------
  441|  1.51k|	return v;						\
  442|  1.51k|}								\
zlib_decompress.c:get_unaligned_be32:
  492|  1.51k|{
  493|  1.51k|	if (UNALIGNED_ACCESS_IS_FAST)
  ------------------
  |  |  402|  1.51k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  ------------------
  |  |  |  Branch (402:36): [True: 1.51k, Folded]
  |  |  ------------------
  ------------------
  494|  1.51k|		return be32_bswap(load_u32_unaligned(p));
  ------------------
  |  |  378|  1.51k|#define be32_bswap(v) (CPU_IS_LITTLE_ENDIAN() ? bswap32(v) : (v))
  |  |  ------------------
  |  |  |  |  312|  1.51k|#  define CPU_IS_LITTLE_ENDIAN()  (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (312:35): [True: 1.51k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  495|      0|	else
  496|      0|		return ((u32)p[0] << 24) | ((u32)p[1] << 16) |
  497|      0|			((u32)p[2] << 8) | p[3];
  498|  1.51k|}
zlib_decompress.c:bswap32:
  342|  1.51k|{
  343|  1.51k|#if defined(__GNUC__) || __has_builtin(__builtin_bswap32)
  344|  1.51k|	return __builtin_bswap32(v);
  345|       |#elif defined(_MSC_VER)
  346|       |	return _byteswap_ulong(v);
  347|       |#else
  348|       |	return ((v & 0x000000FF) << 24) |
  349|       |	       ((v & 0x0000FF00) << 8) |
  350|       |	       ((v & 0x00FF0000) >> 8) |
  351|       |	       ((v & 0xFF000000) >> 24);
  352|       |#endif
  353|  1.51k|}
zlib_decompress.c:load_u32_unaligned:
  436|  1.51k|load_##type##_unaligned(const void *p)				\
  437|  1.51k|{								\
  438|  1.51k|	type v;							\
  439|  1.51k|								\
  440|  1.51k|	MEMCOPY(&v, p, sizeof(v));				\
  ------------------
  |  |  429|  1.51k|#  define MEMCOPY	memcpy
  ------------------
  441|  1.51k|	return v;						\
  442|  1.51k|}								\

libdeflate_adler32:
  158|  1.51k|{
  159|  1.51k|	if (buffer == NULL) /* Return initial value. */
  ------------------
  |  Branch (159:6): [True: 0, False: 1.51k]
  ------------------
  160|      0|		return 1;
  161|  1.51k|	return adler32_impl(adler, buffer, len);
  162|  1.51k|}
adler32.c:dispatch_adler32:
  142|      2|{
  143|      2|	adler32_func_t f = arch_select_adler32_func();
  ------------------
  |  |  134|      2|#define arch_select_adler32_func	arch_select_adler32_func
  ------------------
  144|       |
  145|      2|	if (f == NULL)
  ------------------
  |  Branch (145:6): [True: 0, False: 2]
  ------------------
  146|      0|		f = DEFAULT_IMPL;
  ------------------
  |  |  132|      0|#  define DEFAULT_IMPL adler32_generic
  ------------------
  147|       |
  148|      2|	adler32_impl = f;
  149|      2|	return f(adler, p, len);
  150|      2|}

cpu_features.c:disable_cpu_features_for_testing:
   89|      2|{
   90|      2|}

deflate_decompress.c:deflate_decompress_bmi2:
   49|  1.51k|{
   50|  1.51k|	u8 *out_next = out;
   51|  1.51k|	u8 * const out_end = out_next + out_nbytes_avail;
   52|  1.51k|	u8 * const out_fastloop_end =
   53|  1.51k|		out_end - MIN(out_nbytes_avail, FASTLOOP_MAX_BYTES_WRITTEN);
  ------------------
  |  |  294|  1.51k|#define MIN(a, b)		((a) <= (b) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (294:21): [True: 383, False: 1.13k]
  |  |  ------------------
  ------------------
   54|       |
   55|       |	/* Input bitstream state; see deflate_decompress.c for documentation */
   56|  1.51k|	const u8 *in_next = in;
   57|  1.51k|	const u8 * const in_end = in_next + in_nbytes;
   58|  1.51k|	const u8 * const in_fastloop_end =
   59|  1.51k|		in_end - MIN(in_nbytes, FASTLOOP_MAX_BYTES_READ);
  ------------------
  |  |  294|  3.03k|#define MIN(a, b)		((a) <= (b) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (294:21): [True: 0, False: 1.51k]
  |  |  |  Branch (294:29): [True: 1.51k, Folded]
  |  |  |  Branch (294:41): [True: 1.51k, Folded]
  |  |  ------------------
  ------------------
   60|  1.51k|	bitbuf_t bitbuf = 0;
   61|  1.51k|	bitbuf_t saved_bitbuf;
   62|  1.51k|	u32 bitsleft = 0;
   63|  1.51k|	size_t overread_count = 0;
   64|       |
   65|  1.51k|	bool is_final_block;
   66|  1.51k|	unsigned block_type;
   67|  1.51k|	unsigned num_litlen_syms;
   68|  1.51k|	unsigned num_offset_syms;
   69|  1.51k|	bitbuf_t litlen_tablemask;
   70|  1.51k|	u32 entry;
   71|       |
   72|  1.68k|next_block:
   73|       |	/* Starting to read the next block */
   74|  1.68k|	;
   75|       |
   76|  1.68k|	STATIC_ASSERT(CAN_CONSUME(1 + 2 + 5 + 5 + 4 + 3));
  ------------------
  |  |  297|  1.68k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
   77|  1.68k|	REFILL_BITS();
  ------------------
  |  |  236|  1.68k|#define REFILL_BITS()							\
  |  |  237|  1.68k|do {									\
  |  |  238|  1.68k|	if (UNALIGNED_ACCESS_IS_FAST &&					\
  |  |  ------------------
  |  |  |  |  402|  3.37k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 1.68k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  239|  1.68k|	    likely(in_end - in_next >= sizeof(bitbuf_t))) {		\
  |  |  ------------------
  |  |  |  |  217|  1.68k|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 1.68k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|  1.68k|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|  1.68k|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|  1.68k|do {									\
  |  |  |  |  208|  1.68k|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|  1.68k|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|  1.68k|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|  1.68k|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|  1.68k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|  1.68k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 1.68k, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|  1.68k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|  1.68k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 1.68k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  241|  1.68k|	} else {							\
  |  |  242|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (242:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  243|      0|			if (likely(in_next != in_end)) {		\
  |  |  ------------------
  |  |  |  |  217|      0|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  244|      0|				bitbuf |= (bitbuf_t)*in_next++ <<	\
  |  |  245|      0|					  (u8)bitsleft;			\
  |  |  246|      0|			} else {					\
  |  |  247|      0|				overread_count++;			\
  |  |  248|      0|				SAFETY_CHECK(overread_count <=		\
  |  |  ------------------
  |  |  |  |   60|      0|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  |  |  ------------------
  |  |  |  |  |  |  224|      0|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (224:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  249|      0|					     sizeof(bitbuf_t));		\
  |  |  250|      0|			}						\
  |  |  251|      0|			bitsleft += 8;					\
  |  |  252|      0|		}							\
  |  |  253|      0|	}								\
  |  |  254|  1.68k|} while (0)
  |  |  ------------------
  |  |  |  Branch (254:10): [Folded, False: 1.68k]
  |  |  ------------------
  ------------------
   78|       |
   79|       |	/* BFINAL: 1 bit */
   80|  1.68k|	is_final_block = bitbuf & BITMASK(1);
  ------------------
  |  |  109|  1.68k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
   81|       |
   82|       |	/* BTYPE: 2 bits */
   83|  1.68k|	block_type = (bitbuf >> 1) & BITMASK(2);
  ------------------
  |  |  109|  1.68k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
   84|       |
   85|  1.68k|	if (block_type == DEFLATE_BLOCKTYPE_DYNAMIC_HUFFMAN) {
  ------------------
  |  |   11|  1.68k|#define DEFLATE_BLOCKTYPE_DYNAMIC_HUFFMAN	2
  ------------------
  |  Branch (85:6): [True: 1.05k, False: 632]
  ------------------
   86|       |
   87|       |		/* Dynamic Huffman block */
   88|       |
   89|       |		/* The order in which precode lengths are stored */
   90|  1.05k|		static const u8 deflate_precode_lens_permutation[DEFLATE_NUM_PRECODE_SYMS] = {
   91|  1.05k|			16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
   92|  1.05k|		};
   93|       |
   94|  1.05k|		unsigned num_explicit_precode_lens;
   95|  1.05k|		unsigned i;
   96|       |
   97|       |		/* Read the codeword length counts. */
   98|       |
   99|  1.05k|		STATIC_ASSERT(DEFLATE_NUM_LITLEN_SYMS == 257 + BITMASK(5));
  ------------------
  |  |  297|  1.05k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  100|  1.05k|		num_litlen_syms = 257 + ((bitbuf >> 3) & BITMASK(5));
  ------------------
  |  |  109|  1.05k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
  101|       |
  102|  1.05k|		STATIC_ASSERT(DEFLATE_NUM_OFFSET_SYMS == 1 + BITMASK(5));
  ------------------
  |  |  297|  1.05k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  103|  1.05k|		num_offset_syms = 1 + ((bitbuf >> 8) & BITMASK(5));
  ------------------
  |  |  109|  1.05k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
  104|       |
  105|  1.05k|		STATIC_ASSERT(DEFLATE_NUM_PRECODE_SYMS == 4 + BITMASK(4));
  ------------------
  |  |  297|  1.05k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  106|  1.05k|		num_explicit_precode_lens = 4 + ((bitbuf >> 13) & BITMASK(4));
  ------------------
  |  |  109|  1.05k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
  107|       |
  108|  1.05k|		d->static_codes_loaded = false;
  109|       |
  110|       |		/*
  111|       |		 * Read the precode codeword lengths.
  112|       |		 *
  113|       |		 * A 64-bit bitbuffer is just one bit too small to hold the
  114|       |		 * maximum number of precode lens, so to minimize branches we
  115|       |		 * merge one len with the previous fields.
  116|       |		 */
  117|  1.05k|		STATIC_ASSERT(DEFLATE_MAX_PRE_CODEWORD_LEN == (1 << 3) - 1);
  ------------------
  |  |  297|  1.05k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  118|  1.05k|		if (CAN_CONSUME(3 * (DEFLATE_NUM_PRECODE_SYMS - 1))) {
  ------------------
  |  |  151|  1.05k|#define CAN_CONSUME(n)	(CONSUMABLE_NBITS >= (n))
  |  |  ------------------
  |  |  |  |  125|  1.05k|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|  1.05k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|  1.05k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|  1.05k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (151:24): [True: 1.05k, Folded]
  |  |  ------------------
  ------------------
  119|  1.05k|			d->u.precode_lens[deflate_precode_lens_permutation[0]] =
  120|  1.05k|				(bitbuf >> 17) & BITMASK(3);
  ------------------
  |  |  109|  1.05k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
  121|  1.05k|			bitbuf >>= 20;
  122|  1.05k|			bitsleft -= 20;
  123|  1.05k|			REFILL_BITS();
  ------------------
  |  |  236|  1.05k|#define REFILL_BITS()							\
  |  |  237|  1.05k|do {									\
  |  |  238|  1.05k|	if (UNALIGNED_ACCESS_IS_FAST &&					\
  |  |  ------------------
  |  |  |  |  402|  2.10k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 1.05k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  239|  1.05k|	    likely(in_end - in_next >= sizeof(bitbuf_t))) {		\
  |  |  ------------------
  |  |  |  |  217|  1.05k|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 1.05k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|  1.05k|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|  1.05k|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|  1.05k|do {									\
  |  |  |  |  208|  1.05k|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|  1.05k|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|  1.05k|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|  1.05k|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|  1.05k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|  1.05k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 1.05k, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|  1.05k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|  1.05k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 1.05k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  241|  1.05k|	} else {							\
  |  |  242|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (242:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  243|      0|			if (likely(in_next != in_end)) {		\
  |  |  ------------------
  |  |  |  |  217|      0|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  244|      0|				bitbuf |= (bitbuf_t)*in_next++ <<	\
  |  |  245|      0|					  (u8)bitsleft;			\
  |  |  246|      0|			} else {					\
  |  |  247|      0|				overread_count++;			\
  |  |  248|      0|				SAFETY_CHECK(overread_count <=		\
  |  |  ------------------
  |  |  |  |   60|      0|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  |  |  ------------------
  |  |  |  |  |  |  224|      0|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (224:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  249|      0|					     sizeof(bitbuf_t));		\
  |  |  250|      0|			}						\
  |  |  251|      0|			bitsleft += 8;					\
  |  |  252|      0|		}							\
  |  |  253|      0|	}								\
  |  |  254|  1.05k|} while (0)
  |  |  ------------------
  |  |  |  Branch (254:10): [Folded, False: 1.05k]
  |  |  ------------------
  ------------------
  124|  1.05k|			i = 1;
  125|  14.2k|			do {
  126|  14.2k|				d->u.precode_lens[deflate_precode_lens_permutation[i]] =
  127|  14.2k|					bitbuf & BITMASK(3);
  ------------------
  |  |  109|  14.2k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
  128|  14.2k|				bitbuf >>= 3;
  129|  14.2k|				bitsleft -= 3;
  130|  14.2k|			} while (++i < num_explicit_precode_lens);
  ------------------
  |  Branch (130:13): [True: 13.1k, False: 1.05k]
  ------------------
  131|  1.05k|		} else {
  132|      0|			bitbuf >>= 17;
  133|      0|			bitsleft -= 17;
  134|      0|			i = 0;
  135|      0|			do {
  136|      0|				if ((u8)bitsleft < 3)
  ------------------
  |  Branch (136:9): [True: 0, False: 0]
  ------------------
  137|      0|					REFILL_BITS();
  ------------------
  |  |  236|      0|#define REFILL_BITS()							\
  |  |  237|      0|do {									\
  |  |  238|      0|	if (UNALIGNED_ACCESS_IS_FAST &&					\
  |  |  ------------------
  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  239|      0|	    likely(in_end - in_next >= sizeof(bitbuf_t))) {		\
  |  |  ------------------
  |  |  |  |  217|      0|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      0|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|      0|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|      0|do {									\
  |  |  |  |  208|      0|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|      0|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|      0|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|      0|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  241|      0|	} else {							\
  |  |  242|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (242:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  243|      0|			if (likely(in_next != in_end)) {		\
  |  |  ------------------
  |  |  |  |  217|      0|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  244|      0|				bitbuf |= (bitbuf_t)*in_next++ <<	\
  |  |  245|      0|					  (u8)bitsleft;			\
  |  |  246|      0|			} else {					\
  |  |  247|      0|				overread_count++;			\
  |  |  248|      0|				SAFETY_CHECK(overread_count <=		\
  |  |  ------------------
  |  |  |  |   60|      0|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  |  |  ------------------
  |  |  |  |  |  |  224|      0|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (224:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  249|      0|					     sizeof(bitbuf_t));		\
  |  |  250|      0|			}						\
  |  |  251|      0|			bitsleft += 8;					\
  |  |  252|      0|		}							\
  |  |  253|      0|	}								\
  |  |  254|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (254:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  138|      0|				d->u.precode_lens[deflate_precode_lens_permutation[i]] =
  139|      0|					bitbuf & BITMASK(3);
  ------------------
  |  |  109|      0|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
  140|      0|				bitbuf >>= 3;
  141|      0|				bitsleft -= 3;
  142|      0|			} while (++i < num_explicit_precode_lens);
  ------------------
  |  Branch (142:13): [True: 0, False: 0]
  ------------------
  143|      0|		}
  144|  5.77k|		for (; i < DEFLATE_NUM_PRECODE_SYMS; i++)
  ------------------
  |  |   26|  5.77k|#define DEFLATE_NUM_PRECODE_SYMS		19
  ------------------
  |  Branch (144:10): [True: 4.72k, False: 1.05k]
  ------------------
  145|  4.72k|			d->u.precode_lens[deflate_precode_lens_permutation[i]] = 0;
  146|       |
  147|       |		/* Build the decode table for the precode. */
  148|  1.05k|		SAFETY_CHECK(build_precode_decode_table(d));
  ------------------
  |  |   60|  1.05k|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  ------------------
  |  |  |  |  224|  1.05k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (224:26): [True: 0, False: 1.05k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  149|       |
  150|       |		/* Decode the litlen and offset codeword lengths. */
  151|  1.05k|		i = 0;
  152|   163k|		do {
  153|   163k|			unsigned presym;
  154|   163k|			u8 rep_val;
  155|   163k|			unsigned rep_count;
  156|       |
  157|   163k|			if ((u8)bitsleft < DEFLATE_MAX_PRE_CODEWORD_LEN + 7)
  ------------------
  |  |   39|   163k|#define DEFLATE_MAX_PRE_CODEWORD_LEN		7
  ------------------
  |  Branch (157:8): [True: 11.5k, False: 152k]
  ------------------
  158|  11.5k|				REFILL_BITS();
  ------------------
  |  |  236|  11.5k|#define REFILL_BITS()							\
  |  |  237|  11.5k|do {									\
  |  |  238|  11.5k|	if (UNALIGNED_ACCESS_IS_FAST &&					\
  |  |  ------------------
  |  |  |  |  402|  23.0k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 11.5k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  239|  11.5k|	    likely(in_end - in_next >= sizeof(bitbuf_t))) {		\
  |  |  ------------------
  |  |  |  |  217|  11.5k|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 11.5k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|  11.5k|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|  11.5k|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|  11.5k|do {									\
  |  |  |  |  208|  11.5k|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|  11.5k|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|  11.5k|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|  11.5k|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|  11.5k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|  11.5k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 11.5k, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|  11.5k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|  11.5k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 11.5k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  241|  11.5k|	} else {							\
  |  |  242|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (242:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  243|      0|			if (likely(in_next != in_end)) {		\
  |  |  ------------------
  |  |  |  |  217|      0|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  244|      0|				bitbuf |= (bitbuf_t)*in_next++ <<	\
  |  |  245|      0|					  (u8)bitsleft;			\
  |  |  246|      0|			} else {					\
  |  |  247|      0|				overread_count++;			\
  |  |  248|      0|				SAFETY_CHECK(overread_count <=		\
  |  |  ------------------
  |  |  |  |   60|      0|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  |  |  ------------------
  |  |  |  |  |  |  224|      0|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (224:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  249|      0|					     sizeof(bitbuf_t));		\
  |  |  250|      0|			}						\
  |  |  251|      0|			bitsleft += 8;					\
  |  |  252|      0|		}							\
  |  |  253|      0|	}								\
  |  |  254|  11.5k|} while (0)
  |  |  ------------------
  |  |  |  Branch (254:10): [Folded, False: 11.5k]
  |  |  ------------------
  ------------------
  159|       |
  160|       |			/*
  161|       |			 * The code below assumes that the precode decode table
  162|       |			 * doesn't have any subtables.
  163|       |			 */
  164|   163k|			STATIC_ASSERT(PRECODE_TABLEBITS == DEFLATE_MAX_PRE_CODEWORD_LEN);
  ------------------
  |  |  297|   163k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  165|       |
  166|       |			/* Decode the next precode symbol. */
  167|   163k|			entry = d->u.l.precode_decode_table[
  168|   163k|				bitbuf & BITMASK(DEFLATE_MAX_PRE_CODEWORD_LEN)];
  ------------------
  |  |  109|   163k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
  169|   163k|			bitbuf >>= (u8)entry;
  170|   163k|			bitsleft -= entry; /* optimization: subtract full entry */
  171|   163k|			presym = entry >> 16;
  172|       |
  173|   163k|			if (presym < 16) {
  ------------------
  |  Branch (173:8): [True: 150k, False: 13.4k]
  ------------------
  174|       |				/* Explicit codeword length */
  175|   150k|				d->u.l.lens[i++] = presym;
  176|   150k|				continue;
  177|   150k|			}
  178|       |
  179|       |			/* Run-length encoded codeword lengths */
  180|       |
  181|       |			/*
  182|       |			 * Note: we don't need to immediately verify that the
  183|       |			 * repeat count doesn't overflow the number of elements,
  184|       |			 * since we've sized the lens array to have enough extra
  185|       |			 * space to allow for the worst-case overrun (138 zeroes
  186|       |			 * when only 1 length was remaining).
  187|       |			 *
  188|       |			 * In the case of the small repeat counts (presyms 16
  189|       |			 * and 17), it is fastest to always write the maximum
  190|       |			 * number of entries.  That gets rid of branches that
  191|       |			 * would otherwise be required.
  192|       |			 *
  193|       |			 * It is not just because of the numerical order that
  194|       |			 * our checks go in the order 'presym < 16', 'presym ==
  195|       |			 * 16', and 'presym == 17'.  For typical data this is
  196|       |			 * ordered from most frequent to least frequent case.
  197|       |			 */
  198|  13.4k|			STATIC_ASSERT(DEFLATE_MAX_LENS_OVERRUN == 138 - 1);
  ------------------
  |  |  297|  13.4k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  199|       |
  200|  13.4k|			if (presym == 16) {
  ------------------
  |  Branch (200:8): [True: 3.89k, False: 9.54k]
  ------------------
  201|       |				/* Repeat the previous length 3 - 6 times. */
  202|  3.89k|				SAFETY_CHECK(i != 0);
  ------------------
  |  |   60|  3.89k|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  ------------------
  |  |  |  |  224|  3.89k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (224:26): [True: 0, False: 3.89k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  203|  3.89k|				rep_val = d->u.l.lens[i - 1];
  204|  3.89k|				STATIC_ASSERT(3 + BITMASK(2) == 6);
  ------------------
  |  |  297|  3.89k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  205|  3.89k|				rep_count = 3 + (bitbuf & BITMASK(2));
  ------------------
  |  |  109|  3.89k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
  206|  3.89k|				bitbuf >>= 2;
  207|  3.89k|				bitsleft -= 2;
  208|  3.89k|				d->u.l.lens[i + 0] = rep_val;
  209|  3.89k|				d->u.l.lens[i + 1] = rep_val;
  210|  3.89k|				d->u.l.lens[i + 2] = rep_val;
  211|  3.89k|				d->u.l.lens[i + 3] = rep_val;
  212|  3.89k|				d->u.l.lens[i + 4] = rep_val;
  213|  3.89k|				d->u.l.lens[i + 5] = rep_val;
  214|  3.89k|				i += rep_count;
  215|  9.54k|			} else if (presym == 17) {
  ------------------
  |  Branch (215:15): [True: 7.76k, False: 1.78k]
  ------------------
  216|       |				/* Repeat zero 3 - 10 times. */
  217|  7.76k|				STATIC_ASSERT(3 + BITMASK(3) == 10);
  ------------------
  |  |  297|  7.76k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  218|  7.76k|				rep_count = 3 + (bitbuf & BITMASK(3));
  ------------------
  |  |  109|  7.76k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
  219|  7.76k|				bitbuf >>= 3;
  220|  7.76k|				bitsleft -= 3;
  221|  7.76k|				d->u.l.lens[i + 0] = 0;
  222|  7.76k|				d->u.l.lens[i + 1] = 0;
  223|  7.76k|				d->u.l.lens[i + 2] = 0;
  224|  7.76k|				d->u.l.lens[i + 3] = 0;
  225|  7.76k|				d->u.l.lens[i + 4] = 0;
  226|  7.76k|				d->u.l.lens[i + 5] = 0;
  227|  7.76k|				d->u.l.lens[i + 6] = 0;
  228|  7.76k|				d->u.l.lens[i + 7] = 0;
  229|  7.76k|				d->u.l.lens[i + 8] = 0;
  230|  7.76k|				d->u.l.lens[i + 9] = 0;
  231|  7.76k|				i += rep_count;
  232|  7.76k|			} else {
  233|       |				/* Repeat zero 11 - 138 times. */
  234|  1.78k|				STATIC_ASSERT(11 + BITMASK(7) == 138);
  ------------------
  |  |  297|  1.78k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  235|  1.78k|				rep_count = 11 + (bitbuf & BITMASK(7));
  ------------------
  |  |  109|  1.78k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
  236|  1.78k|				bitbuf >>= 7;
  237|  1.78k|				bitsleft -= 7;
  238|  1.78k|				memset(&d->u.l.lens[i], 0,
  239|  1.78k|				       rep_count * sizeof(d->u.l.lens[i]));
  240|  1.78k|				i += rep_count;
  241|  1.78k|			}
  242|   163k|		} while (i < num_litlen_syms + num_offset_syms);
  ------------------
  |  Branch (242:12): [True: 162k, False: 1.05k]
  ------------------
  243|       |
  244|       |		/* Unnecessary, but check this for consistency with zlib. */
  245|  1.05k|		SAFETY_CHECK(i == num_litlen_syms + num_offset_syms);
  ------------------
  |  |   60|  1.05k|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  ------------------
  |  |  |  |  224|  1.05k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (224:26): [True: 0, False: 1.05k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  246|       |
  247|  1.05k|	} else if (block_type == DEFLATE_BLOCKTYPE_UNCOMPRESSED) {
  ------------------
  |  |    9|    632|#define DEFLATE_BLOCKTYPE_UNCOMPRESSED		0
  ------------------
  |  Branch (247:13): [True: 0, False: 632]
  ------------------
  248|      0|		u16 len, nlen;
  249|       |
  250|       |		/*
  251|       |		 * Uncompressed block: copy 'len' bytes literally from the input
  252|       |		 * buffer to the output buffer.
  253|       |		 */
  254|       |
  255|      0|		bitsleft -= 3; /* for BTYPE and BFINAL */
  256|       |
  257|       |		/*
  258|       |		 * Align the bitstream to the next byte boundary.  This means
  259|       |		 * the next byte boundary as if we were reading a byte at a
  260|       |		 * time.  Therefore, we have to rewind 'in_next' by any bytes
  261|       |		 * that have been refilled but not actually consumed yet (not
  262|       |		 * counting overread bytes, which don't increment 'in_next').
  263|       |		 */
  264|      0|		bitsleft = (u8)bitsleft;
  265|      0|		SAFETY_CHECK(overread_count <= (bitsleft >> 3));
  ------------------
  |  |   60|      0|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  ------------------
  |  |  |  |  224|      0|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (224:26): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  266|      0|		in_next -= (bitsleft >> 3) - overread_count;
  267|      0|		overread_count = 0;
  268|      0|		bitbuf = 0;
  269|      0|		bitsleft = 0;
  270|       |
  271|      0|		SAFETY_CHECK(in_end - in_next >= 4);
  ------------------
  |  |   60|      0|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  ------------------
  |  |  |  |  224|      0|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (224:26): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  272|      0|		len = get_unaligned_le16(in_next);
  273|      0|		nlen = get_unaligned_le16(in_next + 2);
  274|      0|		in_next += 4;
  275|       |
  276|      0|		SAFETY_CHECK(len == (u16)~nlen);
  ------------------
  |  |   60|      0|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  ------------------
  |  |  |  |  224|      0|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (224:26): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  277|      0|		if (unlikely(len > out_end - out_next))
  ------------------
  |  |  224|      0|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  278|      0|			return LIBDEFLATE_INSUFFICIENT_SPACE;
  279|      0|		SAFETY_CHECK(len <= in_end - in_next);
  ------------------
  |  |   60|      0|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  ------------------
  |  |  |  |  224|      0|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (224:26): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  280|       |
  281|      0|		memcpy(out_next, in_next, len);
  282|      0|		in_next += len;
  283|      0|		out_next += len;
  284|       |
  285|      0|		goto block_done;
  286|       |
  287|    632|	} else {
  288|    632|		unsigned i;
  289|       |
  290|    632|		SAFETY_CHECK(block_type == DEFLATE_BLOCKTYPE_STATIC_HUFFMAN);
  ------------------
  |  |   60|    632|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  ------------------
  |  |  |  |  224|    632|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (224:26): [True: 0, False: 632]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  291|       |
  292|       |		/*
  293|       |		 * Static Huffman block: build the decode tables for the static
  294|       |		 * codes.  Skip doing so if the tables are already set up from
  295|       |		 * an earlier static block; this speeds up decompression of
  296|       |		 * degenerate input of many empty or very short static blocks.
  297|       |		 *
  298|       |		 * Afterwards, the remainder is the same as decompressing a
  299|       |		 * dynamic Huffman block.
  300|       |		 */
  301|       |
  302|    632|		bitbuf >>= 3; /* for BTYPE and BFINAL */
  303|    632|		bitsleft -= 3;
  304|       |
  305|    632|		if (d->static_codes_loaded)
  ------------------
  |  Branch (305:7): [True: 316, False: 316]
  ------------------
  306|    316|			goto have_decode_tables;
  307|       |
  308|    316|		d->static_codes_loaded = true;
  309|       |
  310|    316|		STATIC_ASSERT(DEFLATE_NUM_LITLEN_SYMS == 288);
  ------------------
  |  |  297|    316|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  311|    316|		STATIC_ASSERT(DEFLATE_NUM_OFFSET_SYMS == 32);
  ------------------
  |  |  297|    316|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  312|       |
  313|  45.8k|		for (i = 0; i < 144; i++)
  ------------------
  |  Branch (313:15): [True: 45.5k, False: 316]
  ------------------
  314|  45.5k|			d->u.l.lens[i] = 8;
  315|  35.7k|		for (; i < 256; i++)
  ------------------
  |  Branch (315:10): [True: 35.3k, False: 316]
  ------------------
  316|  35.3k|			d->u.l.lens[i] = 9;
  317|  7.90k|		for (; i < 280; i++)
  ------------------
  |  Branch (317:10): [True: 7.58k, False: 316]
  ------------------
  318|  7.58k|			d->u.l.lens[i] = 7;
  319|  2.84k|		for (; i < 288; i++)
  ------------------
  |  Branch (319:10): [True: 2.52k, False: 316]
  ------------------
  320|  2.52k|			d->u.l.lens[i] = 8;
  321|       |
  322|  10.4k|		for (; i < 288 + 32; i++)
  ------------------
  |  Branch (322:10): [True: 10.1k, False: 316]
  ------------------
  323|  10.1k|			d->u.l.lens[i] = 5;
  324|       |
  325|    316|		num_litlen_syms = 288;
  326|    316|		num_offset_syms = 32;
  327|    316|	}
  328|       |
  329|       |	/* Decompressing a Huffman block (either dynamic or static) */
  330|       |
  331|  1.37k|	SAFETY_CHECK(build_offset_decode_table(d, num_litlen_syms, num_offset_syms));
  ------------------
  |  |   60|  1.37k|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  ------------------
  |  |  |  |  224|  1.37k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (224:26): [True: 0, False: 1.37k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  332|  1.37k|	SAFETY_CHECK(build_litlen_decode_table(d, num_litlen_syms, num_offset_syms));
  ------------------
  |  |   60|  1.37k|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  ------------------
  |  |  |  |  224|  1.37k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (224:26): [True: 0, False: 1.37k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  333|  1.68k|have_decode_tables:
  334|  1.68k|	litlen_tablemask = BITMASK(d->litlen_tablebits);
  ------------------
  |  |  109|  1.68k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
  335|       |
  336|       |	/*
  337|       |	 * This is the "fastloop" for decoding literals and matches.  It does
  338|       |	 * bounds checks on in_next and out_next in the loop conditions so that
  339|       |	 * additional bounds checks aren't needed inside the loop body.
  340|       |	 *
  341|       |	 * To reduce latency, the bitbuffer is refilled and the next litlen
  342|       |	 * decode table entry is preloaded before each loop iteration.
  343|       |	 */
  344|  1.68k|	if (in_next >= in_fastloop_end || out_next >= out_fastloop_end)
  ------------------
  |  Branch (344:6): [True: 0, False: 1.68k]
  |  Branch (344:36): [True: 383, False: 1.30k]
  ------------------
  345|    383|		goto generic_loop;
  346|  1.30k|	REFILL_BITS_IN_FASTLOOP();
  ------------------
  |  |  260|  1.30k|#define REFILL_BITS_IN_FASTLOOP()					\
  |  |  261|  1.30k|do {									\
  |  |  262|  1.30k|	STATIC_ASSERT(UNALIGNED_ACCESS_IS_FAST ||			\
  |  |  ------------------
  |  |  |  |  297|  1.30k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  |  |  ------------------
  |  |  263|  1.30k|		      FASTLOOP_PRELOADABLE_NBITS == CONSUMABLE_NBITS);	\
  |  |  264|  1.30k|	if (UNALIGNED_ACCESS_IS_FAST) {					\
  |  |  ------------------
  |  |  |  |  402|  1.30k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 1.30k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  265|  1.30k|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|  1.30k|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|  1.30k|do {									\
  |  |  |  |  208|  1.30k|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|  1.30k|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|  1.30k|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|  1.30k|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|  1.30k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|  1.30k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 1.30k, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|  1.30k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|  1.30k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 1.30k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|  1.30k|	} else {							\
  |  |  267|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (267:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  268|      0|			bitbuf |= (bitbuf_t)*in_next++ << (u8)bitsleft;	\
  |  |  269|      0|			bitsleft += 8;					\
  |  |  270|      0|		}							\
  |  |  271|      0|	}								\
  |  |  272|  1.30k|} while (0)
  |  |  ------------------
  |  |  |  Branch (272:10): [Folded, False: 1.30k]
  |  |  ------------------
  ------------------
  347|  1.30k|	entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
  348|   456k|	do {
  349|   456k|		u32 length, offset, lit;
  350|   456k|		const u8 *src;
  351|   456k|		u8 *dst;
  352|       |
  353|       |		/*
  354|       |		 * Consume the bits for the litlen decode table entry.  Save the
  355|       |		 * original bitbuf for later, in case the extra match length
  356|       |		 * bits need to be extracted from it.
  357|       |		 */
  358|   456k|		saved_bitbuf = bitbuf;
  359|   456k|		bitbuf >>= (u8)entry;
  360|   456k|		bitsleft -= entry; /* optimization: subtract full entry */
  361|       |
  362|       |		/*
  363|       |		 * Begin by checking for a "fast" literal, i.e. a literal that
  364|       |		 * doesn't need a subtable.
  365|       |		 */
  366|   456k|		if (entry & HUFFDEC_LITERAL) {
  ------------------
  |  |  420|   456k|#define HUFFDEC_LITERAL			0x80000000
  ------------------
  |  Branch (366:7): [True: 275k, False: 180k]
  ------------------
  367|       |			/*
  368|       |			 * On 64-bit platforms, we decode up to 2 extra fast
  369|       |			 * literals in addition to the primary item, as this
  370|       |			 * increases performance and still leaves enough bits
  371|       |			 * remaining for what follows.  We could actually do 3,
  372|       |			 * assuming LITLEN_TABLEBITS=11, but that actually
  373|       |			 * decreases performance slightly (perhaps by messing
  374|       |			 * with the branch prediction of the conditional refill
  375|       |			 * that happens later while decoding the match offset).
  376|       |			 *
  377|       |			 * Note: the definitions of FASTLOOP_MAX_BYTES_WRITTEN
  378|       |			 * and FASTLOOP_MAX_BYTES_READ need to be updated if the
  379|       |			 * number of extra literals decoded here is changed.
  380|       |			 */
  381|   275k|			if (/* enough bits for 2 fast literals + length + offset preload? */
  382|   275k|			    CAN_CONSUME_AND_THEN_PRELOAD(2 * LITLEN_TABLEBITS +
  ------------------
  |  |  160|   551k|	(CONSUMABLE_NBITS >= (consume_nbits) &&				\
  |  |  ------------------
  |  |  |  |  125|   275k|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|   275k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|   275k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|   275k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (160:3): [True: 0, Folded]
  |  |  ------------------
  |  |  161|   551k|	 FASTLOOP_PRELOADABLE_NBITS >= (consume_nbits) + (preload_nbits))
  |  |  ------------------
  |  |  |  |  136|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  ------------------
  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (161:3): [True: 0, Folded]
  |  |  ------------------
  ------------------
  383|   275k|							 LENGTH_MAXBITS,
  384|   275k|							 OFFSET_TABLEBITS) &&
  385|       |			    /* enough bits for 2 fast literals + slow literal + litlen preload? */
  386|      0|			    CAN_CONSUME_AND_THEN_PRELOAD(2 * LITLEN_TABLEBITS +
  ------------------
  |  |  160|      0|	(CONSUMABLE_NBITS >= (consume_nbits) &&				\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (160:3): [True: 0, Folded]
  |  |  ------------------
  |  |  161|      0|	 FASTLOOP_PRELOADABLE_NBITS >= (consume_nbits) + (preload_nbits))
  |  |  ------------------
  |  |  |  |  136|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  ------------------
  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (161:3): [True: 0, Folded]
  |  |  ------------------
  ------------------
  387|   275k|							 DEFLATE_MAX_LITLEN_CODEWORD_LEN,
  388|   275k|							 LITLEN_TABLEBITS)) {
  389|       |				/* 1st extra fast literal */
  390|   275k|				lit = entry >> 16;
  391|   275k|				entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
  392|   275k|				saved_bitbuf = bitbuf;
  393|   275k|				bitbuf >>= (u8)entry;
  394|   275k|				bitsleft -= entry;
  395|   275k|				*out_next++ = lit;
  396|   275k|				if (entry & HUFFDEC_LITERAL) {
  ------------------
  |  |  420|   275k|#define HUFFDEC_LITERAL			0x80000000
  ------------------
  |  Branch (396:9): [True: 81.3k, False: 194k]
  ------------------
  397|       |					/* 2nd extra fast literal */
  398|  81.3k|					lit = entry >> 16;
  399|  81.3k|					entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
  400|  81.3k|					saved_bitbuf = bitbuf;
  401|  81.3k|					bitbuf >>= (u8)entry;
  402|  81.3k|					bitsleft -= entry;
  403|  81.3k|					*out_next++ = lit;
  404|  81.3k|					if (entry & HUFFDEC_LITERAL) {
  ------------------
  |  |  420|  81.3k|#define HUFFDEC_LITERAL			0x80000000
  ------------------
  |  Branch (404:10): [True: 57.2k, False: 24.0k]
  ------------------
  405|       |						/*
  406|       |						 * Another fast literal, but
  407|       |						 * this one is in lieu of the
  408|       |						 * primary item, so it doesn't
  409|       |						 * count as one of the extras.
  410|       |						 */
  411|  57.2k|						lit = entry >> 16;
  412|  57.2k|						entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
  413|  57.2k|						REFILL_BITS_IN_FASTLOOP();
  ------------------
  |  |  260|  57.2k|#define REFILL_BITS_IN_FASTLOOP()					\
  |  |  261|  57.2k|do {									\
  |  |  262|  57.2k|	STATIC_ASSERT(UNALIGNED_ACCESS_IS_FAST ||			\
  |  |  ------------------
  |  |  |  |  297|  57.2k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  |  |  ------------------
  |  |  263|  57.2k|		      FASTLOOP_PRELOADABLE_NBITS == CONSUMABLE_NBITS);	\
  |  |  264|  57.2k|	if (UNALIGNED_ACCESS_IS_FAST) {					\
  |  |  ------------------
  |  |  |  |  402|  57.2k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 57.2k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  265|  57.2k|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|  57.2k|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|  57.2k|do {									\
  |  |  |  |  208|  57.2k|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|  57.2k|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|  57.2k|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|  57.2k|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|  57.2k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|  57.2k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 57.2k, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|  57.2k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|  57.2k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 57.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|  57.2k|	} else {							\
  |  |  267|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (267:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  268|      0|			bitbuf |= (bitbuf_t)*in_next++ << (u8)bitsleft;	\
  |  |  269|      0|			bitsleft += 8;					\
  |  |  270|      0|		}							\
  |  |  271|      0|	}								\
  |  |  272|  57.2k|} while (0)
  |  |  ------------------
  |  |  |  Branch (272:10): [Folded, False: 57.2k]
  |  |  ------------------
  ------------------
  414|  57.2k|						*out_next++ = lit;
  415|  57.2k|						continue;
  416|  57.2k|					}
  417|  81.3k|				}
  418|   275k|			} else {
  419|       |				/*
  420|       |				 * Decode a literal.  While doing so, preload
  421|       |				 * the next litlen decode table entry and refill
  422|       |				 * the bitbuffer.  To reduce latency, we've
  423|       |				 * arranged for there to be enough "preloadable"
  424|       |				 * bits remaining to do the table preload
  425|       |				 * independently of the refill.
  426|       |				 */
  427|      0|				STATIC_ASSERT(CAN_CONSUME_AND_THEN_PRELOAD(
  ------------------
  |  |  297|      0|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  428|      0|						LITLEN_TABLEBITS, LITLEN_TABLEBITS));
  429|      0|				lit = entry >> 16;
  430|      0|				entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
  431|      0|				REFILL_BITS_IN_FASTLOOP();
  ------------------
  |  |  260|      0|#define REFILL_BITS_IN_FASTLOOP()					\
  |  |  261|      0|do {									\
  |  |  262|      0|	STATIC_ASSERT(UNALIGNED_ACCESS_IS_FAST ||			\
  |  |  ------------------
  |  |  |  |  297|      0|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  |  |  ------------------
  |  |  263|      0|		      FASTLOOP_PRELOADABLE_NBITS == CONSUMABLE_NBITS);	\
  |  |  264|      0|	if (UNALIGNED_ACCESS_IS_FAST) {					\
  |  |  ------------------
  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  265|      0|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|      0|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|      0|do {									\
  |  |  |  |  208|      0|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|      0|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|      0|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|      0|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|      0|	} else {							\
  |  |  267|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (267:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  268|      0|			bitbuf |= (bitbuf_t)*in_next++ << (u8)bitsleft;	\
  |  |  269|      0|			bitsleft += 8;					\
  |  |  270|      0|		}							\
  |  |  271|      0|	}								\
  |  |  272|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (272:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  432|      0|				*out_next++ = lit;
  433|      0|				continue;
  434|      0|			}
  435|   275k|		}
  436|       |
  437|       |		/*
  438|       |		 * It's not a literal entry, so it can be a length entry, a
  439|       |		 * subtable pointer entry, or an end-of-block entry.  Detect the
  440|       |		 * two unlikely cases by testing the HUFFDEC_EXCEPTIONAL flag.
  441|       |		 */
  442|   399k|		if (unlikely(entry & HUFFDEC_EXCEPTIONAL)) {
  ------------------
  |  |  224|   399k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 1.61k, False: 397k]
  |  |  ------------------
  ------------------
  443|       |			/* Subtable pointer or end-of-block entry */
  444|       |
  445|  1.61k|			if (unlikely(entry & HUFFDEC_END_OF_BLOCK))
  ------------------
  |  |  224|  1.61k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 151, False: 1.45k]
  |  |  ------------------
  ------------------
  446|    151|				goto block_done;
  447|       |
  448|       |			/*
  449|       |			 * A subtable is required.  Load and consume the
  450|       |			 * subtable entry.  The subtable entry can be of any
  451|       |			 * type: literal, length, or end-of-block.
  452|       |			 */
  453|  1.45k|			entry = d->u.litlen_decode_table[(entry >> 16) +
  454|  1.45k|				EXTRACT_VARBITS(bitbuf, (entry >> 8) & 0x3F)];
  ------------------
  |  |   38|  1.45k|#  define EXTRACT_VARBITS(word, count)	((word) & BITMASK(count))
  |  |  ------------------
  |  |  |  |  109|  1.45k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  |  |  ------------------
  ------------------
  455|  1.45k|			saved_bitbuf = bitbuf;
  456|  1.45k|			bitbuf >>= (u8)entry;
  457|  1.45k|			bitsleft -= entry;
  458|       |
  459|       |			/*
  460|       |			 * 32-bit platforms that use the byte-at-a-time refill
  461|       |			 * method have to do a refill here for there to always
  462|       |			 * be enough bits to decode a literal that requires a
  463|       |			 * subtable, then preload the next litlen decode table
  464|       |			 * entry; or to decode a match length that requires a
  465|       |			 * subtable, then preload the offset decode table entry.
  466|       |			 */
  467|  1.45k|			if (!CAN_CONSUME_AND_THEN_PRELOAD(DEFLATE_MAX_LITLEN_CODEWORD_LEN,
  ------------------
  |  |  160|  2.91k|	(CONSUMABLE_NBITS >= (consume_nbits) &&				\
  |  |  ------------------
  |  |  |  |  125|  1.45k|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|  1.45k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|  1.45k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|  1.45k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (160:3): [True: 0, Folded]
  |  |  ------------------
  |  |  161|  2.91k|	 FASTLOOP_PRELOADABLE_NBITS >= (consume_nbits) + (preload_nbits))
  |  |  ------------------
  |  |  |  |  136|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  ------------------
  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (161:3): [True: 0, Folded]
  |  |  ------------------
  ------------------
  468|  1.45k|							  LITLEN_TABLEBITS) ||
  469|      0|			    !CAN_CONSUME_AND_THEN_PRELOAD(LENGTH_MAXBITS,
  ------------------
  |  |  160|      0|	(CONSUMABLE_NBITS >= (consume_nbits) &&				\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (160:3): [True: 0, Folded]
  |  |  ------------------
  |  |  161|      0|	 FASTLOOP_PRELOADABLE_NBITS >= (consume_nbits) + (preload_nbits))
  |  |  ------------------
  |  |  |  |  136|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  ------------------
  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (161:3): [True: 0, Folded]
  |  |  ------------------
  ------------------
  470|  1.45k|							  OFFSET_TABLEBITS))
  471|      0|				REFILL_BITS_IN_FASTLOOP();
  ------------------
  |  |  260|      0|#define REFILL_BITS_IN_FASTLOOP()					\
  |  |  261|      0|do {									\
  |  |  262|      0|	STATIC_ASSERT(UNALIGNED_ACCESS_IS_FAST ||			\
  |  |  ------------------
  |  |  |  |  297|      0|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  |  |  ------------------
  |  |  263|      0|		      FASTLOOP_PRELOADABLE_NBITS == CONSUMABLE_NBITS);	\
  |  |  264|      0|	if (UNALIGNED_ACCESS_IS_FAST) {					\
  |  |  ------------------
  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  265|      0|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|      0|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|      0|do {									\
  |  |  |  |  208|      0|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|      0|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|      0|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|      0|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|      0|	} else {							\
  |  |  267|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (267:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  268|      0|			bitbuf |= (bitbuf_t)*in_next++ << (u8)bitsleft;	\
  |  |  269|      0|			bitsleft += 8;					\
  |  |  270|      0|		}							\
  |  |  271|      0|	}								\
  |  |  272|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (272:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  472|  1.45k|			if (entry & HUFFDEC_LITERAL) {
  ------------------
  |  |  420|  1.45k|#define HUFFDEC_LITERAL			0x80000000
  ------------------
  |  Branch (472:8): [True: 1.43k, False: 26]
  ------------------
  473|       |				/* Decode a literal that required a subtable. */
  474|  1.43k|				lit = entry >> 16;
  475|  1.43k|				entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
  476|  1.43k|				REFILL_BITS_IN_FASTLOOP();
  ------------------
  |  |  260|  1.43k|#define REFILL_BITS_IN_FASTLOOP()					\
  |  |  261|  1.43k|do {									\
  |  |  262|  1.43k|	STATIC_ASSERT(UNALIGNED_ACCESS_IS_FAST ||			\
  |  |  ------------------
  |  |  |  |  297|  1.43k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  |  |  ------------------
  |  |  263|  1.43k|		      FASTLOOP_PRELOADABLE_NBITS == CONSUMABLE_NBITS);	\
  |  |  264|  1.43k|	if (UNALIGNED_ACCESS_IS_FAST) {					\
  |  |  ------------------
  |  |  |  |  402|  1.43k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 1.43k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  265|  1.43k|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|  1.43k|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|  1.43k|do {									\
  |  |  |  |  208|  1.43k|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|  1.43k|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|  1.43k|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|  1.43k|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|  1.43k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|  1.43k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 1.43k, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|  1.43k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|  1.43k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 1.43k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|  1.43k|	} else {							\
  |  |  267|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (267:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  268|      0|			bitbuf |= (bitbuf_t)*in_next++ << (u8)bitsleft;	\
  |  |  269|      0|			bitsleft += 8;					\
  |  |  270|      0|		}							\
  |  |  271|      0|	}								\
  |  |  272|  1.43k|} while (0)
  |  |  ------------------
  |  |  |  Branch (272:10): [Folded, False: 1.43k]
  |  |  ------------------
  ------------------
  477|  1.43k|				*out_next++ = lit;
  478|  1.43k|				continue;
  479|  1.43k|			}
  480|     26|			if (unlikely(entry & HUFFDEC_END_OF_BLOCK))
  ------------------
  |  |  224|     26|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 17, False: 9]
  |  |  ------------------
  ------------------
  481|     17|				goto block_done;
  482|       |			/* Else, it's a length that required a subtable. */
  483|     26|		}
  484|       |
  485|       |		/*
  486|       |		 * Decode the match length: the length base value associated
  487|       |		 * with the litlen symbol (which we extract from the decode
  488|       |		 * table entry), plus the extra length bits.  We don't need to
  489|       |		 * consume the extra length bits here, as they were included in
  490|       |		 * the bits consumed by the entry earlier.  We also don't need
  491|       |		 * to check for too-long matches here, as this is inside the
  492|       |		 * fastloop where it's already been verified that the output
  493|       |		 * buffer has enough space remaining to copy a max-length match.
  494|       |		 */
  495|   397k|		length = entry >> 16;
  496|   397k|		length += EXTRACT_VARBITS8(saved_bitbuf, entry) >> (u8)(entry >> 8);
  ------------------
  |  |   41|   397k|#  define EXTRACT_VARBITS8(word, count)	((word) & BITMASK((u8)(count)))
  |  |  ------------------
  |  |  |  |  109|   397k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  |  |  ------------------
  ------------------
  497|       |
  498|       |		/*
  499|       |		 * Decode the match offset.  There are enough "preloadable" bits
  500|       |		 * remaining to preload the offset decode table entry, but a
  501|       |		 * refill might be needed before consuming it.
  502|       |		 */
  503|   397k|		STATIC_ASSERT(CAN_CONSUME_AND_THEN_PRELOAD(LENGTH_MAXFASTBITS,
  ------------------
  |  |  297|   397k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  504|   397k|							   OFFSET_TABLEBITS));
  505|   397k|		entry = d->offset_decode_table[bitbuf & BITMASK(OFFSET_TABLEBITS)];
  ------------------
  |  |  109|   397k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
  506|   397k|		if (CAN_CONSUME_AND_THEN_PRELOAD(OFFSET_MAXBITS,
  ------------------
  |  |  160|   397k|	(CONSUMABLE_NBITS >= (consume_nbits) &&				\
  |  |  ------------------
  |  |  |  |  125|   397k|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|   397k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|   397k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|   397k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (160:3): [True: 0, Folded]
  |  |  ------------------
  |  |  161|   397k|	 FASTLOOP_PRELOADABLE_NBITS >= (consume_nbits) + (preload_nbits))
  |  |  ------------------
  |  |  |  |  136|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  ------------------
  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (161:3): [True: 0, Folded]
  |  |  ------------------
  ------------------
  507|   397k|						 LITLEN_TABLEBITS)) {
  508|       |			/*
  509|       |			 * Decoding a match offset on a 64-bit platform.  We may
  510|       |			 * need to refill once, but then we can decode the whole
  511|       |			 * offset and preload the next litlen table entry.
  512|       |			 */
  513|   397k|			if (unlikely(entry & HUFFDEC_EXCEPTIONAL)) {
  ------------------
  |  |  224|   397k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 309, False: 397k]
  |  |  ------------------
  ------------------
  514|       |				/* Offset codeword requires a subtable */
  515|    309|				if (unlikely((u8)bitsleft < OFFSET_MAXBITS +
  ------------------
  |  |  224|  3.70k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 16, False: 293]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [True: 309, Folded]
  |  |  |  Branch (224:46): [True: 309, Folded]
  |  |  |  Branch (224:46): [Folded, False: 309]
  |  |  ------------------
  ------------------
  516|    309|					     LITLEN_TABLEBITS - PRELOAD_SLACK))
  517|     16|					REFILL_BITS_IN_FASTLOOP();
  ------------------
  |  |  260|     16|#define REFILL_BITS_IN_FASTLOOP()					\
  |  |  261|     16|do {									\
  |  |  262|     16|	STATIC_ASSERT(UNALIGNED_ACCESS_IS_FAST ||			\
  |  |  ------------------
  |  |  |  |  297|     16|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  |  |  ------------------
  |  |  263|     16|		      FASTLOOP_PRELOADABLE_NBITS == CONSUMABLE_NBITS);	\
  |  |  264|     16|	if (UNALIGNED_ACCESS_IS_FAST) {					\
  |  |  ------------------
  |  |  |  |  402|     16|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 16, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  265|     16|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|     16|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|     16|do {									\
  |  |  |  |  208|     16|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|     16|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|     16|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|     16|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|     16|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|     16|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 16, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|     16|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|     16|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 16]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|     16|	} else {							\
  |  |  267|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (267:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  268|      0|			bitbuf |= (bitbuf_t)*in_next++ << (u8)bitsleft;	\
  |  |  269|      0|			bitsleft += 8;					\
  |  |  270|      0|		}							\
  |  |  271|      0|	}								\
  |  |  272|     16|} while (0)
  |  |  ------------------
  |  |  |  Branch (272:10): [Folded, False: 16]
  |  |  ------------------
  ------------------
  518|    309|				bitbuf >>= OFFSET_TABLEBITS;
  ------------------
  |  |  374|    309|#define OFFSET_TABLEBITS	8
  ------------------
  519|    309|				bitsleft -= OFFSET_TABLEBITS;
  ------------------
  |  |  374|    309|#define OFFSET_TABLEBITS	8
  ------------------
  520|    309|				entry = d->offset_decode_table[(entry >> 16) +
  521|    309|					EXTRACT_VARBITS(bitbuf, (entry >> 8) & 0x3F)];
  ------------------
  |  |   38|    309|#  define EXTRACT_VARBITS(word, count)	((word) & BITMASK(count))
  |  |  ------------------
  |  |  |  |  109|    309|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  |  |  ------------------
  ------------------
  522|   397k|			} else if (unlikely((u8)bitsleft < OFFSET_MAXFASTBITS +
  ------------------
  |  |  224|  4.77M|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 215, False: 397k]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [True: 397k, Folded]
  |  |  |  Branch (224:46): [True: 397k, Folded]
  |  |  |  Branch (224:46): [Folded, False: 397k]
  |  |  ------------------
  ------------------
  523|   397k|					    LITLEN_TABLEBITS - PRELOAD_SLACK))
  524|    215|				REFILL_BITS_IN_FASTLOOP();
  ------------------
  |  |  260|    215|#define REFILL_BITS_IN_FASTLOOP()					\
  |  |  261|    215|do {									\
  |  |  262|    215|	STATIC_ASSERT(UNALIGNED_ACCESS_IS_FAST ||			\
  |  |  ------------------
  |  |  |  |  297|    215|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  |  |  ------------------
  |  |  263|    215|		      FASTLOOP_PRELOADABLE_NBITS == CONSUMABLE_NBITS);	\
  |  |  264|    215|	if (UNALIGNED_ACCESS_IS_FAST) {					\
  |  |  ------------------
  |  |  |  |  402|    215|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 215, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  265|    215|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|    215|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|    215|do {									\
  |  |  |  |  208|    215|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|    215|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|    215|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|    215|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|    215|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|    215|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 215, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|    215|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|    215|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 215]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|    215|	} else {							\
  |  |  267|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (267:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  268|      0|			bitbuf |= (bitbuf_t)*in_next++ << (u8)bitsleft;	\
  |  |  269|      0|			bitsleft += 8;					\
  |  |  270|      0|		}							\
  |  |  271|      0|	}								\
  |  |  272|    215|} while (0)
  |  |  ------------------
  |  |  |  Branch (272:10): [Folded, False: 215]
  |  |  ------------------
  ------------------
  525|   397k|		} else {
  526|       |			/* Decoding a match offset on a 32-bit platform */
  527|      0|			REFILL_BITS_IN_FASTLOOP();
  ------------------
  |  |  260|      0|#define REFILL_BITS_IN_FASTLOOP()					\
  |  |  261|      0|do {									\
  |  |  262|      0|	STATIC_ASSERT(UNALIGNED_ACCESS_IS_FAST ||			\
  |  |  ------------------
  |  |  |  |  297|      0|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  |  |  ------------------
  |  |  263|      0|		      FASTLOOP_PRELOADABLE_NBITS == CONSUMABLE_NBITS);	\
  |  |  264|      0|	if (UNALIGNED_ACCESS_IS_FAST) {					\
  |  |  ------------------
  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  265|      0|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|      0|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|      0|do {									\
  |  |  |  |  208|      0|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|      0|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|      0|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|      0|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|      0|	} else {							\
  |  |  267|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (267:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  268|      0|			bitbuf |= (bitbuf_t)*in_next++ << (u8)bitsleft;	\
  |  |  269|      0|			bitsleft += 8;					\
  |  |  270|      0|		}							\
  |  |  271|      0|	}								\
  |  |  272|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (272:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  528|      0|			if (unlikely(entry & HUFFDEC_EXCEPTIONAL)) {
  ------------------
  |  |  224|      0|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  529|       |				/* Offset codeword requires a subtable */
  530|      0|				bitbuf >>= OFFSET_TABLEBITS;
  ------------------
  |  |  374|      0|#define OFFSET_TABLEBITS	8
  ------------------
  531|      0|				bitsleft -= OFFSET_TABLEBITS;
  ------------------
  |  |  374|      0|#define OFFSET_TABLEBITS	8
  ------------------
  532|      0|				entry = d->offset_decode_table[(entry >> 16) +
  533|      0|					EXTRACT_VARBITS(bitbuf, (entry >> 8) & 0x3F)];
  ------------------
  |  |   38|      0|#  define EXTRACT_VARBITS(word, count)	((word) & BITMASK(count))
  |  |  ------------------
  |  |  |  |  109|      0|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  |  |  ------------------
  ------------------
  534|      0|				REFILL_BITS_IN_FASTLOOP();
  ------------------
  |  |  260|      0|#define REFILL_BITS_IN_FASTLOOP()					\
  |  |  261|      0|do {									\
  |  |  262|      0|	STATIC_ASSERT(UNALIGNED_ACCESS_IS_FAST ||			\
  |  |  ------------------
  |  |  |  |  297|      0|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  |  |  ------------------
  |  |  263|      0|		      FASTLOOP_PRELOADABLE_NBITS == CONSUMABLE_NBITS);	\
  |  |  264|      0|	if (UNALIGNED_ACCESS_IS_FAST) {					\
  |  |  ------------------
  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  265|      0|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|      0|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|      0|do {									\
  |  |  |  |  208|      0|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|      0|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|      0|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|      0|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|      0|	} else {							\
  |  |  267|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (267:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  268|      0|			bitbuf |= (bitbuf_t)*in_next++ << (u8)bitsleft;	\
  |  |  269|      0|			bitsleft += 8;					\
  |  |  270|      0|		}							\
  |  |  271|      0|	}								\
  |  |  272|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (272:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  535|       |				/* No further refill needed before extra bits */
  536|      0|				STATIC_ASSERT(CAN_CONSUME(
  ------------------
  |  |  297|      0|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  537|      0|					OFFSET_MAXBITS - OFFSET_TABLEBITS));
  538|      0|			} else {
  539|       |				/* No refill needed before extra bits */
  540|      0|				STATIC_ASSERT(CAN_CONSUME(OFFSET_MAXFASTBITS));
  ------------------
  |  |  297|      0|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  541|      0|			}
  542|      0|		}
  543|   397k|		saved_bitbuf = bitbuf;
  544|   397k|		bitbuf >>= (u8)entry;
  545|   397k|		bitsleft -= entry; /* optimization: subtract full entry */
  546|   397k|		offset = entry >> 16;
  547|   397k|		offset += EXTRACT_VARBITS8(saved_bitbuf, entry) >> (u8)(entry >> 8);
  ------------------
  |  |   41|   397k|#  define EXTRACT_VARBITS8(word, count)	((word) & BITMASK((u8)(count)))
  |  |  ------------------
  |  |  |  |  109|   397k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  |  |  ------------------
  ------------------
  548|       |
  549|       |		/* Validate the match offset; needed even in the fastloop. */
  550|   397k|		SAFETY_CHECK(offset <= out_next - (const u8 *)out);
  ------------------
  |  |   60|   397k|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  ------------------
  |  |  |  |  224|   397k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (224:26): [True: 0, False: 397k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  551|   397k|		src = out_next - offset;
  552|   397k|		dst = out_next;
  553|   397k|		out_next += length;
  554|       |
  555|       |		/*
  556|       |		 * Before starting to issue the instructions to copy the match,
  557|       |		 * refill the bitbuffer and preload the litlen decode table
  558|       |		 * entry for the next loop iteration.  This can increase
  559|       |		 * performance by allowing the latency of the match copy to
  560|       |		 * overlap with these other operations.  To further reduce
  561|       |		 * latency, we've arranged for there to be enough bits remaining
  562|       |		 * to do the table preload independently of the refill, except
  563|       |		 * on 32-bit platforms using the byte-at-a-time refill method.
  564|       |		 */
  565|   397k|		if (!CAN_CONSUME_AND_THEN_PRELOAD(
  ------------------
  |  |  160|   795k|	(CONSUMABLE_NBITS >= (consume_nbits) &&				\
  |  |  ------------------
  |  |  |  |  125|   397k|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|   397k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|   397k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|   397k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (160:3): [True: 0, Folded]
  |  |  |  Branch (160:24): [Folded, False: 397k]
  |  |  ------------------
  |  |  161|   795k|	 FASTLOOP_PRELOADABLE_NBITS >= (consume_nbits) + (preload_nbits))
  |  |  ------------------
  |  |  |  |  136|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  ------------------
  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS : CONSUMABLE_NBITS)
  |  |  |  |  ------------------
  |  |  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (161:3): [True: 0, Folded]
  |  |  |  Branch (161:34): [Folded, False: 0]
  |  |  ------------------
  ------------------
  566|   397k|			MAX(OFFSET_MAXBITS - OFFSET_TABLEBITS,
  567|   397k|			    OFFSET_MAXFASTBITS),
  568|   397k|			LITLEN_TABLEBITS) &&
  569|      0|		    unlikely((u8)bitsleft < LITLEN_TABLEBITS - PRELOAD_SLACK))
  ------------------
  |  |  224|      0|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 0, False: 0]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [True: 0, Folded]
  |  |  |  Branch (224:46): [Folded, False: 0]
  |  |  ------------------
  ------------------
  570|      0|			REFILL_BITS_IN_FASTLOOP();
  ------------------
  |  |  260|      0|#define REFILL_BITS_IN_FASTLOOP()					\
  |  |  261|      0|do {									\
  |  |  262|      0|	STATIC_ASSERT(UNALIGNED_ACCESS_IS_FAST ||			\
  |  |  ------------------
  |  |  |  |  297|      0|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  |  |  ------------------
  |  |  263|      0|		      FASTLOOP_PRELOADABLE_NBITS == CONSUMABLE_NBITS);	\
  |  |  264|      0|	if (UNALIGNED_ACCESS_IS_FAST) {					\
  |  |  ------------------
  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  265|      0|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|      0|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|      0|do {									\
  |  |  |  |  208|      0|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|      0|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|      0|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|      0|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|      0|	} else {							\
  |  |  267|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (267:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  268|      0|			bitbuf |= (bitbuf_t)*in_next++ << (u8)bitsleft;	\
  |  |  269|      0|			bitsleft += 8;					\
  |  |  270|      0|		}							\
  |  |  271|      0|	}								\
  |  |  272|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (272:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  571|   397k|		entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
  572|   397k|		REFILL_BITS_IN_FASTLOOP();
  ------------------
  |  |  260|   397k|#define REFILL_BITS_IN_FASTLOOP()					\
  |  |  261|   397k|do {									\
  |  |  262|   397k|	STATIC_ASSERT(UNALIGNED_ACCESS_IS_FAST ||			\
  |  |  ------------------
  |  |  |  |  297|   397k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  |  |  ------------------
  |  |  263|   397k|		      FASTLOOP_PRELOADABLE_NBITS == CONSUMABLE_NBITS);	\
  |  |  264|   397k|	if (UNALIGNED_ACCESS_IS_FAST) {					\
  |  |  ------------------
  |  |  |  |  402|   397k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 397k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  265|   397k|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|   397k|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|   397k|do {									\
  |  |  |  |  208|   397k|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|   397k|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|   397k|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|   397k|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|   397k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|   397k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 397k, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|   397k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|   397k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 397k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  266|   397k|	} else {							\
  |  |  267|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (267:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  268|      0|			bitbuf |= (bitbuf_t)*in_next++ << (u8)bitsleft;	\
  |  |  269|      0|			bitsleft += 8;					\
  |  |  270|      0|		}							\
  |  |  271|      0|	}								\
  |  |  272|   397k|} while (0)
  |  |  ------------------
  |  |  |  Branch (272:10): [Folded, False: 397k]
  |  |  ------------------
  ------------------
  573|       |
  574|       |		/*
  575|       |		 * Copy the match.  On most CPUs the fastest method is a
  576|       |		 * word-at-a-time copy, unconditionally copying about 5 words
  577|       |		 * since this is enough for most matches without being too much.
  578|       |		 *
  579|       |		 * The normal word-at-a-time copy works for offset >= WORDBYTES,
  580|       |		 * which is most cases.  The case of offset == 1 is also common
  581|       |		 * and is worth optimizing for, since it is just RLE encoding of
  582|       |		 * the previous byte, which is the result of compressing long
  583|       |		 * runs of the same byte.
  584|       |		 *
  585|       |		 * Writing past the match 'length' is allowed here, since it's
  586|       |		 * been ensured there is enough output space left for a slight
  587|       |		 * overrun.  FASTLOOP_MAX_BYTES_WRITTEN needs to be updated if
  588|       |		 * the maximum possible overrun here is changed.
  589|       |		 */
  590|   397k|		if (UNALIGNED_ACCESS_IS_FAST && offset >= WORDBYTES) {
  ------------------
  |  |  402|   795k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  ------------------
  |  |  |  Branch (402:36): [True: 397k, Folded]
  |  |  ------------------
  ------------------
              		if (UNALIGNED_ACCESS_IS_FAST && offset >= WORDBYTES) {
  ------------------
  |  |  125|   397k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  |  Branch (590:35): [True: 363k, False: 34.7k]
  ------------------
  591|   363k|			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|   363k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|   363k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  592|   363k|			src += WORDBYTES;
  ------------------
  |  |  125|   363k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  593|   363k|			dst += WORDBYTES;
  ------------------
  |  |  125|   363k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  594|   363k|			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|   363k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|   363k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  595|   363k|			src += WORDBYTES;
  ------------------
  |  |  125|   363k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  596|   363k|			dst += WORDBYTES;
  ------------------
  |  |  125|   363k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  597|   363k|			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|   363k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|   363k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  598|   363k|			src += WORDBYTES;
  ------------------
  |  |  125|   363k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  599|   363k|			dst += WORDBYTES;
  ------------------
  |  |  125|   363k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  600|   363k|			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|   363k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|   363k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  601|   363k|			src += WORDBYTES;
  ------------------
  |  |  125|   363k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  602|   363k|			dst += WORDBYTES;
  ------------------
  |  |  125|   363k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  603|   363k|			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|   363k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|   363k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  604|   363k|			src += WORDBYTES;
  ------------------
  |  |  125|   363k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  605|   363k|			dst += WORDBYTES;
  ------------------
  |  |  125|   363k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  606|   520k|			while (dst < out_next) {
  ------------------
  |  Branch (606:11): [True: 157k, False: 363k]
  ------------------
  607|   157k|				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|   157k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|   157k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  608|   157k|				src += WORDBYTES;
  ------------------
  |  |  125|   157k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  609|   157k|				dst += WORDBYTES;
  ------------------
  |  |  125|   157k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  610|   157k|				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|   157k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|   157k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  611|   157k|				src += WORDBYTES;
  ------------------
  |  |  125|   157k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  612|   157k|				dst += WORDBYTES;
  ------------------
  |  |  125|   157k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  613|   157k|				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|   157k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|   157k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  614|   157k|				src += WORDBYTES;
  ------------------
  |  |  125|   157k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  615|   157k|				dst += WORDBYTES;
  ------------------
  |  |  125|   157k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  616|   157k|				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|   157k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|   157k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  617|   157k|				src += WORDBYTES;
  ------------------
  |  |  125|   157k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  618|   157k|				dst += WORDBYTES;
  ------------------
  |  |  125|   157k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  619|   157k|				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|   157k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|   157k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  620|   157k|				src += WORDBYTES;
  ------------------
  |  |  125|   157k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  621|   157k|				dst += WORDBYTES;
  ------------------
  |  |  125|   157k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  622|   157k|			}
  623|   363k|		} else if (UNALIGNED_ACCESS_IS_FAST && offset == 1) {
  ------------------
  |  |  402|  69.4k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  ------------------
  |  |  |  Branch (402:36): [True: 34.7k, Folded]
  |  |  ------------------
  ------------------
  |  Branch (623:42): [True: 3.93k, False: 30.8k]
  ------------------
  624|  3.93k|			machine_word_t v;
  625|       |
  626|       |			/*
  627|       |			 * This part tends to get auto-vectorized, so keep it
  628|       |			 * copying a multiple of 16 bytes at a time.
  629|       |			 */
  630|  3.93k|			v = (machine_word_t)0x0101010101010101 * src[0];
  631|  3.93k|			store_word_unaligned(v, dst);
  ------------------
  |  |  458|  3.93k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
  632|  3.93k|			dst += WORDBYTES;
  ------------------
  |  |  125|  3.93k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  633|  3.93k|			store_word_unaligned(v, dst);
  ------------------
  |  |  458|  3.93k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
  634|  3.93k|			dst += WORDBYTES;
  ------------------
  |  |  125|  3.93k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  635|  3.93k|			store_word_unaligned(v, dst);
  ------------------
  |  |  458|  3.93k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
  636|  3.93k|			dst += WORDBYTES;
  ------------------
  |  |  125|  3.93k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  637|  3.93k|			store_word_unaligned(v, dst);
  ------------------
  |  |  458|  3.93k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
  638|  3.93k|			dst += WORDBYTES;
  ------------------
  |  |  125|  3.93k|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  639|  4.07k|			while (dst < out_next) {
  ------------------
  |  Branch (639:11): [True: 140, False: 3.93k]
  ------------------
  640|    140|				store_word_unaligned(v, dst);
  ------------------
  |  |  458|    140|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
  641|    140|				dst += WORDBYTES;
  ------------------
  |  |  125|    140|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  642|    140|				store_word_unaligned(v, dst);
  ------------------
  |  |  458|    140|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
  643|    140|				dst += WORDBYTES;
  ------------------
  |  |  125|    140|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  644|    140|				store_word_unaligned(v, dst);
  ------------------
  |  |  458|    140|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
  645|    140|				dst += WORDBYTES;
  ------------------
  |  |  125|    140|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  646|    140|				store_word_unaligned(v, dst);
  ------------------
  |  |  458|    140|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
  647|    140|				dst += WORDBYTES;
  ------------------
  |  |  125|    140|#define WORDBYTES	((int)sizeof(machine_word_t))
  ------------------
  648|    140|			}
  649|  30.8k|		} else if (UNALIGNED_ACCESS_IS_FAST) {
  ------------------
  |  |  402|  30.8k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  ------------------
  |  |  |  Branch (402:36): [True: 30.8k, Folded]
  |  |  ------------------
  ------------------
  650|  30.8k|			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|  30.8k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|  30.8k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  651|  30.8k|			src += offset;
  652|  30.8k|			dst += offset;
  653|  30.8k|			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|  30.8k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              			store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|  30.8k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  654|  30.8k|			src += offset;
  655|  30.8k|			dst += offset;
  656|  46.0k|			do {
  657|  46.0k|				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|  46.0k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|  46.0k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  658|  46.0k|				src += offset;
  659|  46.0k|				dst += offset;
  660|  46.0k|				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  458|  46.0k|#define store_word_unaligned	store_machine_word_t_unaligned
  ------------------
              				store_word_unaligned(load_word_unaligned(src), dst);
  ------------------
  |  |  457|  46.0k|#define load_word_unaligned	load_machine_word_t_unaligned
  ------------------
  661|  46.0k|				src += offset;
  662|  46.0k|				dst += offset;
  663|  46.0k|			} while (dst < out_next);
  ------------------
  |  Branch (663:13): [True: 15.2k, False: 30.8k]
  ------------------
  664|  30.8k|		} else {
  665|      0|			*dst++ = *src++;
  666|      0|			*dst++ = *src++;
  667|      0|			do {
  668|      0|				*dst++ = *src++;
  669|      0|			} while (dst < out_next);
  ------------------
  |  Branch (669:13): [True: 0, False: 0]
  ------------------
  670|      0|		}
  671|   456k|	} while (in_next < in_fastloop_end && out_next < out_fastloop_end);
  ------------------
  |  Branch (671:11): [True: 456k, False: 116]
  |  Branch (671:40): [True: 455k, False: 1.01k]
  ------------------
  672|       |
  673|       |	/*
  674|       |	 * This is the generic loop for decoding literals and matches.  This
  675|       |	 * handles cases where in_next and out_next are close to the end of
  676|       |	 * their respective buffers.  Usually this loop isn't performance-
  677|       |	 * critical, as most time is spent in the fastloop above instead.  We
  678|       |	 * therefore omit some optimizations here in favor of smaller code.
  679|       |	 */
  680|  1.51k|generic_loop:
  681|   139k|	for (;;) {
  682|   139k|		u32 length, offset;
  683|   139k|		const u8 *src;
  684|   139k|		u8 *dst;
  685|       |
  686|   139k|		REFILL_BITS();
  ------------------
  |  |  236|   139k|#define REFILL_BITS()							\
  |  |  237|   139k|do {									\
  |  |  238|   139k|	if (UNALIGNED_ACCESS_IS_FAST &&					\
  |  |  ------------------
  |  |  |  |  402|   279k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 139k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  239|   139k|	    likely(in_end - in_next >= sizeof(bitbuf_t))) {		\
  |  |  ------------------
  |  |  |  |  217|   139k|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 120k, False: 19.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|   120k|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|   120k|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|   120k|do {									\
  |  |  |  |  208|   120k|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|   120k|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|   120k|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|   120k|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|   120k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|   120k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 120k, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|   120k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|   120k|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 120k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  241|   120k|	} else {							\
  |  |  242|  39.2k|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|  39.2k|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|  39.2k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|  39.2k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 39.2k, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|  39.2k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (242:10): [True: 19.5k, False: 19.6k]
  |  |  ------------------
  |  |  243|  19.5k|			if (likely(in_next != in_end)) {		\
  |  |  ------------------
  |  |  |  |  217|  19.5k|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 10.4k, False: 9.11k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  244|  10.4k|				bitbuf |= (bitbuf_t)*in_next++ <<	\
  |  |  245|  10.4k|					  (u8)bitsleft;			\
  |  |  246|  10.4k|			} else {					\
  |  |  247|  9.11k|				overread_count++;			\
  |  |  248|  9.11k|				SAFETY_CHECK(overread_count <=		\
  |  |  ------------------
  |  |  |  |   60|  9.11k|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  |  |  ------------------
  |  |  |  |  |  |  224|  9.11k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (224:26): [True: 0, False: 9.11k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  249|  9.11k|					     sizeof(bitbuf_t));		\
  |  |  250|  9.11k|			}						\
  |  |  251|  19.5k|			bitsleft += 8;					\
  |  |  252|  19.5k|		}							\
  |  |  253|  19.6k|	}								\
  |  |  254|   139k|} while (0)
  |  |  ------------------
  |  |  |  Branch (254:10): [Folded, False: 139k]
  |  |  ------------------
  ------------------
  687|   139k|		entry = d->u.litlen_decode_table[bitbuf & litlen_tablemask];
  688|   139k|		saved_bitbuf = bitbuf;
  689|   139k|		bitbuf >>= (u8)entry;
  690|   139k|		bitsleft -= entry;
  691|   139k|		if (unlikely(entry & HUFFDEC_SUBTABLE_POINTER)) {
  ------------------
  |  |  224|   139k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 12, False: 139k]
  |  |  ------------------
  ------------------
  692|     12|			entry = d->u.litlen_decode_table[(entry >> 16) +
  693|     12|					EXTRACT_VARBITS(bitbuf, (entry >> 8) & 0x3F)];
  ------------------
  |  |   38|     12|#  define EXTRACT_VARBITS(word, count)	((word) & BITMASK(count))
  |  |  ------------------
  |  |  |  |  109|     12|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  |  |  ------------------
  ------------------
  694|     12|			saved_bitbuf = bitbuf;
  695|     12|			bitbuf >>= (u8)entry;
  696|     12|			bitsleft -= entry;
  697|     12|		}
  698|   139k|		length = entry >> 16;
  699|   139k|		if (entry & HUFFDEC_LITERAL) {
  ------------------
  |  |  420|   139k|#define HUFFDEC_LITERAL			0x80000000
  ------------------
  |  Branch (699:7): [True: 103k, False: 36.4k]
  ------------------
  700|   103k|			if (unlikely(out_next == out_end))
  ------------------
  |  |  224|   103k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 0, False: 103k]
  |  |  ------------------
  ------------------
  701|      0|				return LIBDEFLATE_INSUFFICIENT_SPACE;
  702|   103k|			*out_next++ = length;
  703|   103k|			continue;
  704|   103k|		}
  705|  36.4k|		if (unlikely(entry & HUFFDEC_END_OF_BLOCK))
  ------------------
  |  |  224|  36.4k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 1.51k, False: 34.9k]
  |  |  ------------------
  ------------------
  706|  1.51k|			goto block_done;
  707|  34.9k|		length += EXTRACT_VARBITS8(saved_bitbuf, entry) >> (u8)(entry >> 8);
  ------------------
  |  |   41|  34.9k|#  define EXTRACT_VARBITS8(word, count)	((word) & BITMASK((u8)(count)))
  |  |  ------------------
  |  |  |  |  109|  34.9k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  |  |  ------------------
  ------------------
  708|  34.9k|		if (unlikely(length > out_end - out_next))
  ------------------
  |  |  224|  34.9k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 0, False: 34.9k]
  |  |  ------------------
  ------------------
  709|      0|			return LIBDEFLATE_INSUFFICIENT_SPACE;
  710|       |
  711|  34.9k|		if (!CAN_CONSUME(LENGTH_MAXBITS + OFFSET_MAXBITS))
  ------------------
  |  |  151|  34.9k|#define CAN_CONSUME(n)	(CONSUMABLE_NBITS >= (n))
  |  |  ------------------
  |  |  |  |  125|  34.9k|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|  34.9k|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|  34.9k|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|  34.9k|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (711:7): [Folded, False: 34.9k]
  ------------------
  712|      0|			REFILL_BITS();
  ------------------
  |  |  236|      0|#define REFILL_BITS()							\
  |  |  237|      0|do {									\
  |  |  238|      0|	if (UNALIGNED_ACCESS_IS_FAST &&					\
  |  |  ------------------
  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  239|      0|	    likely(in_end - in_next >= sizeof(bitbuf_t))) {		\
  |  |  ------------------
  |  |  |  |  217|      0|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      0|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|      0|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|      0|do {									\
  |  |  |  |  208|      0|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|      0|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|      0|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|      0|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  241|      0|	} else {							\
  |  |  242|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (242:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  243|      0|			if (likely(in_next != in_end)) {		\
  |  |  ------------------
  |  |  |  |  217|      0|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  244|      0|				bitbuf |= (bitbuf_t)*in_next++ <<	\
  |  |  245|      0|					  (u8)bitsleft;			\
  |  |  246|      0|			} else {					\
  |  |  247|      0|				overread_count++;			\
  |  |  248|      0|				SAFETY_CHECK(overread_count <=		\
  |  |  ------------------
  |  |  |  |   60|      0|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  |  |  ------------------
  |  |  |  |  |  |  224|      0|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (224:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  249|      0|					     sizeof(bitbuf_t));		\
  |  |  250|      0|			}						\
  |  |  251|      0|			bitsleft += 8;					\
  |  |  252|      0|		}							\
  |  |  253|      0|	}								\
  |  |  254|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (254:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  713|  34.9k|		entry = d->offset_decode_table[bitbuf & BITMASK(OFFSET_TABLEBITS)];
  ------------------
  |  |  109|  34.9k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  ------------------
  714|  34.9k|		if (unlikely(entry & HUFFDEC_EXCEPTIONAL)) {
  ------------------
  |  |  224|  34.9k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 16, False: 34.8k]
  |  |  ------------------
  ------------------
  715|     16|			bitbuf >>= OFFSET_TABLEBITS;
  ------------------
  |  |  374|     16|#define OFFSET_TABLEBITS	8
  ------------------
  716|     16|			bitsleft -= OFFSET_TABLEBITS;
  ------------------
  |  |  374|     16|#define OFFSET_TABLEBITS	8
  ------------------
  717|     16|			entry = d->offset_decode_table[(entry >> 16) +
  718|     16|					EXTRACT_VARBITS(bitbuf, (entry >> 8) & 0x3F)];
  ------------------
  |  |   38|     16|#  define EXTRACT_VARBITS(word, count)	((word) & BITMASK(count))
  |  |  ------------------
  |  |  |  |  109|     16|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  |  |  ------------------
  ------------------
  719|     16|			if (!CAN_CONSUME(OFFSET_MAXBITS))
  ------------------
  |  |  151|     16|#define CAN_CONSUME(n)	(CONSUMABLE_NBITS >= (n))
  |  |  ------------------
  |  |  |  |  125|     16|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|     16|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|     16|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|     16|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  |  Branch (719:8): [Folded, False: 16]
  ------------------
  720|      0|				REFILL_BITS();
  ------------------
  |  |  236|      0|#define REFILL_BITS()							\
  |  |  237|      0|do {									\
  |  |  238|      0|	if (UNALIGNED_ACCESS_IS_FAST &&					\
  |  |  ------------------
  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  239|      0|	    likely(in_end - in_next >= sizeof(bitbuf_t))) {		\
  |  |  ------------------
  |  |  |  |  217|      0|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  240|      0|		REFILL_BITS_BRANCHLESS();				\
  |  |  ------------------
  |  |  |  |  206|      0|#define REFILL_BITS_BRANCHLESS()					\
  |  |  |  |  207|      0|do {									\
  |  |  |  |  208|      0|	bitbuf |= get_unaligned_leword(in_next) << (u8)bitsleft;	\
  |  |  |  |  209|      0|	in_next += sizeof(bitbuf_t) - 1;				\
  |  |  |  |  210|      0|	in_next -= (bitsleft >> 3) & 0x7;				\
  |  |  |  |  211|      0|	bitsleft |= MAX_BITSLEFT & ~7;					\
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  212|      0|} while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (212:10): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  241|      0|	} else {							\
  |  |  242|      0|		while ((u8)bitsleft < CONSUMABLE_NBITS) {		\
  |  |  ------------------
  |  |  |  |  125|      0|#define CONSUMABLE_NBITS	(MAX_BITSLEFT - 7)
  |  |  |  |  ------------------
  |  |  |  |  |  |  117|      0|	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  402|      0|#  define UNALIGNED_ACCESS_IS_FAST	1
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (402:36): [True: 0, Folded]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |               	(UNALIGNED_ACCESS_IS_FAST ? BITBUF_NBITS - 1 : BITBUF_NBITS)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  106|      0|#define BITBUF_NBITS	(8 * (int)sizeof(bitbuf_t))
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (242:10): [True: 0, False: 0]
  |  |  ------------------
  |  |  243|      0|			if (likely(in_next != in_end)) {		\
  |  |  ------------------
  |  |  |  |  217|      0|#  define likely(expr)		__builtin_expect(!!(expr), 1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (217:25): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  244|      0|				bitbuf |= (bitbuf_t)*in_next++ <<	\
  |  |  245|      0|					  (u8)bitsleft;			\
  |  |  246|      0|			} else {					\
  |  |  247|      0|				overread_count++;			\
  |  |  248|      0|				SAFETY_CHECK(overread_count <=		\
  |  |  ------------------
  |  |  |  |   60|      0|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  |  |  ------------------
  |  |  |  |  |  |  224|      0|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (224:26): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  249|      0|					     sizeof(bitbuf_t));		\
  |  |  250|      0|			}						\
  |  |  251|      0|			bitsleft += 8;					\
  |  |  252|      0|		}							\
  |  |  253|      0|	}								\
  |  |  254|      0|} while (0)
  |  |  ------------------
  |  |  |  Branch (254:10): [Folded, False: 0]
  |  |  ------------------
  ------------------
  721|     16|		}
  722|  34.9k|		offset = entry >> 16;
  723|  34.9k|		offset += EXTRACT_VARBITS8(bitbuf, entry) >> (u8)(entry >> 8);
  ------------------
  |  |   41|  34.9k|#  define EXTRACT_VARBITS8(word, count)	((word) & BITMASK((u8)(count)))
  |  |  ------------------
  |  |  |  |  109|  34.9k|#define BITMASK(n)	(((bitbuf_t)1 << (n)) - 1)
  |  |  ------------------
  ------------------
  724|  34.9k|		bitbuf >>= (u8)entry;
  725|  34.9k|		bitsleft -= entry;
  726|       |
  727|  34.9k|		SAFETY_CHECK(offset <= out_next - (const u8 *)out);
  ------------------
  |  |   60|  34.9k|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  ------------------
  |  |  |  |  224|  34.9k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (224:26): [True: 0, False: 34.9k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  728|  34.9k|		src = out_next - offset;
  729|  34.9k|		dst = out_next;
  730|  34.9k|		out_next += length;
  731|       |
  732|  34.9k|		STATIC_ASSERT(DEFLATE_MIN_MATCH_LEN == 3);
  ------------------
  |  |  297|  34.9k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  733|  34.9k|		*dst++ = *src++;
  734|  34.9k|		*dst++ = *src++;
  735|   250k|		do {
  736|   250k|			*dst++ = *src++;
  737|   250k|		} while (dst < out_next);
  ------------------
  |  Branch (737:12): [True: 215k, False: 34.9k]
  ------------------
  738|  34.9k|	}
  739|       |
  740|  1.68k|block_done:
  741|       |	/* Finished decoding a block */
  742|       |
  743|  1.68k|	if (!is_final_block)
  ------------------
  |  Branch (743:6): [True: 168, False: 1.51k]
  ------------------
  744|    168|		goto next_block;
  745|       |
  746|       |	/* That was the last block. */
  747|       |
  748|  1.51k|	bitsleft = (u8)bitsleft;
  749|       |
  750|       |	/*
  751|       |	 * If any of the implicit appended zero bytes were consumed (not just
  752|       |	 * refilled) before hitting end of stream, then the data is bad.
  753|       |	 */
  754|  1.51k|	SAFETY_CHECK(overread_count <= (bitsleft >> 3));
  ------------------
  |  |   60|  1.51k|#  define SAFETY_CHECK(expr)	if (unlikely(!(expr))) return LIBDEFLATE_BAD_DATA
  |  |  ------------------
  |  |  |  |  224|  1.51k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (224:26): [True: 0, False: 1.51k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  755|       |
  756|       |	/* Optionally return the actual number of bytes consumed. */
  757|  1.51k|	if (actual_in_nbytes_ret) {
  ------------------
  |  Branch (757:6): [True: 1.51k, False: 0]
  ------------------
  758|       |		/* Don't count bytes that were refilled but not consumed. */
  759|  1.51k|		in_next -= (bitsleft >> 3) - overread_count;
  760|       |
  761|  1.51k|		*actual_in_nbytes_ret = in_next - (u8 *)in;
  762|  1.51k|	}
  763|       |
  764|       |	/* Optionally return the actual number of bytes written. */
  765|  1.51k|	if (actual_out_nbytes_ret) {
  ------------------
  |  Branch (765:6): [True: 1.51k, False: 0]
  ------------------
  766|  1.51k|		*actual_out_nbytes_ret = out_next - (u8 *)out;
  767|  1.51k|	} else {
  768|      0|		if (out_next != out_end)
  ------------------
  |  Branch (768:7): [True: 0, False: 0]
  ------------------
  769|      0|			return LIBDEFLATE_SHORT_OUTPUT;
  770|      0|	}
  771|  1.51k|	return LIBDEFLATE_SUCCESS;
  772|  1.51k|}

libdeflate_deflate_decompress_ex:
 1139|  1.51k|{
 1140|  1.51k|	return decompress_impl(d, in, in_nbytes, out, out_nbytes_avail,
 1141|  1.51k|			       actual_in_nbytes_ret, actual_out_nbytes_ret);
 1142|  1.51k|}
libdeflate_alloc_decompressor_ex:
 1157|      2|{
 1158|      2|	struct libdeflate_decompressor *d;
 1159|       |
 1160|       |	/*
 1161|       |	 * Note: if more fields are added to libdeflate_options, this code will
 1162|       |	 * need to be updated to support both the old and new structs.
 1163|       |	 */
 1164|      2|	if (options->sizeof_options != sizeof(*options))
  ------------------
  |  Branch (1164:6): [True: 0, False: 2]
  ------------------
 1165|      0|		return NULL;
 1166|       |
 1167|      2|	d = (options->malloc_func ? options->malloc_func :
  ------------------
  |  Branch (1167:7): [True: 0, False: 2]
  ------------------
 1168|      2|	     libdeflate_default_malloc_func)(sizeof(*d));
 1169|      2|	if (d == NULL)
  ------------------
  |  Branch (1169:6): [True: 0, False: 2]
  ------------------
 1170|      0|		return NULL;
 1171|       |	/*
 1172|       |	 * Note that only certain parts of the decompressor actually must be
 1173|       |	 * initialized here:
 1174|       |	 *
 1175|       |	 * - 'static_codes_loaded' must be initialized to false.
 1176|       |	 *
 1177|       |	 * - The first half of the main portion of each decode table must be
 1178|       |	 *   initialized to any value, to avoid reading from uninitialized
 1179|       |	 *   memory during table expansion in build_decode_table().  (Although,
 1180|       |	 *   this is really just to avoid warnings with dynamic tools like
 1181|       |	 *   valgrind, since build_decode_table() is guaranteed to initialize
 1182|       |	 *   all entries eventually anyway.)
 1183|       |	 *
 1184|       |	 * - 'free_func' must be set.
 1185|       |	 *
 1186|       |	 * But for simplicity, we currently just zero the whole decompressor.
 1187|       |	 */
 1188|      2|	memset(d, 0, sizeof(*d));
 1189|      2|	d->free_func = options->free_func ?
  ------------------
  |  Branch (1189:17): [True: 0, False: 2]
  ------------------
 1190|      2|		       options->free_func : libdeflate_default_free_func;
 1191|      2|	return d;
 1192|      2|}
libdeflate_alloc_decompressor:
 1196|      2|{
 1197|      2|	static const struct libdeflate_options defaults = {
 1198|      2|		.sizeof_options = sizeof(defaults),
 1199|      2|	};
 1200|      2|	return libdeflate_alloc_decompressor_ex(&defaults);
 1201|      2|}
deflate_decompress.c:dispatch_decomp:
 1110|      2|{
 1111|      2|	decompress_func_t f = arch_select_decompress_func();
  ------------------
  |  |   54|      2|#define arch_select_decompress_func	arch_select_decompress_func
  ------------------
 1112|       |
 1113|      2|	if (f == NULL)
  ------------------
  |  Branch (1113:6): [True: 0, False: 2]
  ------------------
 1114|      0|		f = DEFAULT_IMPL;
  ------------------
  |  | 1092|      0|#  define DEFAULT_IMPL deflate_decompress_default
  ------------------
 1115|       |
 1116|      2|	decompress_impl = f;
 1117|      2|	return f(d, in, in_nbytes, out, out_nbytes_avail,
 1118|      2|		 actual_in_nbytes_ret, actual_out_nbytes_ret);
 1119|      2|}
deflate_decompress.c:build_precode_decode_table:
 1009|  1.05k|{
 1010|       |	/* When you change TABLEBITS, you must change ENOUGH, and vice versa! */
 1011|  1.05k|	STATIC_ASSERT(PRECODE_TABLEBITS == 7 && PRECODE_ENOUGH == 128);
  ------------------
  |  |  297|  1.05k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
 1012|       |
 1013|  1.05k|	STATIC_ASSERT(ARRAY_LEN(precode_decode_results) ==
  ------------------
  |  |  297|  1.05k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
 1014|  1.05k|		      DEFLATE_NUM_PRECODE_SYMS);
 1015|       |
 1016|  1.05k|	return build_decode_table(d->u.l.precode_decode_table,
 1017|  1.05k|				  d->u.precode_lens,
 1018|  1.05k|				  DEFLATE_NUM_PRECODE_SYMS,
  ------------------
  |  |   26|  1.05k|#define DEFLATE_NUM_PRECODE_SYMS		19
  ------------------
 1019|  1.05k|				  precode_decode_results,
 1020|  1.05k|				  PRECODE_TABLEBITS,
  ------------------
  |  |  370|  1.05k|#define PRECODE_TABLEBITS	7
  ------------------
 1021|  1.05k|				  DEFLATE_MAX_PRE_CODEWORD_LEN,
  ------------------
  |  |   39|  1.05k|#define DEFLATE_MAX_PRE_CODEWORD_LEN		7
  ------------------
 1022|  1.05k|				  d->sorted_syms,
 1023|       |				  NULL);
 1024|  1.05k|}
deflate_decompress.c:build_decode_table:
  730|  3.79k|{
  731|  3.79k|	unsigned len_counts[DEFLATE_MAX_CODEWORD_LEN + 1];
  732|  3.79k|	unsigned offsets[DEFLATE_MAX_CODEWORD_LEN + 1];
  733|  3.79k|	unsigned sym;		/* current symbol */
  734|  3.79k|	unsigned codeword;	/* current codeword, bit-reversed */
  735|  3.79k|	unsigned len;		/* current codeword length in bits */
  736|  3.79k|	unsigned count;		/* num codewords remaining with this length */
  737|  3.79k|	u32 codespace_used;	/* codespace used out of '2^max_codeword_len' */
  738|  3.79k|	unsigned cur_table_end; /* end index of current table */
  739|  3.79k|	unsigned subtable_prefix; /* codeword prefix of current subtable */
  740|  3.79k|	unsigned subtable_start;  /* start index of current subtable */
  741|  3.79k|	unsigned subtable_bits;   /* log2 of current subtable length */
  742|       |
  743|       |	/* Count how many codewords have each length, including 0. */
  744|  56.0k|	for (len = 0; len <= max_codeword_len; len++)
  ------------------
  |  Branch (744:16): [True: 52.2k, False: 3.79k]
  ------------------
  745|  52.2k|		len_counts[len] = 0;
  746|   440k|	for (sym = 0; sym < num_syms; sym++)
  ------------------
  |  Branch (746:16): [True: 436k, False: 3.79k]
  ------------------
  747|   436k|		len_counts[lens[sym]]++;
  748|       |
  749|       |	/*
  750|       |	 * Determine the actual maximum codeword length that was used, and
  751|       |	 * decrease table_bits to it if allowed.
  752|       |	 */
  753|  24.9k|	while (max_codeword_len > 1 && len_counts[max_codeword_len] == 0)
  ------------------
  |  Branch (753:9): [True: 24.9k, False: 0]
  |  Branch (753:33): [True: 21.1k, False: 3.79k]
  ------------------
  754|  21.1k|		max_codeword_len--;
  755|  3.79k|	if (table_bits_ret != NULL) {
  ------------------
  |  Branch (755:6): [True: 1.37k, False: 2.42k]
  ------------------
  756|  1.37k|		table_bits = MIN(table_bits, max_codeword_len);
  ------------------
  |  |  294|  1.37k|#define MIN(a, b)		((a) <= (b) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (294:21): [True: 167, False: 1.20k]
  |  |  ------------------
  ------------------
  757|  1.37k|		*table_bits_ret = table_bits;
  758|  1.37k|	}
  759|       |
  760|       |	/*
  761|       |	 * Sort the symbols primarily by increasing codeword length and
  762|       |	 * secondarily by increasing symbol value; or equivalently by their
  763|       |	 * codewords in lexicographic order, since a canonical code is assumed.
  764|       |	 *
  765|       |	 * For efficiency, also compute 'codespace_used' in the same pass over
  766|       |	 * 'len_counts[]' used to build 'offsets[]' for sorting.
  767|       |	 */
  768|       |
  769|       |	/* Ensure that 'codespace_used' cannot overflow. */
  770|  3.79k|	STATIC_ASSERT(sizeof(codespace_used) == 4);
  ------------------
  |  |  297|  3.79k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  771|  3.79k|	STATIC_ASSERT(UINT32_MAX / (1U << (DEFLATE_MAX_CODEWORD_LEN - 1)) >=
  ------------------
  |  |  297|  3.79k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
  772|  3.79k|		      DEFLATE_MAX_NUM_SYMS);
  773|       |
  774|  3.79k|	offsets[0] = 0;
  775|  3.79k|	offsets[1] = len_counts[0];
  776|  3.79k|	codespace_used = 0;
  777|  27.2k|	for (len = 1; len < max_codeword_len; len++) {
  ------------------
  |  Branch (777:16): [True: 23.4k, False: 3.79k]
  ------------------
  778|  23.4k|		offsets[len + 1] = offsets[len] + len_counts[len];
  779|  23.4k|		codespace_used = (codespace_used << 1) + len_counts[len];
  780|  23.4k|	}
  781|  3.79k|	codespace_used = (codespace_used << 1) + len_counts[len];
  782|       |
  783|   440k|	for (sym = 0; sym < num_syms; sym++)
  ------------------
  |  Branch (783:16): [True: 436k, False: 3.79k]
  ------------------
  784|   436k|		sorted_syms[offsets[lens[sym]]++] = sym;
  785|       |
  786|  3.79k|	sorted_syms += offsets[0]; /* Skip unused symbols */
  787|       |
  788|       |	/* lens[] is done being used, so we can write to decode_table[] now. */
  789|       |
  790|       |	/*
  791|       |	 * Check whether the lengths form a complete code (exactly fills the
  792|       |	 * codespace), an incomplete code (doesn't fill the codespace), or an
  793|       |	 * overfull code (overflows the codespace).  A codeword of length 'n'
  794|       |	 * uses proportion '1/(2^n)' of the codespace.  An overfull code is
  795|       |	 * nonsensical, so is considered invalid.  An incomplete code is
  796|       |	 * considered valid only in two specific cases; see below.
  797|       |	 */
  798|       |
  799|       |	/* overfull code? */
  800|  3.79k|	if (unlikely(codespace_used > (1U << max_codeword_len)))
  ------------------
  |  |  224|  3.79k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 0, False: 3.79k]
  |  |  ------------------
  ------------------
  801|      0|		return false;
  802|       |
  803|       |	/* incomplete code? */
  804|  3.79k|	if (unlikely(codespace_used < (1U << max_codeword_len))) {
  ------------------
  |  |  224|  3.79k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 0, False: 3.79k]
  |  |  ------------------
  ------------------
  805|      0|		u32 entry;
  806|      0|		unsigned i;
  807|       |
  808|       |		/*
  809|       |		 * The DEFLATE RFC explicitly allows the offset code to be
  810|       |		 * incomplete in two cases: a code containing just 1 codeword,
  811|       |		 * if that codeword has length 1; and a code containing no
  812|       |		 * codewords.  Note: the list of offset codeword lengths is
  813|       |		 * always nonempty, but lengths of 0 don't count as codewords.
  814|       |		 *
  815|       |		 * The RFC doesn't say whether the same cases are allowed for
  816|       |		 * the litlen and pre codes.  It's actually impossible for no
  817|       |		 * symbols to be used from these codes; however, it's
  818|       |		 * technically possible for only one symbol to be used.  zlib
  819|       |		 * allows 1 codeword for the litlen code, but not the precode.
  820|       |		 * The RFC also doesn't say whether, when there is 1 codeword,
  821|       |		 * that codeword is '0' or '1'.  zlib uses '0'.
  822|       |		 *
  823|       |		 * We accept what zlib accepts, plus a bit more.  First, we
  824|       |		 * don't treat the precode more strictly than the litlen and
  825|       |		 * offset codes.  There's no convincing reason to add a special
  826|       |		 * case for the precode here.
  827|       |		 *
  828|       |		 * Second, we just map each allowed incompete code to a complete
  829|       |		 * code with only real symbols.  To do this, we choose a symbol,
  830|       |		 * either the used symbol (for codes with 1 codeword) or an
  831|       |		 * arbitrary symbol (for empty codes), and give it both
  832|       |		 * codewords '0' and '1'.  zlib instead uses a special ERROR
  833|       |		 * symbol in the part of the codespace the code doesn't use.
  834|       |		 * However, having an ERROR symbol reduces the performance of
  835|       |		 * the Huffman decoder, for no real benefit.  Our approach also
  836|       |		 * avoids having to decide whether '0' or '1' is correct.
  837|       |		 *
  838|       |		 * Like zlib, we still reject all incomplete codes that contain
  839|       |		 * more than 1 codeword or a codeword length greater than 1.
  840|       |		 */
  841|      0|		if (codespace_used == 0) {
  ------------------
  |  Branch (841:7): [True: 0, False: 0]
  ------------------
  842|      0|			sym = 0; /* arbitrary */
  843|      0|		} else {
  844|      0|			if (codespace_used != (1U << (max_codeword_len - 1)) ||
  ------------------
  |  Branch (844:8): [True: 0, False: 0]
  ------------------
  845|      0|			    len_counts[1] != 1)
  ------------------
  |  Branch (845:8): [True: 0, False: 0]
  ------------------
  846|      0|				return false;
  847|      0|			sym = sorted_syms[0];
  848|      0|		}
  849|      0|		entry = make_decode_table_entry(decode_results, sym, 1);
  850|      0|		for (i = 0; i < (1U << table_bits); i++)
  ------------------
  |  Branch (850:15): [True: 0, False: 0]
  ------------------
  851|      0|			decode_table[i] = entry;
  852|      0|		return true;
  853|      0|	}
  854|       |
  855|       |	/*
  856|       |	 * The lengths form a complete code.  Now, enumerate the codewords in
  857|       |	 * lexicographic order and fill the decode table entries for each one.
  858|       |	 *
  859|       |	 * First, process all codewords with len <= table_bits.  Each one gets
  860|       |	 * '2^(table_bits-len)' direct entries in the table.
  861|       |	 *
  862|       |	 * Since DEFLATE uses bit-reversed codewords, these entries aren't
  863|       |	 * consecutive but rather are spaced '2^len' entries apart.  This makes
  864|       |	 * filling them naively somewhat awkward and inefficient, since strided
  865|       |	 * stores are less cache-friendly and preclude the use of word or
  866|       |	 * vector-at-a-time stores to fill multiple entries per instruction.
  867|       |	 *
  868|       |	 * To optimize this, we incrementally double the table size.  When
  869|       |	 * processing codewords with length 'len', the table is treated as
  870|       |	 * having only '2^len' entries, so each codeword uses just one entry.
  871|       |	 * Then, each time 'len' is incremented, the table size is doubled and
  872|       |	 * the first half is copied to the second half.  This significantly
  873|       |	 * improves performance over naively doing strided stores.
  874|       |	 *
  875|       |	 * Note that some entries copied for each table doubling may not have
  876|       |	 * been initialized yet, but it doesn't matter since they're guaranteed
  877|       |	 * to be initialized later (because the Huffman code is complete).
  878|       |	 */
  879|  3.79k|	codeword = 0;
  880|  3.79k|	len = 1;
  881|  12.2k|	while ((count = len_counts[len]) == 0)
  ------------------
  |  Branch (881:9): [True: 8.49k, False: 3.79k]
  ------------------
  882|  8.49k|		len++;
  883|  3.79k|	cur_table_end = 1U << len;
  884|  18.1k|	while (len <= table_bits) {
  ------------------
  |  Branch (884:9): [True: 18.0k, False: 138]
  ------------------
  885|       |		/* Process all 'count' codewords with length 'len' bits. */
  886|   253k|		do {
  887|   253k|			unsigned bit;
  888|       |
  889|       |			/* Fill the first entry for the current codeword. */
  890|   253k|			decode_table[codeword] =
  891|   253k|				make_decode_table_entry(decode_results,
  892|   253k|							*sorted_syms++, len);
  893|       |
  894|   253k|			if (codeword == cur_table_end - 1) {
  ------------------
  |  Branch (894:8): [True: 3.65k, False: 249k]
  ------------------
  895|       |				/* Last codeword (all 1's) */
  896|  7.09k|				for (; len < table_bits; len++) {
  ------------------
  |  Branch (896:12): [True: 3.44k, False: 3.65k]
  ------------------
  897|  3.44k|					memcpy(&decode_table[cur_table_end],
  898|  3.44k|					       decode_table,
  899|  3.44k|					       cur_table_end *
  900|  3.44k|						sizeof(decode_table[0]));
  901|  3.44k|					cur_table_end <<= 1;
  902|  3.44k|				}
  903|  3.65k|				return true;
  904|  3.65k|			}
  905|       |			/*
  906|       |			 * To advance to the lexicographically next codeword in
  907|       |			 * the canonical code, the codeword must be incremented,
  908|       |			 * then 0's must be appended to the codeword as needed
  909|       |			 * to match the next codeword's length.
  910|       |			 *
  911|       |			 * Since the codeword is bit-reversed, appending 0's is
  912|       |			 * a no-op.  However, incrementing it is nontrivial.  To
  913|       |			 * do so efficiently, use the 'bsr' instruction to find
  914|       |			 * the last (highest order) 0 bit in the codeword, set
  915|       |			 * it, and clear any later (higher order) 1 bits.  But
  916|       |			 * 'bsr' actually finds the highest order 1 bit, so to
  917|       |			 * use it first flip all bits in the codeword by XOR'ing
  918|       |			 * it with (1U << len) - 1 == cur_table_end - 1.
  919|       |			 */
  920|   249k|			bit = 1U << bsr32(codeword ^ (cur_table_end - 1));
  921|   249k|			codeword &= bit - 1;
  922|   249k|			codeword |= bit;
  923|   249k|		} while (--count);
  ------------------
  |  Branch (923:12): [True: 235k, False: 14.3k]
  ------------------
  924|       |
  925|       |		/* Advance to the next codeword length. */
  926|  14.9k|		do {
  927|  14.9k|			if (++len <= table_bits) {
  ------------------
  |  Branch (927:8): [True: 14.8k, False: 140]
  ------------------
  928|  14.8k|				memcpy(&decode_table[cur_table_end],
  929|  14.8k|				       decode_table,
  930|  14.8k|				       cur_table_end * sizeof(decode_table[0]));
  931|  14.8k|				cur_table_end <<= 1;
  932|  14.8k|			}
  933|  14.9k|		} while ((count = len_counts[len]) == 0);
  ------------------
  |  Branch (933:12): [True: 621, False: 14.3k]
  ------------------
  934|  14.3k|	}
  935|       |
  936|       |	/* Process codewords with len > table_bits.  These require subtables. */
  937|    138|	cur_table_end = 1U << table_bits;
  938|    138|	subtable_prefix = -1;
  939|    138|	subtable_start = 0;
  940|  1.53k|	for (;;) {
  941|  1.53k|		u32 entry;
  942|  1.53k|		unsigned i;
  943|  1.53k|		unsigned stride;
  944|  1.53k|		unsigned bit;
  945|       |
  946|       |		/*
  947|       |		 * Start a new subtable if the first 'table_bits' bits of the
  948|       |		 * codeword don't match the prefix of the current subtable.
  949|       |		 */
  950|  1.53k|		if ((codeword & ((1U << table_bits) - 1)) != subtable_prefix) {
  ------------------
  |  Branch (950:7): [True: 713, False: 817]
  ------------------
  951|    713|			subtable_prefix = (codeword & ((1U << table_bits) - 1));
  952|    713|			subtable_start = cur_table_end;
  953|       |			/*
  954|       |			 * Calculate the subtable length.  If the codeword has
  955|       |			 * length 'table_bits + n', then the subtable needs
  956|       |			 * '2^n' entries.  But it may need more; if fewer than
  957|       |			 * '2^n' codewords of length 'table_bits + n' remain,
  958|       |			 * then the length will need to be incremented to bring
  959|       |			 * in longer codewords until the subtable can be
  960|       |			 * completely filled.  Note that because the Huffman
  961|       |			 * code is complete, it will always be possible to fill
  962|       |			 * the subtable eventually.
  963|       |			 */
  964|    713|			subtable_bits = len - table_bits;
  965|    713|			codespace_used = count;
  966|    729|			while (codespace_used < (1U << subtable_bits)) {
  ------------------
  |  Branch (966:11): [True: 16, False: 713]
  ------------------
  967|     16|				subtable_bits++;
  968|     16|				codespace_used = (codespace_used << 1) +
  969|     16|					len_counts[table_bits + subtable_bits];
  970|     16|			}
  971|    713|			cur_table_end = subtable_start + (1U << subtable_bits);
  972|       |
  973|       |			/*
  974|       |			 * Create the entry that points from the main table to
  975|       |			 * the subtable.
  976|       |			 */
  977|    713|			decode_table[subtable_prefix] =
  978|    713|				((u32)subtable_start << 16) |
  979|    713|				HUFFDEC_EXCEPTIONAL |
  ------------------
  |  |  423|    713|#define HUFFDEC_EXCEPTIONAL		0x00008000
  ------------------
  980|    713|				HUFFDEC_SUBTABLE_POINTER |
  ------------------
  |  |  426|    713|#define HUFFDEC_SUBTABLE_POINTER	0x00004000
  ------------------
  981|    713|				(subtable_bits << 8) | table_bits;
  982|    713|		}
  983|       |
  984|       |		/* Fill the subtable entries for the current codeword. */
  985|  1.53k|		entry = make_decode_table_entry(decode_results, *sorted_syms++,
  986|  1.53k|						len - table_bits);
  987|  1.53k|		i = subtable_start + (codeword >> table_bits);
  988|  1.53k|		stride = 1U << (len - table_bits);
  989|  1.54k|		do {
  990|  1.54k|			decode_table[i] = entry;
  991|  1.54k|			i += stride;
  992|  1.54k|		} while (i < cur_table_end);
  ------------------
  |  Branch (992:12): [True: 16, False: 1.53k]
  ------------------
  993|       |
  994|       |		/* Advance to the next codeword. */
  995|  1.53k|		if (codeword == (1U << len) - 1) /* last codeword (all 1's)? */
  ------------------
  |  Branch (995:7): [True: 138, False: 1.39k]
  ------------------
  996|    138|			return true;
  997|  1.39k|		bit = 1U << bsr32(codeword ^ ((1U << len) - 1));
  998|  1.39k|		codeword &= bit - 1;
  999|  1.39k|		codeword |= bit;
 1000|  1.39k|		count--;
 1001|  1.41k|		while (count == 0)
  ------------------
  |  Branch (1001:10): [True: 18, False: 1.39k]
  ------------------
 1002|     18|			count = len_counts[++len];
 1003|  1.39k|	}
 1004|    138|}
deflate_decompress.c:make_decode_table_entry:
  389|   254k|{
  390|   254k|	return decode_results[sym] + (len << 8) + len;
  391|   254k|}
deflate_decompress.c:build_offset_decode_table:
 1051|  1.37k|{
 1052|       |	/* When you change TABLEBITS, you must change ENOUGH, and vice versa! */
 1053|  1.37k|	STATIC_ASSERT(OFFSET_TABLEBITS == 8 && OFFSET_ENOUGH == 402);
  ------------------
  |  |  297|  1.37k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
 1054|       |
 1055|  1.37k|	STATIC_ASSERT(ARRAY_LEN(offset_decode_results) ==
  ------------------
  |  |  297|  1.37k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
 1056|  1.37k|		      DEFLATE_NUM_OFFSET_SYMS);
 1057|       |
 1058|  1.37k|	return build_decode_table(d->offset_decode_table,
 1059|  1.37k|				  d->u.l.lens + num_litlen_syms,
 1060|  1.37k|				  num_offset_syms,
 1061|  1.37k|				  offset_decode_results,
 1062|  1.37k|				  OFFSET_TABLEBITS,
  ------------------
  |  |  374|  1.37k|#define OFFSET_TABLEBITS	8
  ------------------
 1063|  1.37k|				  DEFLATE_MAX_OFFSET_CODEWORD_LEN,
  ------------------
  |  |   41|  1.37k|#define DEFLATE_MAX_OFFSET_CODEWORD_LEN		15
  ------------------
 1064|  1.37k|				  d->sorted_syms,
 1065|       |				  NULL);
 1066|  1.37k|}
deflate_decompress.c:build_litlen_decode_table:
 1030|  1.37k|{
 1031|       |	/* When you change TABLEBITS, you must change ENOUGH, and vice versa! */
 1032|  1.37k|	STATIC_ASSERT(LITLEN_TABLEBITS == 11 && LITLEN_ENOUGH == 2342);
  ------------------
  |  |  297|  1.37k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
 1033|       |
 1034|  1.37k|	STATIC_ASSERT(ARRAY_LEN(litlen_decode_results) ==
  ------------------
  |  |  297|  1.37k|#define STATIC_ASSERT(expr)	((void)sizeof(char[1 - 2 * !(expr)]))
  ------------------
 1035|  1.37k|		      DEFLATE_NUM_LITLEN_SYMS);
 1036|       |
 1037|  1.37k|	return build_decode_table(d->u.litlen_decode_table,
 1038|  1.37k|				  d->u.l.lens,
 1039|  1.37k|				  num_litlen_syms,
 1040|  1.37k|				  litlen_decode_results,
 1041|  1.37k|				  LITLEN_TABLEBITS,
  ------------------
  |  |  372|  1.37k|#define LITLEN_TABLEBITS	11
  ------------------
 1042|  1.37k|				  DEFLATE_MAX_LITLEN_CODEWORD_LEN,
  ------------------
  |  |   40|  1.37k|#define DEFLATE_MAX_LITLEN_CODEWORD_LEN		15
  ------------------
 1043|  1.37k|				  d->sorted_syms,
 1044|  1.37k|				  &d->litlen_tablebits);
 1045|  1.37k|}

adler32.c:arch_select_adler32_func:
  107|      2|{
  108|      2|	const u32 features MAYBE_UNUSED = get_x86_cpu_features();
  109|       |
  110|      2|#ifdef adler32_x86_avx512_vl512_vnni
  111|      2|	if ((features & X86_CPU_FEATURE_ZMM) &&
  ------------------
  |  |   46|      2|#define X86_CPU_FEATURE_ZMM		(1 << 5)
  ------------------
  |  Branch (111:6): [True: 0, False: 2]
  ------------------
  112|      0|	    HAVE_AVX512BW(features) && HAVE_AVX512VNNI(features))
  ------------------
  |  |  141|      2|#  define HAVE_AVX512BW(features)	((features) & X86_CPU_FEATURE_AVX512BW)
  |  |  ------------------
  |  |  |  |   47|      0|#define X86_CPU_FEATURE_AVX512BW	(1 << 6)
  |  |  ------------------
  |  |  |  Branch (141:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
              	    HAVE_AVX512BW(features) && HAVE_AVX512VNNI(features))
  ------------------
  |  |  159|      0|#  define HAVE_AVX512VNNI(features)	((features) & X86_CPU_FEATURE_AVX512VNNI)
  |  |  ------------------
  |  |  |  |   50|      0|#define X86_CPU_FEATURE_AVX512VNNI	(1 << 9)
  |  |  ------------------
  |  |  |  Branch (159:37): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  113|      0|		return adler32_x86_avx512_vl512_vnni;
  ------------------
  |  |   96|      0|#  define adler32_x86_avx512_vl512_vnni	adler32_x86_avx512_vl512_vnni
  ------------------
  114|      2|#endif
  115|      2|#ifdef adler32_x86_avx512_vl256_vnni
  116|      2|	if (HAVE_AVX512BW(features) && HAVE_AVX512VL(features) &&
  ------------------
  |  |  141|      4|#  define HAVE_AVX512BW(features)	((features) & X86_CPU_FEATURE_AVX512BW)
  |  |  ------------------
  |  |  |  |   47|      2|#define X86_CPU_FEATURE_AVX512BW	(1 << 6)
  |  |  ------------------
  |  |  |  Branch (141:35): [True: 0, False: 2]
  |  |  ------------------
  ------------------
              	if (HAVE_AVX512BW(features) && HAVE_AVX512VL(features) &&
  ------------------
  |  |  147|      2|#  define HAVE_AVX512VL(features)	((features) & X86_CPU_FEATURE_AVX512VL)
  |  |  ------------------
  |  |  |  |   48|      0|#define X86_CPU_FEATURE_AVX512VL	(1 << 7)
  |  |  ------------------
  |  |  |  Branch (147:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  117|      0|	    HAVE_AVX512VNNI(features))
  ------------------
  |  |  159|      0|#  define HAVE_AVX512VNNI(features)	((features) & X86_CPU_FEATURE_AVX512VNNI)
  |  |  ------------------
  |  |  |  |   50|      0|#define X86_CPU_FEATURE_AVX512VNNI	(1 << 9)
  |  |  ------------------
  |  |  |  Branch (159:37): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  118|      0|		return adler32_x86_avx512_vl256_vnni;
  ------------------
  |  |   84|      0|#  define adler32_x86_avx512_vl256_vnni	adler32_x86_avx512_vl256_vnni
  ------------------
  119|      2|#endif
  120|      2|#ifdef adler32_x86_avx2_vnni
  121|      2|	if (HAVE_AVX2(features) && HAVE_AVXVNNI(features))
  ------------------
  |  |  127|      4|#  define HAVE_AVX2(features)		((features) & X86_CPU_FEATURE_AVX2)
  |  |  ------------------
  |  |  |  |   38|      2|#define X86_CPU_FEATURE_AVX2		(1 << 3)
  |  |  ------------------
  |  |  |  Branch (127:32): [True: 2, False: 0]
  |  |  ------------------
  ------------------
              	if (HAVE_AVX2(features) && HAVE_AVXVNNI(features))
  ------------------
  |  |  165|      2|#  define HAVE_AVXVNNI(features)	((features) & X86_CPU_FEATURE_AVXVNNI)
  |  |  ------------------
  |  |  |  |   51|      2|#define X86_CPU_FEATURE_AVXVNNI		(1 << 10)
  |  |  ------------------
  |  |  |  Branch (165:34): [True: 0, False: 2]
  |  |  ------------------
  ------------------
  122|      0|		return adler32_x86_avx2_vnni;
  ------------------
  |  |   65|      0|#  define adler32_x86_avx2_vnni	adler32_x86_avx2_vnni
  ------------------
  123|      2|#endif
  124|      2|#ifdef adler32_x86_avx2
  125|      2|	if (HAVE_AVX2(features))
  ------------------
  |  |  127|      2|#  define HAVE_AVX2(features)		((features) & X86_CPU_FEATURE_AVX2)
  |  |  ------------------
  |  |  |  |   38|      2|#define X86_CPU_FEATURE_AVX2		(1 << 3)
  |  |  ------------------
  |  |  |  Branch (127:32): [True: 2, False: 0]
  |  |  ------------------
  ------------------
  126|      2|		return adler32_x86_avx2;
  ------------------
  |  |   43|      2|#  define adler32_x86_avx2	adler32_x86_avx2
  ------------------
  127|      0|#endif
  128|      0|#ifdef adler32_x86_sse2
  129|      0|	if (HAVE_SSE2(features))
  ------------------
  |  |  104|      0|#  define HAVE_SSE2(features)		1
  |  |  ------------------
  |  |  |  Branch (104:32): [True: 0, Folded]
  |  |  ------------------
  ------------------
  130|      0|		return adler32_x86_sse2;
  ------------------
  |  |   35|      0|#  define adler32_x86_sse2	adler32_x86_sse2
  ------------------
  131|      0|#endif
  132|      0|	return NULL;
  133|      0|}

adler32.c:adler32_x86_avx2:
  184|  1.51k|{
  185|       |#if USE_VNNI
  186|       |	/* This contains the bytes [VL, VL-1, VL-2, ..., 1]. */
  187|       |	static const u8 _aligned_attribute(VL) raw_mults[VL] = {
  188|       |	#if VL == 64
  189|       |		64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49,
  190|       |		48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33,
  191|       |	#endif
  192|       |	#if VL >= 32
  193|       |		32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17,
  194|       |	#endif
  195|       |		16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,
  196|       |	};
  197|       |	const vec_t ones = VSET1_8(1);
  198|       |#else
  199|       |	/*
  200|       |	 * This contains the 16-bit values [2*VL, 2*VL - 1, 2*VL - 2, ..., 1].
  201|       |	 * For VL==32 the ordering is weird because it has to match the way that
  202|       |	 * vpunpcklbw and vpunpckhbw work on 128-bit lanes separately.
  203|       |	 */
  204|  1.51k|	static const u16 _aligned_attribute(VL) raw_mults[4][VL / 2] = {
  205|       |	#if VL == 16
  206|       |		{ 32, 31, 30, 29, 28, 27, 26, 25 },
  207|       |		{ 24, 23, 22, 21, 20, 19, 18, 17 },
  208|       |		{ 16, 15, 14, 13, 12, 11, 10, 9  },
  209|       |		{ 8,  7,  6,  5,  4,  3,  2,  1  },
  210|       |	#elif VL == 32
  211|       |		{ 64, 63, 62, 61, 60, 59, 58, 57, 48, 47, 46, 45, 44, 43, 42, 41 },
  212|  1.51k|		{ 56, 55, 54, 53, 52, 51, 50, 49, 40, 39, 38, 37, 36, 35, 34, 33 },
  213|  1.51k|		{ 32, 31, 30, 29, 28, 27, 26, 25, 16, 15, 14, 13, 12, 11, 10,  9 },
  214|  1.51k|		{ 24, 23, 22, 21, 20, 19, 18, 17,  8,  7,  6,  5,  4,  3,  2,  1 },
  215|       |	#else
  216|       |	#  error "unsupported parameters"
  217|       |	#endif
  218|  1.51k|	};
  219|  1.51k|	const vec_t mults_a = VLOAD(raw_mults[0]);
  ------------------
  |  |   90|  1.51k|#  define VLOAD(p)		_mm256_load_si256((const void *)(p))
  ------------------
  220|  1.51k|	const vec_t mults_b = VLOAD(raw_mults[1]);
  ------------------
  |  |   90|  1.51k|#  define VLOAD(p)		_mm256_load_si256((const void *)(p))
  ------------------
  221|  1.51k|	const vec_t mults_c = VLOAD(raw_mults[2]);
  ------------------
  |  |   90|  1.51k|#  define VLOAD(p)		_mm256_load_si256((const void *)(p))
  ------------------
  222|  1.51k|	const vec_t mults_d = VLOAD(raw_mults[3]);
  ------------------
  |  |   90|  1.51k|#  define VLOAD(p)		_mm256_load_si256((const void *)(p))
  ------------------
  223|  1.51k|#endif
  224|  1.51k|	const vec_t zeroes = VSETZERO();
  ------------------
  |  |   98|  1.51k|#  define VSETZERO()		_mm256_setzero_si256()
  ------------------
  225|  1.51k|	u32 s1 = adler & 0xFFFF;
  226|  1.51k|	u32 s2 = adler >> 16;
  227|       |
  228|       |	/*
  229|       |	 * If the length is large and the pointer is misaligned, align it.
  230|       |	 * For smaller lengths, just take the misaligned load penalty.
  231|       |	 */
  232|  1.51k|	if (unlikely(len > 65536 && ((uintptr_t)p & (VL-1)))) {
  ------------------
  |  |  224|  1.53k|#  define unlikely(expr)	__builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (224:26): [True: 4, False: 1.51k]
  |  |  |  Branch (224:46): [True: 19, False: 1.49k]
  |  |  |  Branch (224:46): [True: 4, False: 15]
  |  |  ------------------
  ------------------
  233|     64|		do {
  234|     64|			s1 += *p++;
  235|     64|			s2 += s1;
  236|     64|			len--;
  237|     64|		} while ((uintptr_t)p & (VL-1));
  ------------------
  |  |   46|     64|#  define VL			32
  ------------------
  |  Branch (237:12): [True: 60, False: 4]
  ------------------
  238|      4|		s1 %= DIVISOR;
  ------------------
  |  |   31|      4|#define DIVISOR 65521
  ------------------
  239|      4|		s2 %= DIVISOR;
  ------------------
  |  |   31|      4|#define DIVISOR 65521
  ------------------
  240|      4|	}
  241|       |
  242|       |#if USE_VNNI
  243|       |	/*
  244|       |	 * This is Adler-32 using the vpdpbusd instruction from AVX512VNNI or
  245|       |	 * AVX-VNNI.  vpdpbusd multiplies the unsigned bytes of one vector by
  246|       |	 * the signed bytes of another vector and adds the sums in groups of 4
  247|       |	 * to the 32-bit elements of a third vector.  We use it in two ways:
  248|       |	 * multiplying the data bytes by a sequence like 64,63,62,...,1 for
  249|       |	 * calculating part of s2, and multiplying the data bytes by an all-ones
  250|       |	 * sequence 1,1,1,...,1 for calculating s1 and part of s2.  The all-ones
  251|       |	 * trick seems to be faster than the alternative of vpsadbw + vpaddd.
  252|       |	 */
  253|       |	while (len) {
  254|       |		/*
  255|       |		 * Calculate the length of the next data chunk such that s1 and
  256|       |		 * s2 are guaranteed to not exceed UINT32_MAX.
  257|       |		 */
  258|       |		size_t n = MIN(len, MAX_CHUNK_LEN & ~(4*VL - 1));
  259|       |		vec_t mults = VLOAD(raw_mults);
  260|       |		vec_t v_s1 = zeroes;
  261|       |		vec_t v_s2 = zeroes;
  262|       |
  263|       |		s2 += s1 * n;
  264|       |		len -= n;
  265|       |
  266|       |		if (n >= 4*VL) {
  267|       |			vec_t v_s1_b = zeroes;
  268|       |			vec_t v_s1_c = zeroes;
  269|       |			vec_t v_s1_d = zeroes;
  270|       |			vec_t v_s2_b = zeroes;
  271|       |			vec_t v_s2_c = zeroes;
  272|       |			vec_t v_s2_d = zeroes;
  273|       |			vec_t v_s1_sums   = zeroes;
  274|       |			vec_t v_s1_sums_b = zeroes;
  275|       |			vec_t v_s1_sums_c = zeroes;
  276|       |			vec_t v_s1_sums_d = zeroes;
  277|       |			vec_t tmp0, tmp1;
  278|       |
  279|       |			do {
  280|       |				vec_t data_a = VLOADU(p + 0*VL);
  281|       |				vec_t data_b = VLOADU(p + 1*VL);
  282|       |				vec_t data_c = VLOADU(p + 2*VL);
  283|       |				vec_t data_d = VLOADU(p + 3*VL);
  284|       |
  285|       |				/*
  286|       |				 * Workaround for gcc bug where it generates
  287|       |				 * unnecessary move instructions
  288|       |				 * (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107892)
  289|       |				 */
  290|       |			#if GCC_PREREQ(1, 0)
  291|       |				__asm__("" : "+v" (data_a), "+v" (data_b),
  292|       |					     "+v" (data_c), "+v" (data_d));
  293|       |			#endif
  294|       |
  295|       |				v_s2   = VDPBUSD(v_s2,   data_a, mults);
  296|       |				v_s2_b = VDPBUSD(v_s2_b, data_b, mults);
  297|       |				v_s2_c = VDPBUSD(v_s2_c, data_c, mults);
  298|       |				v_s2_d = VDPBUSD(v_s2_d, data_d, mults);
  299|       |
  300|       |				v_s1_sums   = VADD32(v_s1_sums,   v_s1);
  301|       |				v_s1_sums_b = VADD32(v_s1_sums_b, v_s1_b);
  302|       |				v_s1_sums_c = VADD32(v_s1_sums_c, v_s1_c);
  303|       |				v_s1_sums_d = VADD32(v_s1_sums_d, v_s1_d);
  304|       |
  305|       |				v_s1   = VDPBUSD(v_s1,   data_a, ones);
  306|       |				v_s1_b = VDPBUSD(v_s1_b, data_b, ones);
  307|       |				v_s1_c = VDPBUSD(v_s1_c, data_c, ones);
  308|       |				v_s1_d = VDPBUSD(v_s1_d, data_d, ones);
  309|       |
  310|       |				/* Same gcc bug workaround.  See above */
  311|       |			#if GCC_PREREQ(1, 0) && !defined(ARCH_X86_32)
  312|       |				__asm__("" : "+v" (v_s2), "+v" (v_s2_b),
  313|       |					     "+v" (v_s2_c), "+v" (v_s2_d),
  314|       |					     "+v" (v_s1_sums),
  315|       |					     "+v" (v_s1_sums_b),
  316|       |					     "+v" (v_s1_sums_c),
  317|       |					     "+v" (v_s1_sums_d),
  318|       |					     "+v" (v_s1), "+v" (v_s1_b),
  319|       |					     "+v" (v_s1_c), "+v" (v_s1_d));
  320|       |			#endif
  321|       |				p += 4*VL;
  322|       |				n -= 4*VL;
  323|       |			} while (n >= 4*VL);
  324|       |
  325|       |			/*
  326|       |			 * Reduce into v_s1 and v_s2 as follows:
  327|       |			 *
  328|       |			 * v_s2 = v_s2 + v_s2_b + v_s2_c + v_s2_d +
  329|       |			 *	  (4*VL)*(v_s1_sums   + v_s1_sums_b +
  330|       |			 *		  v_s1_sums_c + v_s1_sums_d) +
  331|       |			 *	  (3*VL)*v_s1 + (2*VL)*v_s1_b + VL*v_s1_c
  332|       |			 * v_s1 = v_s1 + v_s1_b + v_s1_c + v_s1_d
  333|       |			 */
  334|       |			tmp0 = VADD32(v_s1, v_s1_b);
  335|       |			tmp1 = VADD32(v_s1, v_s1_c);
  336|       |			v_s1_sums = VADD32_4X(v_s1_sums, v_s1_sums_b,
  337|       |					      v_s1_sums_c, v_s1_sums_d);
  338|       |			v_s1 = VADD32_3X(tmp0, v_s1_c, v_s1_d);
  339|       |			v_s2 = VADD32_7X(VSLL32(v_s1_sums, LOG2_VL + 2),
  340|       |					 VSLL32(tmp0, LOG2_VL + 1),
  341|       |					 VSLL32(tmp1, LOG2_VL),
  342|       |					 v_s2, v_s2_b, v_s2_c, v_s2_d);
  343|       |		}
  344|       |
  345|       |		/* Process the last 0 <= n < 4*VL bytes of the chunk. */
  346|       |		if (n >= 2*VL) {
  347|       |			const vec_t data_a = VLOADU(p + 0*VL);
  348|       |			const vec_t data_b = VLOADU(p + 1*VL);
  349|       |
  350|       |			v_s2 = VADD32(v_s2, VSLL32(v_s1, LOG2_VL + 1));
  351|       |			v_s1 = VDPBUSD(v_s1, data_a, ones);
  352|       |			v_s1 = VDPBUSD(v_s1, data_b, ones);
  353|       |			v_s2 = VDPBUSD(v_s2, data_a, VSET1_8(VL));
  354|       |			v_s2 = VDPBUSD(v_s2, data_a, mults);
  355|       |			v_s2 = VDPBUSD(v_s2, data_b, mults);
  356|       |			p += 2*VL;
  357|       |			n -= 2*VL;
  358|       |		}
  359|       |		if (n) {
  360|       |			/* Process the last 0 < n < 2*VL bytes of the chunk. */
  361|       |			vec_t data;
  362|       |
  363|       |			v_s2 = VADD32(v_s2, VMULLO32(v_s1, VSET1_32(n)));
  364|       |
  365|       |			mults = VADD8(mults, VSET1_8((int)n - VL));
  366|       |			if (n > VL) {
  367|       |				data = VLOADU(p);
  368|       |				v_s1 = VDPBUSD(v_s1, data, ones);
  369|       |				v_s2 = VDPBUSD(v_s2, data, mults);
  370|       |				p += VL;
  371|       |				n -= VL;
  372|       |				mults = VADD8(mults, VSET1_8(-VL));
  373|       |			}
  374|       |			/*
  375|       |			 * Process the last 0 < n <= VL bytes of the chunk.
  376|       |			 * Utilize a masked load if it's available.
  377|       |			 */
  378|       |		#if USE_AVX512
  379|       |			data = VMASKZ_LOADU((mask_t)-1 >> (VL - n), p);
  380|       |		#else
  381|       |			data = zeroes;
  382|       |			memcpy(&data, p, n);
  383|       |		#endif
  384|       |			v_s1 = VDPBUSD(v_s1, data, ones);
  385|       |			v_s2 = VDPBUSD(v_s2, data, mults);
  386|       |			p += n;
  387|       |		}
  388|       |
  389|       |		reduce_to_32bits(v_s1, v_s2, &s1, &s2);
  390|       |		s1 %= DIVISOR;
  391|       |		s2 %= DIVISOR;
  392|       |	}
  393|       |#else /* USE_VNNI */
  394|       |	/*
  395|       |	 * This is Adler-32 for SSE2 and AVX2.
  396|       |	 *
  397|       |	 * To horizontally sum bytes, use psadbw + paddd, where one of the
  398|       |	 * arguments to psadbw is all-zeroes.
  399|       |	 *
  400|       |	 * For the s2 contribution from (2*VL - i)*data[i] for each of the 2*VL
  401|       |	 * bytes of each iteration of the inner loop, use punpck{l,h}bw + paddw
  402|       |	 * to sum, for each i across iterations, byte i into a corresponding
  403|       |	 * 16-bit counter in v_byte_sums_*.  After the inner loop, use pmaddwd
  404|       |	 * to multiply each counter by (2*VL - i), then add the products to s2.
  405|       |	 *
  406|       |	 * An alternative implementation would use pmaddubsw and pmaddwd in the
  407|       |	 * inner loop to do (2*VL - i)*data[i] directly and add the products in
  408|       |	 * groups of 4 to 32-bit counters.  However, on average that approach
  409|       |	 * seems to be slower than the current approach which delays the
  410|       |	 * multiplications.  Also, pmaddubsw requires SSSE3; the current
  411|       |	 * approach keeps the implementation aligned between SSE2 and AVX2.
  412|       |	 *
  413|       |	 * The inner loop processes 2*VL bytes per iteration.  Increasing this
  414|       |	 * to 4*VL doesn't seem to be helpful here.
  415|       |	 */
  416|  5.03k|	while (len) {
  ------------------
  |  Branch (416:9): [True: 3.52k, False: 1.51k]
  ------------------
  417|       |		/*
  418|       |		 * Calculate the length of the next data chunk such that s1 and
  419|       |		 * s2 are guaranteed to not exceed UINT32_MAX, and every
  420|       |		 * v_byte_sums_* counter is guaranteed to not exceed INT16_MAX.
  421|       |		 * It's INT16_MAX, not UINT16_MAX, because v_byte_sums_* are
  422|       |		 * used with pmaddwd which does signed multiplication.  In the
  423|       |		 * SSE2 case this limits chunks to 4096 bytes instead of 5536.
  424|       |		 */
  425|  3.52k|		size_t n = MIN(len, MIN(2 * VL * (INT16_MAX / UINT8_MAX),
  ------------------
  |  |  294|  7.04k|#define MIN(a, b)		((a) <= (b) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (294:21): [True: 1.51k, False: 2.00k]
  |  |  |  Branch (294:29): [Folded, False: 3.52k]
  |  |  |  Branch (294:41): [Folded, False: 2.00k]
  |  |  ------------------
  ------------------
  426|  3.52k|					MAX_CHUNK_LEN) & ~(2*VL - 1));
  427|  3.52k|		len -= n;
  428|       |
  429|  3.52k|		if (n >= 2*VL) {
  ------------------
  |  |   46|  3.52k|#  define VL			32
  ------------------
  |  Branch (429:7): [True: 3.46k, False: 56]
  ------------------
  430|  3.46k|			vec_t v_s1 = zeroes;
  ------------------
  |  |   79|  3.46k|#  define vec_t			__m256i
  ------------------
  431|  3.46k|			vec_t v_s1_sums = zeroes;
  ------------------
  |  |   79|  3.46k|#  define vec_t			__m256i
  ------------------
  432|  3.46k|			vec_t v_byte_sums_a = zeroes;
  ------------------
  |  |   79|  3.46k|#  define vec_t			__m256i
  ------------------
  433|  3.46k|			vec_t v_byte_sums_b = zeroes;
  ------------------
  |  |   79|  3.46k|#  define vec_t			__m256i
  ------------------
  434|  3.46k|			vec_t v_byte_sums_c = zeroes;
  ------------------
  |  |   79|  3.46k|#  define vec_t			__m256i
  ------------------
  435|  3.46k|			vec_t v_byte_sums_d = zeroes;
  ------------------
  |  |   79|  3.46k|#  define vec_t			__m256i
  ------------------
  436|  3.46k|			vec_t v_s2;
  ------------------
  |  |   79|  3.46k|#  define vec_t			__m256i
  ------------------
  437|       |
  438|  3.46k|			s2 += s1 * (n & ~(2*VL - 1));
  ------------------
  |  |   46|  3.46k|#  define VL			32
  ------------------
  439|       |
  440|   195k|			do {
  441|   195k|				vec_t data_a = VLOADU(p + 0*VL);
  ------------------
  |  |   79|   195k|#  define vec_t			__m256i
  ------------------
              				vec_t data_a = VLOADU(p + 0*VL);
  ------------------
  |  |   91|   195k|#  define VLOADU(p)		_mm256_loadu_si256((const void *)(p))
  ------------------
  442|   195k|				vec_t data_b = VLOADU(p + 1*VL);
  ------------------
  |  |   79|   195k|#  define vec_t			__m256i
  ------------------
              				vec_t data_b = VLOADU(p + 1*VL);
  ------------------
  |  |   91|   195k|#  define VLOADU(p)		_mm256_loadu_si256((const void *)(p))
  ------------------
  443|       |
  444|   195k|				v_s1_sums = VADD32(v_s1_sums, v_s1);
  ------------------
  |  |   84|   195k|#  define VADD32(a, b)		_mm256_add_epi32((a), (b))
  ------------------
  445|   195k|				v_byte_sums_a = VADD16(v_byte_sums_a,
  ------------------
  |  |   83|   195k|#  define VADD16(a, b)		_mm256_add_epi16((a), (b))
  ------------------
  446|   195k|						       VUNPACKLO8(data_a, zeroes));
  447|   195k|				v_byte_sums_b = VADD16(v_byte_sums_b,
  ------------------
  |  |   83|   195k|#  define VADD16(a, b)		_mm256_add_epi16((a), (b))
  ------------------
  448|   195k|						       VUNPACKHI8(data_a, zeroes));
  449|   195k|				v_byte_sums_c = VADD16(v_byte_sums_c,
  ------------------
  |  |   83|   195k|#  define VADD16(a, b)		_mm256_add_epi16((a), (b))
  ------------------
  450|   195k|						       VUNPACKLO8(data_b, zeroes));
  451|   195k|				v_byte_sums_d = VADD16(v_byte_sums_d,
  ------------------
  |  |   83|   195k|#  define VADD16(a, b)		_mm256_add_epi16((a), (b))
  ------------------
  452|   195k|						       VUNPACKHI8(data_b, zeroes));
  453|   195k|				v_s1 = VADD32(v_s1,
  ------------------
  |  |   84|   195k|#  define VADD32(a, b)		_mm256_add_epi32((a), (b))
  ------------------
  454|   195k|					      VADD32(VSAD8(data_a, zeroes),
  455|   195k|						     VSAD8(data_b, zeroes)));
  456|       |				/*
  457|       |				 * Workaround for gcc bug where it generates
  458|       |				 * unnecessary move instructions
  459|       |				 * (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107892)
  460|       |				 */
  461|       |			#if GCC_PREREQ(1, 0)
  462|       |				__asm__("" : "+x" (v_s1), "+x" (v_s1_sums),
  463|       |					     "+x" (v_byte_sums_a),
  464|       |					     "+x" (v_byte_sums_b),
  465|       |					     "+x" (v_byte_sums_c),
  466|       |					     "+x" (v_byte_sums_d));
  467|       |			#endif
  468|   195k|				p += 2*VL;
  ------------------
  |  |   46|   195k|#  define VL			32
  ------------------
  469|   195k|				n -= 2*VL;
  ------------------
  |  |   46|   195k|#  define VL			32
  ------------------
  470|   195k|			} while (n >= 2*VL);
  ------------------
  |  |   46|   195k|#  define VL			32
  ------------------
  |  Branch (470:13): [True: 192k, False: 3.46k]
  ------------------
  471|       |
  472|       |			/*
  473|       |			 * Calculate v_s2 as (2*VL)*v_s1_sums +
  474|       |			 * [2*VL, 2*VL - 1, 2*VL - 2, ..., 1] * v_byte_sums.
  475|       |			 * Then update s1 and s2 from v_s1 and v_s2.
  476|       |			 */
  477|  3.46k|			v_s2 = VADD32_5X(VSLL32(v_s1_sums, LOG2_VL + 1),
  ------------------
  |  |  128|  3.46k|#define VADD32_5X(a, b, c, d, e) VADD32((a), VADD32_4X((b), (c), (d), (e)))
  |  |  ------------------
  |  |  |  |   84|  3.46k|#  define VADD32(a, b)		_mm256_add_epi32((a), (b))
  |  |  ------------------
  ------------------
  478|  3.46k|					 VMADD16(v_byte_sums_a, mults_a),
  479|  3.46k|					 VMADD16(v_byte_sums_b, mults_b),
  480|  3.46k|					 VMADD16(v_byte_sums_c, mults_c),
  481|  3.46k|					 VMADD16(v_byte_sums_d, mults_d));
  482|  3.46k|			reduce_to_32bits(v_s1, v_s2, &s1, &s2);
  ------------------
  |  |  180|  3.46k|#define reduce_to_32bits	ADD_SUFFIX(reduce_to_32bits)
  |  |  ------------------
  |  |  |  |  104|  3.46k|#define ADD_SUFFIX(name)	CONCAT(name, SUFFIX)
  |  |  |  |  ------------------
  |  |  |  |  |  |  103|  3.46k|#define CONCAT(a, b)		CONCAT_IMPL(a, b)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  102|  3.46k|#define CONCAT_IMPL(a, b)	a##b
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  483|  3.46k|		}
  484|       |		/*
  485|       |		 * Process the last 0 <= n < 2*VL bytes of the chunk using
  486|       |		 * scalar instructions and reduce s1 and s2 mod DIVISOR.
  487|       |		 */
  488|  3.52k|		ADLER32_CHUNK(s1, s2, p, n);
  ------------------
  |  |   75|  3.52k|#define ADLER32_CHUNK(s1, s2, p, n)					\
  |  |   76|  3.52k|do {									\
  |  |   77|  3.52k|	if (n >= 4) {							\
  |  |  ------------------
  |  |  |  Branch (77:6): [True: 1.28k, False: 2.23k]
  |  |  ------------------
  |  |   78|  1.28k|		u32 s1_sum = 0;						\
  |  |   79|  1.28k|		u32 byte_0_sum = 0;					\
  |  |   80|  1.28k|		u32 byte_1_sum = 0;					\
  |  |   81|  1.28k|		u32 byte_2_sum = 0;					\
  |  |   82|  1.28k|		u32 byte_3_sum = 0;					\
  |  |   83|  1.28k|									\
  |  |   84|  11.0k|		do {							\
  |  |   85|  11.0k|			s1_sum += s1;					\
  |  |   86|  11.0k|			s1 += p[0] + p[1] + p[2] + p[3];		\
  |  |   87|  11.0k|			byte_0_sum += p[0];				\
  |  |   88|  11.0k|			byte_1_sum += p[1];				\
  |  |   89|  11.0k|			byte_2_sum += p[2];				\
  |  |   90|  11.0k|			byte_3_sum += p[3];				\
  |  |   91|  11.0k|			p += 4;						\
  |  |   92|  11.0k|			n -= 4;						\
  |  |   93|  11.0k|		} while (n >= 4);					\
  |  |  ------------------
  |  |  |  Branch (93:12): [True: 9.80k, False: 1.28k]
  |  |  ------------------
  |  |   94|  1.28k|		s2 += (4 * (s1_sum + byte_0_sum)) + (3 * byte_1_sum) +	\
  |  |   95|  1.28k|		      (2 * byte_2_sum) + byte_3_sum;			\
  |  |   96|  1.28k|	}								\
  |  |   97|  5.74k|	for (; n; n--, p++) {						\
  |  |  ------------------
  |  |  |  Branch (97:9): [True: 2.22k, False: 3.52k]
  |  |  ------------------
  |  |   98|  2.22k|		s1 += *p;						\
  |  |   99|  2.22k|		s2 += s1;						\
  |  |  100|  2.22k|	}								\
  |  |  101|  3.52k|	s1 %= DIVISOR;							\
  |  |  ------------------
  |  |  |  |   31|  3.52k|#define DIVISOR 65521
  |  |  ------------------
  |  |  102|  3.52k|	s2 %= DIVISOR;							\
  |  |  ------------------
  |  |  |  |   31|  3.52k|#define DIVISOR 65521
  |  |  ------------------
  |  |  103|  3.52k|} while (0)
  |  |  ------------------
  |  |  |  Branch (103:10): [Folded, False: 3.52k]
  |  |  ------------------
  ------------------
  489|  3.52k|	}
  490|  1.51k|#endif /* !USE_VNNI */
  491|  1.51k|	return (s2 << 16) | s1;
  492|  1.51k|}
adler32.c:reduce_to_32bits_avx2:
  136|  3.46k|{
  137|  3.46k|	__m128i v_s1_128, v_s2_128;
  138|       |#if VL == 16
  139|       |	{
  140|       |		v_s1_128 = v_s1;
  141|       |		v_s2_128 = v_s2;
  142|       |	}
  143|       |#else
  144|  3.46k|	{
  145|  3.46k|		__m256i v_s1_256, v_s2_256;
  146|  3.46k|	#if VL == 32
  147|  3.46k|		v_s1_256 = v_s1;
  148|  3.46k|		v_s2_256 = v_s2;
  149|       |	#else
  150|       |		/* Reduce 512 bits to 256 bits. */
  151|       |		v_s1_256 = _mm256_add_epi32(_mm512_extracti64x4_epi64(v_s1, 0),
  152|       |					    _mm512_extracti64x4_epi64(v_s1, 1));
  153|       |		v_s2_256 = _mm256_add_epi32(_mm512_extracti64x4_epi64(v_s2, 0),
  154|       |					    _mm512_extracti64x4_epi64(v_s2, 1));
  155|       |	#endif
  156|       |		/* Reduce 256 bits to 128 bits. */
  157|  3.46k|		v_s1_128 = _mm_add_epi32(_mm256_extracti128_si256(v_s1_256, 0),
  158|  3.46k|					 _mm256_extracti128_si256(v_s1_256, 1));
  159|  3.46k|		v_s2_128 = _mm_add_epi32(_mm256_extracti128_si256(v_s2_256, 0),
  160|  3.46k|					 _mm256_extracti128_si256(v_s2_256, 1));
  161|  3.46k|	}
  162|  3.46k|#endif
  163|       |
  164|       |	/*
  165|       |	 * Reduce 128 bits to 32 bits.
  166|       |	 *
  167|       |	 * If the bytes were summed into v_s1 using psadbw + paddd, then ignore
  168|       |	 * the odd-indexed elements of v_s1_128 since they are zero.
  169|       |	 */
  170|       |#if USE_VNNI
  171|       |	v_s1_128 = _mm_add_epi32(v_s1_128, _mm_shuffle_epi32(v_s1_128, 0x31));
  172|       |#endif
  173|  3.46k|	v_s2_128 = _mm_add_epi32(v_s2_128, _mm_shuffle_epi32(v_s2_128, 0x31));
  174|  3.46k|	v_s1_128 = _mm_add_epi32(v_s1_128, _mm_shuffle_epi32(v_s1_128, 0x02));
  175|  3.46k|	v_s2_128 = _mm_add_epi32(v_s2_128, _mm_shuffle_epi32(v_s2_128, 0x02));
  176|       |
  177|  3.46k|	*s1_p += (u32)_mm_cvtsi128_si32(v_s1_128);
  178|  3.46k|	*s2_p += (u32)_mm_cvtsi128_si32(v_s2_128);
  179|  3.46k|}

libdeflate_init_x86_cpu_features:
  141|      2|{
  142|      2|	u32 max_leaf;
  143|      2|	u32 manufacturer[3];
  144|      2|	u32 family, model;
  145|      2|	u32 a, b, c, d;
  146|      2|	u64 xcr0 = 0;
  147|      2|	u32 features = 0;
  148|       |
  149|       |	/* EAX=0: Highest Function Parameter and Manufacturer ID */
  150|      2|	cpuid(0, 0, &max_leaf, &manufacturer[0], &manufacturer[2],
  151|      2|	      &manufacturer[1]);
  152|      2|	if (max_leaf < 1)
  ------------------
  |  Branch (152:6): [True: 0, False: 2]
  ------------------
  153|      0|		goto out;
  154|       |
  155|       |	/* EAX=1: Processor Info and Feature Bits */
  156|      2|	cpuid(1, 0, &a, &b, &c, &d);
  157|      2|	family = (a >> 8) & 0xf;
  158|      2|	model = (a >> 4) & 0xf;
  159|      2|	if (family == 6 || family == 0xf)
  ------------------
  |  Branch (159:6): [True: 0, False: 2]
  |  Branch (159:21): [True: 2, False: 0]
  ------------------
  160|      2|		model += (a >> 12) & 0xf0;
  161|      2|	if (family == 0xf)
  ------------------
  |  Branch (161:6): [True: 2, False: 0]
  ------------------
  162|      2|		family += (a >> 20) & 0xff;
  163|      2|	if (d & (1 << 26))
  ------------------
  |  Branch (163:6): [True: 2, False: 0]
  ------------------
  164|      2|		features |= X86_CPU_FEATURE_SSE2;
  ------------------
  |  |   35|      2|#define X86_CPU_FEATURE_SSE2		(1 << 0)
  ------------------
  165|       |	/*
  166|       |	 * No known CPUs have pclmulqdq without sse4.1, so in practice code
  167|       |	 * targeting pclmulqdq can use sse4.1 instructions.  But to be safe,
  168|       |	 * explicitly check for both the pclmulqdq and sse4.1 bits.
  169|       |	 */
  170|      2|	if ((c & (1 << 1)) && (c & (1 << 19)))
  ------------------
  |  Branch (170:6): [True: 2, False: 0]
  |  Branch (170:24): [True: 2, False: 0]
  ------------------
  171|      2|		features |= X86_CPU_FEATURE_PCLMULQDQ;
  ------------------
  |  |   36|      2|#define X86_CPU_FEATURE_PCLMULQDQ	(1 << 1)
  ------------------
  172|      2|	if (c & (1 << 27))
  ------------------
  |  Branch (172:6): [True: 2, False: 0]
  ------------------
  173|      2|		xcr0 = read_xcr(0);
  174|      2|	if ((c & (1 << 28)) && ((xcr0 & 0x6) == 0x6))
  ------------------
  |  Branch (174:6): [True: 2, False: 0]
  |  Branch (174:25): [True: 2, False: 0]
  ------------------
  175|      2|		features |= X86_CPU_FEATURE_AVX;
  ------------------
  |  |   37|      2|#define X86_CPU_FEATURE_AVX		(1 << 2)
  ------------------
  176|       |
  177|      2|	if (max_leaf < 7)
  ------------------
  |  Branch (177:6): [True: 0, False: 2]
  ------------------
  178|      0|		goto out;
  179|       |
  180|       |	/* EAX=7, ECX=0: Extended Features */
  181|      2|	cpuid(7, 0, &a, &b, &c, &d);
  182|      2|	if (b & (1 << 8))
  ------------------
  |  Branch (182:6): [True: 2, False: 0]
  ------------------
  183|      2|		features |= X86_CPU_FEATURE_BMI2;
  ------------------
  |  |   39|      2|#define X86_CPU_FEATURE_BMI2		(1 << 4)
  ------------------
  184|      2|	if ((xcr0 & 0x6) == 0x6) {
  ------------------
  |  Branch (184:6): [True: 2, False: 0]
  ------------------
  185|      2|		if (b & (1 << 5))
  ------------------
  |  Branch (185:7): [True: 2, False: 0]
  ------------------
  186|      2|			features |= X86_CPU_FEATURE_AVX2;
  ------------------
  |  |   38|      2|#define X86_CPU_FEATURE_AVX2		(1 << 3)
  ------------------
  187|      2|		if (c & (1 << 10))
  ------------------
  |  Branch (187:7): [True: 0, False: 2]
  ------------------
  188|      0|			features |= X86_CPU_FEATURE_VPCLMULQDQ;
  ------------------
  |  |   49|      0|#define X86_CPU_FEATURE_VPCLMULQDQ	(1 << 8)
  ------------------
  189|      2|	}
  190|      2|	if (os_supports_avx512(xcr0)) {
  ------------------
  |  Branch (190:6): [True: 0, False: 2]
  ------------------
  191|      0|		if (allow_512bit_vectors(manufacturer, family, model))
  ------------------
  |  Branch (191:7): [True: 0, False: 0]
  ------------------
  192|      0|			features |= X86_CPU_FEATURE_ZMM;
  ------------------
  |  |   46|      0|#define X86_CPU_FEATURE_ZMM		(1 << 5)
  ------------------
  193|      0|		if (b & (1 << 30))
  ------------------
  |  Branch (193:7): [True: 0, False: 0]
  ------------------
  194|      0|			features |= X86_CPU_FEATURE_AVX512BW;
  ------------------
  |  |   47|      0|#define X86_CPU_FEATURE_AVX512BW	(1 << 6)
  ------------------
  195|      0|		if (b & (1U << 31))
  ------------------
  |  Branch (195:7): [True: 0, False: 0]
  ------------------
  196|      0|			features |= X86_CPU_FEATURE_AVX512VL;
  ------------------
  |  |   48|      0|#define X86_CPU_FEATURE_AVX512VL	(1 << 7)
  ------------------
  197|      0|		if (c & (1 << 11))
  ------------------
  |  Branch (197:7): [True: 0, False: 0]
  ------------------
  198|      0|			features |= X86_CPU_FEATURE_AVX512VNNI;
  ------------------
  |  |   50|      0|#define X86_CPU_FEATURE_AVX512VNNI	(1 << 9)
  ------------------
  199|      0|	}
  200|       |
  201|       |	/* EAX=7, ECX=1: Extended Features */
  202|      2|	cpuid(7, 1, &a, &b, &c, &d);
  203|      2|	if ((a & (1 << 4)) && ((xcr0 & 0x6) == 0x6))
  ------------------
  |  Branch (203:6): [True: 0, False: 2]
  |  Branch (203:24): [True: 0, False: 0]
  ------------------
  204|      0|		features |= X86_CPU_FEATURE_AVXVNNI;
  ------------------
  |  |   51|      0|#define X86_CPU_FEATURE_AVXVNNI		(1 << 10)
  ------------------
  205|       |
  206|      2|out:
  207|      2|	disable_cpu_features_for_testing(&features, x86_cpu_feature_table,
  208|      2|					 ARRAY_LEN(x86_cpu_feature_table));
  ------------------
  |  |  293|      2|#define ARRAY_LEN(A)		(sizeof(A) / sizeof((A)[0]))
  ------------------
  209|       |
  210|      2|	libdeflate_x86_cpu_features = features | X86_CPU_FEATURES_KNOWN;
  ------------------
  |  |   55|      2|#  define X86_CPU_FEATURES_KNOWN	(1U << 31)
  ------------------
  211|      2|}
cpu_features.c:cpuid:
   37|      8|{
   38|       |#ifdef _MSC_VER
   39|       |	int result[4];
   40|       |
   41|       |	__cpuidex(result, leaf, subleaf);
   42|       |	*a = result[0];
   43|       |	*b = result[1];
   44|       |	*c = result[2];
   45|       |	*d = result[3];
   46|       |#else
   47|      8|	__asm__ volatile("cpuid" : "=a" (*a), "=b" (*b), "=c" (*c), "=d" (*d)
   48|      8|			 : "a" (leaf), "c" (subleaf));
   49|      8|#endif
   50|      8|}
cpu_features.c:read_xcr:
   55|      2|{
   56|       |#ifdef _MSC_VER
   57|       |	return _xgetbv(index);
   58|       |#else
   59|      2|	u32 d, a;
   60|       |
   61|       |	/*
   62|       |	 * Execute the "xgetbv" instruction.  Old versions of binutils do not
   63|       |	 * recognize this instruction, so list the raw bytes instead.
   64|       |	 *
   65|       |	 * This must be 'volatile' to prevent this code from being moved out
   66|       |	 * from under the check for OSXSAVE.
   67|       |	 */
   68|      2|	__asm__ volatile(".byte 0x0f, 0x01, 0xd0" :
   69|      2|			 "=d" (d), "=a" (a) : "c" (index));
   70|       |
   71|      2|	return ((u64)d << 32) | a;
   72|      2|#endif
   73|      2|}
cpu_features.c:os_supports_avx512:
   93|      2|{
   94|       |#ifdef __APPLE__
   95|       |	/*
   96|       |	 * The Darwin kernel had a bug where it could corrupt the opmask
   97|       |	 * registers.  See
   98|       |	 * https://community.intel.com/t5/Software-Tuning-Performance/MacOS-Darwin-kernel-bug-clobbers-AVX-512-opmask-register-state/m-p/1327259
   99|       |	 * Darwin also does not initially set the XCR0 bits for AVX512, but they
  100|       |	 * are set if the thread tries to use AVX512 anyway.  Thus, to safely
  101|       |	 * and consistently use AVX512 on macOS we'd need to check the kernel
  102|       |	 * version as well as detect AVX512 support using a macOS-specific
  103|       |	 * method.  We don't bother with this, especially given Apple's
  104|       |	 * transition to arm64.
  105|       |	 */
  106|       |	return false;
  107|       |#else
  108|      2|	return (xcr0 & 0xe6) == 0xe6;
  109|      2|#endif
  110|      2|}

deflate_decompress.c:get_x86_cpu_features:
   61|      2|{
   62|      2|	if (libdeflate_x86_cpu_features == 0)
  ------------------
  |  Branch (62:6): [True: 2, False: 0]
  ------------------
   63|      2|		libdeflate_init_x86_cpu_features();
   64|      2|	return libdeflate_x86_cpu_features;
   65|      2|}
adler32.c:get_x86_cpu_features:
   61|      2|{
   62|      2|	if (libdeflate_x86_cpu_features == 0)
  ------------------
  |  Branch (62:6): [True: 0, False: 2]
  ------------------
   63|      0|		libdeflate_init_x86_cpu_features();
   64|      2|	return libdeflate_x86_cpu_features;
   65|      2|}

deflate_decompress.c:arch_select_decompress_func:
   47|      2|{
   48|      2|#ifdef deflate_decompress_bmi2
   49|      2|	if (HAVE_BMI2(get_x86_cpu_features()))
  ------------------
  |  |  134|      2|#  define HAVE_BMI2(features)		((features) & X86_CPU_FEATURE_BMI2)
  |  |  ------------------
  |  |  |  |   39|      2|#define X86_CPU_FEATURE_BMI2		(1 << 4)
  |  |  ------------------
  |  |  |  Branch (134:32): [True: 2, False: 0]
  |  |  ------------------
  ------------------
   50|      2|		return deflate_decompress_bmi2;
  ------------------
  |  |   19|      2|#  define deflate_decompress_bmi2	deflate_decompress_bmi2
  ------------------
   51|      0|#endif
   52|      0|	return NULL;
   53|      2|}

libdeflate_zlib_decompress_ex:
   37|  1.51k|{
   38|  1.51k|	const u8 *in_next = in;
   39|  1.51k|	const u8 * const in_end = in_next + in_nbytes;
   40|  1.51k|	u16 hdr;
   41|  1.51k|	size_t actual_in_nbytes;
   42|  1.51k|	size_t actual_out_nbytes;
   43|  1.51k|	enum libdeflate_result result;
   44|       |
   45|  1.51k|	if (in_nbytes < ZLIB_MIN_OVERHEAD)
  ------------------
  |  |   10|  1.51k|#define ZLIB_MIN_OVERHEAD	(ZLIB_MIN_HEADER_SIZE + ZLIB_FOOTER_SIZE)
  |  |  ------------------
  |  |  |  |    8|  1.51k|#define ZLIB_MIN_HEADER_SIZE	2
  |  |  ------------------
  |  |               #define ZLIB_MIN_OVERHEAD	(ZLIB_MIN_HEADER_SIZE + ZLIB_FOOTER_SIZE)
  |  |  ------------------
  |  |  |  |    9|  1.51k|#define ZLIB_FOOTER_SIZE	4
  |  |  ------------------
  ------------------
  |  Branch (45:6): [True: 0, False: 1.51k]
  ------------------
   46|      0|		return LIBDEFLATE_BAD_DATA;
   47|       |
   48|       |	/* 2 byte header: CMF and FLG  */
   49|  1.51k|	hdr = get_unaligned_be16(in_next);
   50|  1.51k|	in_next += 2;
   51|       |
   52|       |	/* FCHECK */
   53|  1.51k|	if ((hdr % 31) != 0)
  ------------------
  |  Branch (53:6): [True: 0, False: 1.51k]
  ------------------
   54|      0|		return LIBDEFLATE_BAD_DATA;
   55|       |
   56|       |	/* CM */
   57|  1.51k|	if (((hdr >> 8) & 0xF) != ZLIB_CM_DEFLATE)
  ------------------
  |  |   12|  1.51k|#define ZLIB_CM_DEFLATE		8
  ------------------
  |  Branch (57:6): [True: 0, False: 1.51k]
  ------------------
   58|      0|		return LIBDEFLATE_BAD_DATA;
   59|       |
   60|       |	/* CINFO */
   61|  1.51k|	if ((hdr >> 12) > ZLIB_CINFO_32K_WINDOW)
  ------------------
  |  |   14|  1.51k|#define ZLIB_CINFO_32K_WINDOW	7
  ------------------
  |  Branch (61:6): [True: 0, False: 1.51k]
  ------------------
   62|      0|		return LIBDEFLATE_BAD_DATA;
   63|       |
   64|       |	/* FDICT */
   65|  1.51k|	if ((hdr >> 5) & 1)
  ------------------
  |  Branch (65:6): [True: 0, False: 1.51k]
  ------------------
   66|      0|		return LIBDEFLATE_BAD_DATA;
   67|       |
   68|       |	/* Compressed data  */
   69|  1.51k|	result = libdeflate_deflate_decompress_ex(d, in_next,
   70|  1.51k|					in_end - ZLIB_FOOTER_SIZE - in_next,
  ------------------
  |  |    9|  1.51k|#define ZLIB_FOOTER_SIZE	4
  ------------------
   71|  1.51k|					out, out_nbytes_avail,
   72|  1.51k|					&actual_in_nbytes, actual_out_nbytes_ret);
   73|  1.51k|	if (result != LIBDEFLATE_SUCCESS)
  ------------------
  |  Branch (73:6): [True: 0, False: 1.51k]
  ------------------
   74|      0|		return result;
   75|       |
   76|  1.51k|	if (actual_out_nbytes_ret)
  ------------------
  |  Branch (76:6): [True: 1.51k, False: 0]
  ------------------
   77|  1.51k|		actual_out_nbytes = *actual_out_nbytes_ret;
   78|      0|	else
   79|      0|		actual_out_nbytes = out_nbytes_avail;
   80|       |
   81|  1.51k|	in_next += actual_in_nbytes;
   82|       |
   83|       |	/* ADLER32  */
   84|  1.51k|	if (libdeflate_adler32(1, out, actual_out_nbytes) !=
  ------------------
  |  Branch (84:6): [True: 0, False: 1.51k]
  ------------------
   85|  1.51k|	    get_unaligned_be32(in_next))
   86|      0|		return LIBDEFLATE_BAD_DATA;
   87|  1.51k|	in_next += 4;
   88|       |
   89|  1.51k|	if (actual_in_nbytes_ret)
  ------------------
  |  Branch (89:6): [True: 0, False: 1.51k]
  ------------------
   90|      0|		*actual_in_nbytes_ret = in_next - (u8 *)in;
   91|       |
   92|  1.51k|	return LIBDEFLATE_SUCCESS;
   93|  1.51k|}
libdeflate_zlib_decompress:
  100|  1.51k|{
  101|  1.51k|	return libdeflate_zlib_decompress_ex(d, in, in_nbytes,
  102|  1.51k|					     out, out_nbytes_avail,
  103|       |					     NULL, actual_out_nbytes_ret);
  104|  1.51k|}

